LLVM  3.7.0
InstructionSimplify.cpp
Go to the documentation of this file.
1 //===- InstructionSimplify.cpp - Fold instruction operands ----------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements routines for folding instructions into simpler forms
11 // that do not require creating new instructions. This does constant folding
12 // ("add i32 1, 1" -> "2") but can also handle non-constant operands, either
13 // returning a constant ("and i32 %x, 0" -> "0") or an already existing value
14 // ("and i32 %x, %x" -> "%x"). All operands are assumed to have already been
15 // simplified: This is usually true and assuming it simplifies the logic (if
16 // they have not been simplified then results are correct but maybe suboptimal).
17 //
18 //===----------------------------------------------------------------------===//
19 
21 #include "llvm/ADT/SetVector.h"
22 #include "llvm/ADT/Statistic.h"
28 #include "llvm/IR/ConstantRange.h"
29 #include "llvm/IR/DataLayout.h"
30 #include "llvm/IR/Dominators.h"
32 #include "llvm/IR/GlobalAlias.h"
33 #include "llvm/IR/Operator.h"
34 #include "llvm/IR/PatternMatch.h"
35 #include "llvm/IR/ValueHandle.h"
36 #include <algorithm>
37 using namespace llvm;
38 using namespace llvm::PatternMatch;
39 
40 #define DEBUG_TYPE "instsimplify"
41 
42 enum { RecursionLimit = 3 };
43 
44 STATISTIC(NumExpand, "Number of expansions");
45 STATISTIC(NumReassoc, "Number of reassociations");
46 
47 namespace {
48 struct Query {
49  const DataLayout &DL;
50  const TargetLibraryInfo *TLI;
51  const DominatorTree *DT;
52  AssumptionCache *AC;
53  const Instruction *CxtI;
54 
55  Query(const DataLayout &DL, const TargetLibraryInfo *tli,
56  const DominatorTree *dt, AssumptionCache *ac = nullptr,
57  const Instruction *cxti = nullptr)
58  : DL(DL), TLI(tli), DT(dt), AC(ac), CxtI(cxti) {}
59 };
60 } // end anonymous namespace
61 
62 static Value *SimplifyAndInst(Value *, Value *, const Query &, unsigned);
63 static Value *SimplifyBinOp(unsigned, Value *, Value *, const Query &,
64  unsigned);
65 static Value *SimplifyFPBinOp(unsigned, Value *, Value *, const FastMathFlags &,
66  const Query &, unsigned);
67 static Value *SimplifyCmpInst(unsigned, Value *, Value *, const Query &,
68  unsigned);
69 static Value *SimplifyOrInst(Value *, Value *, const Query &, unsigned);
70 static Value *SimplifyXorInst(Value *, Value *, const Query &, unsigned);
71 static Value *SimplifyTruncInst(Value *, Type *, const Query &, unsigned);
72 
73 /// getFalse - For a boolean type, or a vector of boolean type, return false, or
74 /// a vector with every element false, as appropriate for the type.
75 static Constant *getFalse(Type *Ty) {
76  assert(Ty->getScalarType()->isIntegerTy(1) &&
77  "Expected i1 type or a vector of i1!");
78  return Constant::getNullValue(Ty);
79 }
80 
81 /// getTrue - For a boolean type, or a vector of boolean type, return true, or
82 /// a vector with every element true, as appropriate for the type.
83 static Constant *getTrue(Type *Ty) {
84  assert(Ty->getScalarType()->isIntegerTy(1) &&
85  "Expected i1 type or a vector of i1!");
86  return Constant::getAllOnesValue(Ty);
87 }
88 
89 /// isSameCompare - Is V equivalent to the comparison "LHS Pred RHS"?
90 static bool isSameCompare(Value *V, CmpInst::Predicate Pred, Value *LHS,
91  Value *RHS) {
92  CmpInst *Cmp = dyn_cast<CmpInst>(V);
93  if (!Cmp)
94  return false;
95  CmpInst::Predicate CPred = Cmp->getPredicate();
96  Value *CLHS = Cmp->getOperand(0), *CRHS = Cmp->getOperand(1);
97  if (CPred == Pred && CLHS == LHS && CRHS == RHS)
98  return true;
99  return CPred == CmpInst::getSwappedPredicate(Pred) && CLHS == RHS &&
100  CRHS == LHS;
101 }
102 
103 /// ValueDominatesPHI - Does the given value dominate the specified phi node?
104 static bool ValueDominatesPHI(Value *V, PHINode *P, const DominatorTree *DT) {
106  if (!I)
107  // Arguments and constants dominate all instructions.
108  return true;
109 
110  // If we are processing instructions (and/or basic blocks) that have not been
111  // fully added to a function, the parent nodes may still be null. Simply
112  // return the conservative answer in these cases.
113  if (!I->getParent() || !P->getParent() || !I->getParent()->getParent())
114  return false;
115 
116  // If we have a DominatorTree then do a precise test.
117  if (DT) {
118  if (!DT->isReachableFromEntry(P->getParent()))
119  return true;
120  if (!DT->isReachableFromEntry(I->getParent()))
121  return false;
122  return DT->dominates(I, P);
123  }
124 
125  // Otherwise, if the instruction is in the entry block, and is not an invoke,
126  // then it obviously dominates all phi nodes.
127  if (I->getParent() == &I->getParent()->getParent()->getEntryBlock() &&
128  !isa<InvokeInst>(I))
129  return true;
130 
131  return false;
132 }
133 
134 /// ExpandBinOp - Simplify "A op (B op' C)" by distributing op over op', turning
135 /// it into "(A op B) op' (A op C)". Here "op" is given by Opcode and "op'" is
136 /// given by OpcodeToExpand, while "A" corresponds to LHS and "B op' C" to RHS.
137 /// Also performs the transform "(A op' B) op C" -> "(A op C) op' (B op C)".
138 /// Returns the simplified value, or null if no simplification was performed.
139 static Value *ExpandBinOp(unsigned Opcode, Value *LHS, Value *RHS,
140  unsigned OpcToExpand, const Query &Q,
141  unsigned MaxRecurse) {
142  Instruction::BinaryOps OpcodeToExpand = (Instruction::BinaryOps)OpcToExpand;
143  // Recursion is always used, so bail out at once if we already hit the limit.
144  if (!MaxRecurse--)
145  return nullptr;
146 
147  // Check whether the expression has the form "(A op' B) op C".
148  if (BinaryOperator *Op0 = dyn_cast<BinaryOperator>(LHS))
149  if (Op0->getOpcode() == OpcodeToExpand) {
150  // It does! Try turning it into "(A op C) op' (B op C)".
151  Value *A = Op0->getOperand(0), *B = Op0->getOperand(1), *C = RHS;
152  // Do "A op C" and "B op C" both simplify?
153  if (Value *L = SimplifyBinOp(Opcode, A, C, Q, MaxRecurse))
154  if (Value *R = SimplifyBinOp(Opcode, B, C, Q, MaxRecurse)) {
155  // They do! Return "L op' R" if it simplifies or is already available.
156  // If "L op' R" equals "A op' B" then "L op' R" is just the LHS.
157  if ((L == A && R == B) || (Instruction::isCommutative(OpcodeToExpand)
158  && L == B && R == A)) {
159  ++NumExpand;
160  return LHS;
161  }
162  // Otherwise return "L op' R" if it simplifies.
163  if (Value *V = SimplifyBinOp(OpcodeToExpand, L, R, Q, MaxRecurse)) {
164  ++NumExpand;
165  return V;
166  }
167  }
168  }
169 
170  // Check whether the expression has the form "A op (B op' C)".
171  if (BinaryOperator *Op1 = dyn_cast<BinaryOperator>(RHS))
172  if (Op1->getOpcode() == OpcodeToExpand) {
173  // It does! Try turning it into "(A op B) op' (A op C)".
174  Value *A = LHS, *B = Op1->getOperand(0), *C = Op1->getOperand(1);
175  // Do "A op B" and "A op C" both simplify?
176  if (Value *L = SimplifyBinOp(Opcode, A, B, Q, MaxRecurse))
177  if (Value *R = SimplifyBinOp(Opcode, A, C, Q, MaxRecurse)) {
178  // They do! Return "L op' R" if it simplifies or is already available.
179  // If "L op' R" equals "B op' C" then "L op' R" is just the RHS.
180  if ((L == B && R == C) || (Instruction::isCommutative(OpcodeToExpand)
181  && L == C && R == B)) {
182  ++NumExpand;
183  return RHS;
184  }
185  // Otherwise return "L op' R" if it simplifies.
186  if (Value *V = SimplifyBinOp(OpcodeToExpand, L, R, Q, MaxRecurse)) {
187  ++NumExpand;
188  return V;
189  }
190  }
191  }
192 
193  return nullptr;
194 }
195 
196 /// SimplifyAssociativeBinOp - Generic simplifications for associative binary
197 /// operations. Returns the simpler value, or null if none was found.
198 static Value *SimplifyAssociativeBinOp(unsigned Opc, Value *LHS, Value *RHS,
199  const Query &Q, unsigned MaxRecurse) {
201  assert(Instruction::isAssociative(Opcode) && "Not an associative operation!");
202 
203  // Recursion is always used, so bail out at once if we already hit the limit.
204  if (!MaxRecurse--)
205  return nullptr;
206 
209 
210  // Transform: "(A op B) op C" ==> "A op (B op C)" if it simplifies completely.
211  if (Op0 && Op0->getOpcode() == Opcode) {
212  Value *A = Op0->getOperand(0);
213  Value *B = Op0->getOperand(1);
214  Value *C = RHS;
215 
216  // Does "B op C" simplify?
217  if (Value *V = SimplifyBinOp(Opcode, B, C, Q, MaxRecurse)) {
218  // It does! Return "A op V" if it simplifies or is already available.
219  // If V equals B then "A op V" is just the LHS.
220  if (V == B) return LHS;
221  // Otherwise return "A op V" if it simplifies.
222  if (Value *W = SimplifyBinOp(Opcode, A, V, Q, MaxRecurse)) {
223  ++NumReassoc;
224  return W;
225  }
226  }
227  }
228 
229  // Transform: "A op (B op C)" ==> "(A op B) op C" if it simplifies completely.
230  if (Op1 && Op1->getOpcode() == Opcode) {
231  Value *A = LHS;
232  Value *B = Op1->getOperand(0);
233  Value *C = Op1->getOperand(1);
234 
235  // Does "A op B" simplify?
236  if (Value *V = SimplifyBinOp(Opcode, A, B, Q, MaxRecurse)) {
237  // It does! Return "V op C" if it simplifies or is already available.
238  // If V equals B then "V op C" is just the RHS.
239  if (V == B) return RHS;
240  // Otherwise return "V op C" if it simplifies.
241  if (Value *W = SimplifyBinOp(Opcode, V, C, Q, MaxRecurse)) {
242  ++NumReassoc;
243  return W;
244  }
245  }
246  }
247 
248  // The remaining transforms require commutativity as well as associativity.
249  if (!Instruction::isCommutative(Opcode))
250  return nullptr;
251 
252  // Transform: "(A op B) op C" ==> "(C op A) op B" if it simplifies completely.
253  if (Op0 && Op0->getOpcode() == Opcode) {
254  Value *A = Op0->getOperand(0);
255  Value *B = Op0->getOperand(1);
256  Value *C = RHS;
257 
258  // Does "C op A" simplify?
259  if (Value *V = SimplifyBinOp(Opcode, C, A, Q, MaxRecurse)) {
260  // It does! Return "V op B" if it simplifies or is already available.
261  // If V equals A then "V op B" is just the LHS.
262  if (V == A) return LHS;
263  // Otherwise return "V op B" if it simplifies.
264  if (Value *W = SimplifyBinOp(Opcode, V, B, Q, MaxRecurse)) {
265  ++NumReassoc;
266  return W;
267  }
268  }
269  }
270 
271  // Transform: "A op (B op C)" ==> "B op (C op A)" if it simplifies completely.
272  if (Op1 && Op1->getOpcode() == Opcode) {
273  Value *A = LHS;
274  Value *B = Op1->getOperand(0);
275  Value *C = Op1->getOperand(1);
276 
277  // Does "C op A" simplify?
278  if (Value *V = SimplifyBinOp(Opcode, C, A, Q, MaxRecurse)) {
279  // It does! Return "B op V" if it simplifies or is already available.
280  // If V equals C then "B op V" is just the RHS.
281  if (V == C) return RHS;
282  // Otherwise return "B op V" if it simplifies.
283  if (Value *W = SimplifyBinOp(Opcode, B, V, Q, MaxRecurse)) {
284  ++NumReassoc;
285  return W;
286  }
287  }
288  }
289 
290  return nullptr;
291 }
292 
293 /// ThreadBinOpOverSelect - In the case of a binary operation with a select
294 /// instruction as an operand, try to simplify the binop by seeing whether
295 /// evaluating it on both branches of the select results in the same value.
296 /// Returns the common value if so, otherwise returns null.
297 static Value *ThreadBinOpOverSelect(unsigned Opcode, Value *LHS, Value *RHS,
298  const Query &Q, unsigned MaxRecurse) {
299  // Recursion is always used, so bail out at once if we already hit the limit.
300  if (!MaxRecurse--)
301  return nullptr;
302 
303  SelectInst *SI;
304  if (isa<SelectInst>(LHS)) {
305  SI = cast<SelectInst>(LHS);
306  } else {
307  assert(isa<SelectInst>(RHS) && "No select instruction operand!");
308  SI = cast<SelectInst>(RHS);
309  }
310 
311  // Evaluate the BinOp on the true and false branches of the select.
312  Value *TV;
313  Value *FV;
314  if (SI == LHS) {
315  TV = SimplifyBinOp(Opcode, SI->getTrueValue(), RHS, Q, MaxRecurse);
316  FV = SimplifyBinOp(Opcode, SI->getFalseValue(), RHS, Q, MaxRecurse);
317  } else {
318  TV = SimplifyBinOp(Opcode, LHS, SI->getTrueValue(), Q, MaxRecurse);
319  FV = SimplifyBinOp(Opcode, LHS, SI->getFalseValue(), Q, MaxRecurse);
320  }
321 
322  // If they simplified to the same value, then return the common value.
323  // If they both failed to simplify then return null.
324  if (TV == FV)
325  return TV;
326 
327  // If one branch simplified to undef, return the other one.
328  if (TV && isa<UndefValue>(TV))
329  return FV;
330  if (FV && isa<UndefValue>(FV))
331  return TV;
332 
333  // If applying the operation did not change the true and false select values,
334  // then the result of the binop is the select itself.
335  if (TV == SI->getTrueValue() && FV == SI->getFalseValue())
336  return SI;
337 
338  // If one branch simplified and the other did not, and the simplified
339  // value is equal to the unsimplified one, return the simplified value.
340  // For example, select (cond, X, X & Z) & Z -> X & Z.
341  if ((FV && !TV) || (TV && !FV)) {
342  // Check that the simplified value has the form "X op Y" where "op" is the
343  // same as the original operation.
344  Instruction *Simplified = dyn_cast<Instruction>(FV ? FV : TV);
345  if (Simplified && Simplified->getOpcode() == Opcode) {
346  // The value that didn't simplify is "UnsimplifiedLHS op UnsimplifiedRHS".
347  // We already know that "op" is the same as for the simplified value. See
348  // if the operands match too. If so, return the simplified value.
349  Value *UnsimplifiedBranch = FV ? SI->getTrueValue() : SI->getFalseValue();
350  Value *UnsimplifiedLHS = SI == LHS ? UnsimplifiedBranch : LHS;
351  Value *UnsimplifiedRHS = SI == LHS ? RHS : UnsimplifiedBranch;
352  if (Simplified->getOperand(0) == UnsimplifiedLHS &&
353  Simplified->getOperand(1) == UnsimplifiedRHS)
354  return Simplified;
355  if (Simplified->isCommutative() &&
356  Simplified->getOperand(1) == UnsimplifiedLHS &&
357  Simplified->getOperand(0) == UnsimplifiedRHS)
358  return Simplified;
359  }
360  }
361 
362  return nullptr;
363 }
364 
365 /// ThreadCmpOverSelect - In the case of a comparison with a select instruction,
366 /// try to simplify the comparison by seeing whether both branches of the select
367 /// result in the same value. Returns the common value if so, otherwise returns
368 /// null.
370  Value *RHS, const Query &Q,
371  unsigned MaxRecurse) {
372  // Recursion is always used, so bail out at once if we already hit the limit.
373  if (!MaxRecurse--)
374  return nullptr;
375 
376  // Make sure the select is on the LHS.
377  if (!isa<SelectInst>(LHS)) {
378  std::swap(LHS, RHS);
379  Pred = CmpInst::getSwappedPredicate(Pred);
380  }
381  assert(isa<SelectInst>(LHS) && "Not comparing with a select instruction!");
382  SelectInst *SI = cast<SelectInst>(LHS);
383  Value *Cond = SI->getCondition();
384  Value *TV = SI->getTrueValue();
385  Value *FV = SI->getFalseValue();
386 
387  // Now that we have "cmp select(Cond, TV, FV), RHS", analyse it.
388  // Does "cmp TV, RHS" simplify?
389  Value *TCmp = SimplifyCmpInst(Pred, TV, RHS, Q, MaxRecurse);
390  if (TCmp == Cond) {
391  // It not only simplified, it simplified to the select condition. Replace
392  // it with 'true'.
393  TCmp = getTrue(Cond->getType());
394  } else if (!TCmp) {
395  // It didn't simplify. However if "cmp TV, RHS" is equal to the select
396  // condition then we can replace it with 'true'. Otherwise give up.
397  if (!isSameCompare(Cond, Pred, TV, RHS))
398  return nullptr;
399  TCmp = getTrue(Cond->getType());
400  }
401 
402  // Does "cmp FV, RHS" simplify?
403  Value *FCmp = SimplifyCmpInst(Pred, FV, RHS, Q, MaxRecurse);
404  if (FCmp == Cond) {
405  // It not only simplified, it simplified to the select condition. Replace
406  // it with 'false'.
407  FCmp = getFalse(Cond->getType());
408  } else if (!FCmp) {
409  // It didn't simplify. However if "cmp FV, RHS" is equal to the select
410  // condition then we can replace it with 'false'. Otherwise give up.
411  if (!isSameCompare(Cond, Pred, FV, RHS))
412  return nullptr;
413  FCmp = getFalse(Cond->getType());
414  }
415 
416  // If both sides simplified to the same value, then use it as the result of
417  // the original comparison.
418  if (TCmp == FCmp)
419  return TCmp;
420 
421  // The remaining cases only make sense if the select condition has the same
422  // type as the result of the comparison, so bail out if this is not so.
423  if (Cond->getType()->isVectorTy() != RHS->getType()->isVectorTy())
424  return nullptr;
425  // If the false value simplified to false, then the result of the compare
426  // is equal to "Cond && TCmp". This also catches the case when the false
427  // value simplified to false and the true value to true, returning "Cond".
428  if (match(FCmp, m_Zero()))
429  if (Value *V = SimplifyAndInst(Cond, TCmp, Q, MaxRecurse))
430  return V;
431  // If the true value simplified to true, then the result of the compare
432  // is equal to "Cond || FCmp".
433  if (match(TCmp, m_One()))
434  if (Value *V = SimplifyOrInst(Cond, FCmp, Q, MaxRecurse))
435  return V;
436  // Finally, if the false value simplified to true and the true value to
437  // false, then the result of the compare is equal to "!Cond".
438  if (match(FCmp, m_One()) && match(TCmp, m_Zero()))
439  if (Value *V =
440  SimplifyXorInst(Cond, Constant::getAllOnesValue(Cond->getType()),
441  Q, MaxRecurse))
442  return V;
443 
444  return nullptr;
445 }
446 
447 /// ThreadBinOpOverPHI - In the case of a binary operation with an operand that
448 /// is a PHI instruction, try to simplify the binop by seeing whether evaluating
449 /// it on the incoming phi values yields the same result for every value. If so
450 /// returns the common value, otherwise returns null.
451 static Value *ThreadBinOpOverPHI(unsigned Opcode, Value *LHS, Value *RHS,
452  const Query &Q, unsigned MaxRecurse) {
453  // Recursion is always used, so bail out at once if we already hit the limit.
454  if (!MaxRecurse--)
455  return nullptr;
456 
457  PHINode *PI;
458  if (isa<PHINode>(LHS)) {
459  PI = cast<PHINode>(LHS);
460  // Bail out if RHS and the phi may be mutually interdependent due to a loop.
461  if (!ValueDominatesPHI(RHS, PI, Q.DT))
462  return nullptr;
463  } else {
464  assert(isa<PHINode>(RHS) && "No PHI instruction operand!");
465  PI = cast<PHINode>(RHS);
466  // Bail out if LHS and the phi may be mutually interdependent due to a loop.
467  if (!ValueDominatesPHI(LHS, PI, Q.DT))
468  return nullptr;
469  }
470 
471  // Evaluate the BinOp on the incoming phi values.
472  Value *CommonValue = nullptr;
473  for (Value *Incoming : PI->incoming_values()) {
474  // If the incoming value is the phi node itself, it can safely be skipped.
475  if (Incoming == PI) continue;
476  Value *V = PI == LHS ?
477  SimplifyBinOp(Opcode, Incoming, RHS, Q, MaxRecurse) :
478  SimplifyBinOp(Opcode, LHS, Incoming, Q, MaxRecurse);
479  // If the operation failed to simplify, or simplified to a different value
480  // to previously, then give up.
481  if (!V || (CommonValue && V != CommonValue))
482  return nullptr;
483  CommonValue = V;
484  }
485 
486  return CommonValue;
487 }
488 
489 /// ThreadCmpOverPHI - In the case of a comparison with a PHI instruction, try
490 /// try to simplify the comparison by seeing whether comparing with all of the
491 /// incoming phi values yields the same result every time. If so returns the
492 /// common result, otherwise returns null.
494  const Query &Q, unsigned MaxRecurse) {
495  // Recursion is always used, so bail out at once if we already hit the limit.
496  if (!MaxRecurse--)
497  return nullptr;
498 
499  // Make sure the phi is on the LHS.
500  if (!isa<PHINode>(LHS)) {
501  std::swap(LHS, RHS);
502  Pred = CmpInst::getSwappedPredicate(Pred);
503  }
504  assert(isa<PHINode>(LHS) && "Not comparing with a phi instruction!");
505  PHINode *PI = cast<PHINode>(LHS);
506 
507  // Bail out if RHS and the phi may be mutually interdependent due to a loop.
508  if (!ValueDominatesPHI(RHS, PI, Q.DT))
509  return nullptr;
510 
511  // Evaluate the BinOp on the incoming phi values.
512  Value *CommonValue = nullptr;
513  for (Value *Incoming : PI->incoming_values()) {
514  // If the incoming value is the phi node itself, it can safely be skipped.
515  if (Incoming == PI) continue;
516  Value *V = SimplifyCmpInst(Pred, Incoming, RHS, Q, MaxRecurse);
517  // If the operation failed to simplify, or simplified to a different value
518  // to previously, then give up.
519  if (!V || (CommonValue && V != CommonValue))
520  return nullptr;
521  CommonValue = V;
522  }
523 
524  return CommonValue;
525 }
526 
527 /// SimplifyAddInst - Given operands for an Add, see if we can
528 /// fold the result. If not, this returns null.
529 static Value *SimplifyAddInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW,
530  const Query &Q, unsigned MaxRecurse) {
531  if (Constant *CLHS = dyn_cast<Constant>(Op0)) {
532  if (Constant *CRHS = dyn_cast<Constant>(Op1)) {
533  Constant *Ops[] = { CLHS, CRHS };
534  return ConstantFoldInstOperands(Instruction::Add, CLHS->getType(), Ops,
535  Q.DL, Q.TLI);
536  }
537 
538  // Canonicalize the constant to the RHS.
539  std::swap(Op0, Op1);
540  }
541 
542  // X + undef -> undef
543  if (match(Op1, m_Undef()))
544  return Op1;
545 
546  // X + 0 -> X
547  if (match(Op1, m_Zero()))
548  return Op0;
549 
550  // X + (Y - X) -> Y
551  // (Y - X) + X -> Y
552  // Eg: X + -X -> 0
553  Value *Y = nullptr;
554  if (match(Op1, m_Sub(m_Value(Y), m_Specific(Op0))) ||
555  match(Op0, m_Sub(m_Value(Y), m_Specific(Op1))))
556  return Y;
557 
558  // X + ~X -> -1 since ~X = -X-1
559  if (match(Op0, m_Not(m_Specific(Op1))) ||
560  match(Op1, m_Not(m_Specific(Op0))))
561  return Constant::getAllOnesValue(Op0->getType());
562 
563  /// i1 add -> xor.
564  if (MaxRecurse && Op0->getType()->isIntegerTy(1))
565  if (Value *V = SimplifyXorInst(Op0, Op1, Q, MaxRecurse-1))
566  return V;
567 
568  // Try some generic simplifications for associative operations.
569  if (Value *V = SimplifyAssociativeBinOp(Instruction::Add, Op0, Op1, Q,
570  MaxRecurse))
571  return V;
572 
573  // Threading Add over selects and phi nodes is pointless, so don't bother.
574  // Threading over the select in "A + select(cond, B, C)" means evaluating
575  // "A+B" and "A+C" and seeing if they are equal; but they are equal if and
576  // only if B and C are equal. If B and C are equal then (since we assume
577  // that operands have already been simplified) "select(cond, B, C)" should
578  // have been simplified to the common value of B and C already. Analysing
579  // "A+B" and "A+C" thus gains nothing, but costs compile time. Similarly
580  // for threading over phi nodes.
581 
582  return nullptr;
583 }
584 
585 Value *llvm::SimplifyAddInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW,
586  const DataLayout &DL, const TargetLibraryInfo *TLI,
587  const DominatorTree *DT, AssumptionCache *AC,
588  const Instruction *CxtI) {
589  return ::SimplifyAddInst(Op0, Op1, isNSW, isNUW, Query(DL, TLI, DT, AC, CxtI),
591 }
592 
593 /// \brief Compute the base pointer and cumulative constant offsets for V.
594 ///
595 /// This strips all constant offsets off of V, leaving it the base pointer, and
596 /// accumulates the total constant offset applied in the returned constant. It
597 /// returns 0 if V is not a pointer, and returns the constant '0' if there are
598 /// no constant offsets applied.
599 ///
600 /// This is very similar to GetPointerBaseWithConstantOffset except it doesn't
601 /// follow non-inbounds geps. This allows it to remain usable for icmp ult/etc.
602 /// folding.
604  bool AllowNonInbounds = false) {
605  assert(V->getType()->getScalarType()->isPointerTy());
606 
607  Type *IntPtrTy = DL.getIntPtrType(V->getType())->getScalarType();
608  APInt Offset = APInt::getNullValue(IntPtrTy->getIntegerBitWidth());
609 
610  // Even though we don't look through PHI nodes, we could be called on an
611  // instruction in an unreachable block, which may be on a cycle.
612  SmallPtrSet<Value *, 4> Visited;
613  Visited.insert(V);
614  do {
615  if (GEPOperator *GEP = dyn_cast<GEPOperator>(V)) {
616  if ((!AllowNonInbounds && !GEP->isInBounds()) ||
617  !GEP->accumulateConstantOffset(DL, Offset))
618  break;
619  V = GEP->getPointerOperand();
620  } else if (Operator::getOpcode(V) == Instruction::BitCast) {
621  V = cast<Operator>(V)->getOperand(0);
622  } else if (GlobalAlias *GA = dyn_cast<GlobalAlias>(V)) {
623  if (GA->mayBeOverridden())
624  break;
625  V = GA->getAliasee();
626  } else {
627  break;
628  }
629  assert(V->getType()->getScalarType()->isPointerTy() &&
630  "Unexpected operand type!");
631  } while (Visited.insert(V).second);
632 
633  Constant *OffsetIntPtr = ConstantInt::get(IntPtrTy, Offset);
634  if (V->getType()->isVectorTy())
636  OffsetIntPtr);
637  return OffsetIntPtr;
638 }
639 
640 /// \brief Compute the constant difference between two pointer values.
641 /// If the difference is not a constant, returns zero.
643  Value *RHS) {
644  Constant *LHSOffset = stripAndComputeConstantOffsets(DL, LHS);
645  Constant *RHSOffset = stripAndComputeConstantOffsets(DL, RHS);
646 
647  // If LHS and RHS are not related via constant offsets to the same base
648  // value, there is nothing we can do here.
649  if (LHS != RHS)
650  return nullptr;
651 
652  // Otherwise, the difference of LHS - RHS can be computed as:
653  // LHS - RHS
654  // = (LHSOffset + Base) - (RHSOffset + Base)
655  // = LHSOffset - RHSOffset
656  return ConstantExpr::getSub(LHSOffset, RHSOffset);
657 }
658 
659 /// SimplifySubInst - Given operands for a Sub, see if we can
660 /// fold the result. If not, this returns null.
661 static Value *SimplifySubInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW,
662  const Query &Q, unsigned MaxRecurse) {
663  if (Constant *CLHS = dyn_cast<Constant>(Op0))
664  if (Constant *CRHS = dyn_cast<Constant>(Op1)) {
665  Constant *Ops[] = { CLHS, CRHS };
666  return ConstantFoldInstOperands(Instruction::Sub, CLHS->getType(),
667  Ops, Q.DL, Q.TLI);
668  }
669 
670  // X - undef -> undef
671  // undef - X -> undef
672  if (match(Op0, m_Undef()) || match(Op1, m_Undef()))
673  return UndefValue::get(Op0->getType());
674 
675  // X - 0 -> X
676  if (match(Op1, m_Zero()))
677  return Op0;
678 
679  // X - X -> 0
680  if (Op0 == Op1)
681  return Constant::getNullValue(Op0->getType());
682 
683  // 0 - X -> 0 if the sub is NUW.
684  if (isNUW && match(Op0, m_Zero()))
685  return Op0;
686 
687  // (X + Y) - Z -> X + (Y - Z) or Y + (X - Z) if everything simplifies.
688  // For example, (X + Y) - Y -> X; (Y + X) - Y -> X
689  Value *X = nullptr, *Y = nullptr, *Z = Op1;
690  if (MaxRecurse && match(Op0, m_Add(m_Value(X), m_Value(Y)))) { // (X + Y) - Z
691  // See if "V === Y - Z" simplifies.
692  if (Value *V = SimplifyBinOp(Instruction::Sub, Y, Z, Q, MaxRecurse-1))
693  // It does! Now see if "X + V" simplifies.
694  if (Value *W = SimplifyBinOp(Instruction::Add, X, V, Q, MaxRecurse-1)) {
695  // It does, we successfully reassociated!
696  ++NumReassoc;
697  return W;
698  }
699  // See if "V === X - Z" simplifies.
700  if (Value *V = SimplifyBinOp(Instruction::Sub, X, Z, Q, MaxRecurse-1))
701  // It does! Now see if "Y + V" simplifies.
702  if (Value *W = SimplifyBinOp(Instruction::Add, Y, V, Q, MaxRecurse-1)) {
703  // It does, we successfully reassociated!
704  ++NumReassoc;
705  return W;
706  }
707  }
708 
709  // X - (Y + Z) -> (X - Y) - Z or (X - Z) - Y if everything simplifies.
710  // For example, X - (X + 1) -> -1
711  X = Op0;
712  if (MaxRecurse && match(Op1, m_Add(m_Value(Y), m_Value(Z)))) { // X - (Y + Z)
713  // See if "V === X - Y" simplifies.
714  if (Value *V = SimplifyBinOp(Instruction::Sub, X, Y, Q, MaxRecurse-1))
715  // It does! Now see if "V - Z" simplifies.
716  if (Value *W = SimplifyBinOp(Instruction::Sub, V, Z, Q, MaxRecurse-1)) {
717  // It does, we successfully reassociated!
718  ++NumReassoc;
719  return W;
720  }
721  // See if "V === X - Z" simplifies.
722  if (Value *V = SimplifyBinOp(Instruction::Sub, X, Z, Q, MaxRecurse-1))
723  // It does! Now see if "V - Y" simplifies.
724  if (Value *W = SimplifyBinOp(Instruction::Sub, V, Y, Q, MaxRecurse-1)) {
725  // It does, we successfully reassociated!
726  ++NumReassoc;
727  return W;
728  }
729  }
730 
731  // Z - (X - Y) -> (Z - X) + Y if everything simplifies.
732  // For example, X - (X - Y) -> Y.
733  Z = Op0;
734  if (MaxRecurse && match(Op1, m_Sub(m_Value(X), m_Value(Y)))) // Z - (X - Y)
735  // See if "V === Z - X" simplifies.
736  if (Value *V = SimplifyBinOp(Instruction::Sub, Z, X, Q, MaxRecurse-1))
737  // It does! Now see if "V + Y" simplifies.
738  if (Value *W = SimplifyBinOp(Instruction::Add, V, Y, Q, MaxRecurse-1)) {
739  // It does, we successfully reassociated!
740  ++NumReassoc;
741  return W;
742  }
743 
744  // trunc(X) - trunc(Y) -> trunc(X - Y) if everything simplifies.
745  if (MaxRecurse && match(Op0, m_Trunc(m_Value(X))) &&
746  match(Op1, m_Trunc(m_Value(Y))))
747  if (X->getType() == Y->getType())
748  // See if "V === X - Y" simplifies.
749  if (Value *V = SimplifyBinOp(Instruction::Sub, X, Y, Q, MaxRecurse-1))
750  // It does! Now see if "trunc V" simplifies.
751  if (Value *W = SimplifyTruncInst(V, Op0->getType(), Q, MaxRecurse-1))
752  // It does, return the simplified "trunc V".
753  return W;
754 
755  // Variations on GEP(base, I, ...) - GEP(base, i, ...) -> GEP(null, I-i, ...).
756  if (match(Op0, m_PtrToInt(m_Value(X))) &&
757  match(Op1, m_PtrToInt(m_Value(Y))))
758  if (Constant *Result = computePointerDifference(Q.DL, X, Y))
759  return ConstantExpr::getIntegerCast(Result, Op0->getType(), true);
760 
761  // i1 sub -> xor.
762  if (MaxRecurse && Op0->getType()->isIntegerTy(1))
763  if (Value *V = SimplifyXorInst(Op0, Op1, Q, MaxRecurse-1))
764  return V;
765 
766  // Threading Sub over selects and phi nodes is pointless, so don't bother.
767  // Threading over the select in "A - select(cond, B, C)" means evaluating
768  // "A-B" and "A-C" and seeing if they are equal; but they are equal if and
769  // only if B and C are equal. If B and C are equal then (since we assume
770  // that operands have already been simplified) "select(cond, B, C)" should
771  // have been simplified to the common value of B and C already. Analysing
772  // "A-B" and "A-C" thus gains nothing, but costs compile time. Similarly
773  // for threading over phi nodes.
774 
775  return nullptr;
776 }
777 
778 Value *llvm::SimplifySubInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW,
779  const DataLayout &DL, const TargetLibraryInfo *TLI,
780  const DominatorTree *DT, AssumptionCache *AC,
781  const Instruction *CxtI) {
782  return ::SimplifySubInst(Op0, Op1, isNSW, isNUW, Query(DL, TLI, DT, AC, CxtI),
784 }
785 
786 /// Given operands for an FAdd, see if we can fold the result. If not, this
787 /// returns null.
789  const Query &Q, unsigned MaxRecurse) {
790  if (Constant *CLHS = dyn_cast<Constant>(Op0)) {
791  if (Constant *CRHS = dyn_cast<Constant>(Op1)) {
792  Constant *Ops[] = { CLHS, CRHS };
793  return ConstantFoldInstOperands(Instruction::FAdd, CLHS->getType(),
794  Ops, Q.DL, Q.TLI);
795  }
796 
797  // Canonicalize the constant to the RHS.
798  std::swap(Op0, Op1);
799  }
800 
801  // fadd X, -0 ==> X
802  if (match(Op1, m_NegZero()))
803  return Op0;
804 
805  // fadd X, 0 ==> X, when we know X is not -0
806  if (match(Op1, m_Zero()) &&
807  (FMF.noSignedZeros() || CannotBeNegativeZero(Op0)))
808  return Op0;
809 
810  // fadd [nnan ninf] X, (fsub [nnan ninf] 0, X) ==> 0
811  // where nnan and ninf have to occur at least once somewhere in this
812  // expression
813  Value *SubOp = nullptr;
814  if (match(Op1, m_FSub(m_AnyZero(), m_Specific(Op0))))
815  SubOp = Op1;
816  else if (match(Op0, m_FSub(m_AnyZero(), m_Specific(Op1))))
817  SubOp = Op0;
818  if (SubOp) {
819  Instruction *FSub = cast<Instruction>(SubOp);
820  if ((FMF.noNaNs() || FSub->hasNoNaNs()) &&
821  (FMF.noInfs() || FSub->hasNoInfs()))
822  return Constant::getNullValue(Op0->getType());
823  }
824 
825  return nullptr;
826 }
827 
828 /// Given operands for an FSub, see if we can fold the result. If not, this
829 /// returns null.
831  const Query &Q, unsigned MaxRecurse) {
832  if (Constant *CLHS = dyn_cast<Constant>(Op0)) {
833  if (Constant *CRHS = dyn_cast<Constant>(Op1)) {
834  Constant *Ops[] = { CLHS, CRHS };
835  return ConstantFoldInstOperands(Instruction::FSub, CLHS->getType(),
836  Ops, Q.DL, Q.TLI);
837  }
838  }
839 
840  // fsub X, 0 ==> X
841  if (match(Op1, m_Zero()))
842  return Op0;
843 
844  // fsub X, -0 ==> X, when we know X is not -0
845  if (match(Op1, m_NegZero()) &&
846  (FMF.noSignedZeros() || CannotBeNegativeZero(Op0)))
847  return Op0;
848 
849  // fsub 0, (fsub -0.0, X) ==> X
850  Value *X;
851  if (match(Op0, m_AnyZero())) {
852  if (match(Op1, m_FSub(m_NegZero(), m_Value(X))))
853  return X;
854  if (FMF.noSignedZeros() && match(Op1, m_FSub(m_AnyZero(), m_Value(X))))
855  return X;
856  }
857 
858  // fsub nnan x, x ==> 0.0
859  if (FMF.noNaNs() && Op0 == Op1)
860  return Constant::getNullValue(Op0->getType());
861 
862  return nullptr;
863 }
864 
865 /// Given the operands for an FMul, see if we can fold the result
866 static Value *SimplifyFMulInst(Value *Op0, Value *Op1,
867  FastMathFlags FMF,
868  const Query &Q,
869  unsigned MaxRecurse) {
870  if (Constant *CLHS = dyn_cast<Constant>(Op0)) {
871  if (Constant *CRHS = dyn_cast<Constant>(Op1)) {
872  Constant *Ops[] = { CLHS, CRHS };
873  return ConstantFoldInstOperands(Instruction::FMul, CLHS->getType(),
874  Ops, Q.DL, Q.TLI);
875  }
876 
877  // Canonicalize the constant to the RHS.
878  std::swap(Op0, Op1);
879  }
880 
881  // fmul X, 1.0 ==> X
882  if (match(Op1, m_FPOne()))
883  return Op0;
884 
885  // fmul nnan nsz X, 0 ==> 0
886  if (FMF.noNaNs() && FMF.noSignedZeros() && match(Op1, m_AnyZero()))
887  return Op1;
888 
889  return nullptr;
890 }
891 
892 /// SimplifyMulInst - Given operands for a Mul, see if we can
893 /// fold the result. If not, this returns null.
894 static Value *SimplifyMulInst(Value *Op0, Value *Op1, const Query &Q,
895  unsigned MaxRecurse) {
896  if (Constant *CLHS = dyn_cast<Constant>(Op0)) {
897  if (Constant *CRHS = dyn_cast<Constant>(Op1)) {
898  Constant *Ops[] = { CLHS, CRHS };
899  return ConstantFoldInstOperands(Instruction::Mul, CLHS->getType(),
900  Ops, Q.DL, Q.TLI);
901  }
902 
903  // Canonicalize the constant to the RHS.
904  std::swap(Op0, Op1);
905  }
906 
907  // X * undef -> 0
908  if (match(Op1, m_Undef()))
909  return Constant::getNullValue(Op0->getType());
910 
911  // X * 0 -> 0
912  if (match(Op1, m_Zero()))
913  return Op1;
914 
915  // X * 1 -> X
916  if (match(Op1, m_One()))
917  return Op0;
918 
919  // (X / Y) * Y -> X if the division is exact.
920  Value *X = nullptr;
921  if (match(Op0, m_Exact(m_IDiv(m_Value(X), m_Specific(Op1)))) || // (X / Y) * Y
922  match(Op1, m_Exact(m_IDiv(m_Value(X), m_Specific(Op0))))) // Y * (X / Y)
923  return X;
924 
925  // i1 mul -> and.
926  if (MaxRecurse && Op0->getType()->isIntegerTy(1))
927  if (Value *V = SimplifyAndInst(Op0, Op1, Q, MaxRecurse-1))
928  return V;
929 
930  // Try some generic simplifications for associative operations.
931  if (Value *V = SimplifyAssociativeBinOp(Instruction::Mul, Op0, Op1, Q,
932  MaxRecurse))
933  return V;
934 
935  // Mul distributes over Add. Try some generic simplifications based on this.
936  if (Value *V = ExpandBinOp(Instruction::Mul, Op0, Op1, Instruction::Add,
937  Q, MaxRecurse))
938  return V;
939 
940  // If the operation is with the result of a select instruction, check whether
941  // operating on either branch of the select always yields the same value.
942  if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1))
943  if (Value *V = ThreadBinOpOverSelect(Instruction::Mul, Op0, Op1, Q,
944  MaxRecurse))
945  return V;
946 
947  // If the operation is with the result of a phi instruction, check whether
948  // operating on all incoming values of the phi always yields the same value.
949  if (isa<PHINode>(Op0) || isa<PHINode>(Op1))
950  if (Value *V = ThreadBinOpOverPHI(Instruction::Mul, Op0, Op1, Q,
951  MaxRecurse))
952  return V;
953 
954  return nullptr;
955 }
956 
958  const DataLayout &DL,
959  const TargetLibraryInfo *TLI,
960  const DominatorTree *DT, AssumptionCache *AC,
961  const Instruction *CxtI) {
962  return ::SimplifyFAddInst(Op0, Op1, FMF, Query(DL, TLI, DT, AC, CxtI),
964 }
965 
967  const DataLayout &DL,
968  const TargetLibraryInfo *TLI,
969  const DominatorTree *DT, AssumptionCache *AC,
970  const Instruction *CxtI) {
971  return ::SimplifyFSubInst(Op0, Op1, FMF, Query(DL, TLI, DT, AC, CxtI),
973 }
974 
976  const DataLayout &DL,
977  const TargetLibraryInfo *TLI,
978  const DominatorTree *DT, AssumptionCache *AC,
979  const Instruction *CxtI) {
980  return ::SimplifyFMulInst(Op0, Op1, FMF, Query(DL, TLI, DT, AC, CxtI),
982 }
983 
985  const TargetLibraryInfo *TLI,
986  const DominatorTree *DT, AssumptionCache *AC,
987  const Instruction *CxtI) {
988  return ::SimplifyMulInst(Op0, Op1, Query(DL, TLI, DT, AC, CxtI),
990 }
991 
992 /// SimplifyDiv - Given operands for an SDiv or UDiv, see if we can
993 /// fold the result. If not, this returns null.
995  const Query &Q, unsigned MaxRecurse) {
996  if (Constant *C0 = dyn_cast<Constant>(Op0)) {
997  if (Constant *C1 = dyn_cast<Constant>(Op1)) {
998  Constant *Ops[] = { C0, C1 };
999  return ConstantFoldInstOperands(Opcode, C0->getType(), Ops, Q.DL, Q.TLI);
1000  }
1001  }
1002 
1003  bool isSigned = Opcode == Instruction::SDiv;
1004 
1005  // X / undef -> undef
1006  if (match(Op1, m_Undef()))
1007  return Op1;
1008 
1009  // X / 0 -> undef, we don't need to preserve faults!
1010  if (match(Op1, m_Zero()))
1011  return UndefValue::get(Op1->getType());
1012 
1013  // undef / X -> 0
1014  if (match(Op0, m_Undef()))
1015  return Constant::getNullValue(Op0->getType());
1016 
1017  // 0 / X -> 0, we don't need to preserve faults!
1018  if (match(Op0, m_Zero()))
1019  return Op0;
1020 
1021  // X / 1 -> X
1022  if (match(Op1, m_One()))
1023  return Op0;
1024 
1025  if (Op0->getType()->isIntegerTy(1))
1026  // It can't be division by zero, hence it must be division by one.
1027  return Op0;
1028 
1029  // X / X -> 1
1030  if (Op0 == Op1)
1031  return ConstantInt::get(Op0->getType(), 1);
1032 
1033  // (X * Y) / Y -> X if the multiplication does not overflow.
1034  Value *X = nullptr, *Y = nullptr;
1035  if (match(Op0, m_Mul(m_Value(X), m_Value(Y))) && (X == Op1 || Y == Op1)) {
1036  if (Y != Op1) std::swap(X, Y); // Ensure expression is (X * Y) / Y, Y = Op1
1037  OverflowingBinaryOperator *Mul = cast<OverflowingBinaryOperator>(Op0);
1038  // If the Mul knows it does not overflow, then we are good to go.
1039  if ((isSigned && Mul->hasNoSignedWrap()) ||
1040  (!isSigned && Mul->hasNoUnsignedWrap()))
1041  return X;
1042  // If X has the form X = A / Y then X * Y cannot overflow.
1043  if (BinaryOperator *Div = dyn_cast<BinaryOperator>(X))
1044  if (Div->getOpcode() == Opcode && Div->getOperand(1) == Y)
1045  return X;
1046  }
1047 
1048  // (X rem Y) / Y -> 0
1049  if ((isSigned && match(Op0, m_SRem(m_Value(), m_Specific(Op1)))) ||
1050  (!isSigned && match(Op0, m_URem(m_Value(), m_Specific(Op1)))))
1051  return Constant::getNullValue(Op0->getType());
1052 
1053  // (X /u C1) /u C2 -> 0 if C1 * C2 overflow
1054  ConstantInt *C1, *C2;
1055  if (!isSigned && match(Op0, m_UDiv(m_Value(X), m_ConstantInt(C1))) &&
1056  match(Op1, m_ConstantInt(C2))) {
1057  bool Overflow;
1058  C1->getValue().umul_ov(C2->getValue(), Overflow);
1059  if (Overflow)
1060  return Constant::getNullValue(Op0->getType());
1061  }
1062 
1063  // If the operation is with the result of a select instruction, check whether
1064  // operating on either branch of the select always yields the same value.
1065  if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1))
1066  if (Value *V = ThreadBinOpOverSelect(Opcode, Op0, Op1, Q, MaxRecurse))
1067  return V;
1068 
1069  // If the operation is with the result of a phi instruction, check whether
1070  // operating on all incoming values of the phi always yields the same value.
1071  if (isa<PHINode>(Op0) || isa<PHINode>(Op1))
1072  if (Value *V = ThreadBinOpOverPHI(Opcode, Op0, Op1, Q, MaxRecurse))
1073  return V;
1074 
1075  return nullptr;
1076 }
1077 
1078 /// SimplifySDivInst - Given operands for an SDiv, see if we can
1079 /// fold the result. If not, this returns null.
1080 static Value *SimplifySDivInst(Value *Op0, Value *Op1, const Query &Q,
1081  unsigned MaxRecurse) {
1082  if (Value *V = SimplifyDiv(Instruction::SDiv, Op0, Op1, Q, MaxRecurse))
1083  return V;
1084 
1085  return nullptr;
1086 }
1087 
1089  const TargetLibraryInfo *TLI,
1090  const DominatorTree *DT, AssumptionCache *AC,
1091  const Instruction *CxtI) {
1092  return ::SimplifySDivInst(Op0, Op1, Query(DL, TLI, DT, AC, CxtI),
1093  RecursionLimit);
1094 }
1095 
1096 /// SimplifyUDivInst - Given operands for a UDiv, see if we can
1097 /// fold the result. If not, this returns null.
1098 static Value *SimplifyUDivInst(Value *Op0, Value *Op1, const Query &Q,
1099  unsigned MaxRecurse) {
1100  if (Value *V = SimplifyDiv(Instruction::UDiv, Op0, Op1, Q, MaxRecurse))
1101  return V;
1102 
1103  return nullptr;
1104 }
1105 
1107  const TargetLibraryInfo *TLI,
1108  const DominatorTree *DT, AssumptionCache *AC,
1109  const Instruction *CxtI) {
1110  return ::SimplifyUDivInst(Op0, Op1, Query(DL, TLI, DT, AC, CxtI),
1111  RecursionLimit);
1112 }
1113 
1115  const Query &Q, unsigned) {
1116  // undef / X -> undef (the undef could be a snan).
1117  if (match(Op0, m_Undef()))
1118  return Op0;
1119 
1120  // X / undef -> undef
1121  if (match(Op1, m_Undef()))
1122  return Op1;
1123 
1124  // 0 / X -> 0
1125  // Requires that NaNs are off (X could be zero) and signed zeroes are
1126  // ignored (X could be positive or negative, so the output sign is unknown).
1127  if (FMF.noNaNs() && FMF.noSignedZeros() && match(Op0, m_AnyZero()))
1128  return Op0;
1129 
1130  if (FMF.noNaNs()) {
1131  // X / X -> 1.0 is legal when NaNs are ignored.
1132  if (Op0 == Op1)
1133  return ConstantFP::get(Op0->getType(), 1.0);
1134 
1135  // -X / X -> -1.0 and
1136  // X / -X -> -1.0 are legal when NaNs are ignored.
1137  // We can ignore signed zeros because +-0.0/+-0.0 is NaN and ignored.
1138  if ((BinaryOperator::isFNeg(Op0, /*IgnoreZeroSign=*/true) &&
1139  BinaryOperator::getFNegArgument(Op0) == Op1) ||
1140  (BinaryOperator::isFNeg(Op1, /*IgnoreZeroSign=*/true) &&
1141  BinaryOperator::getFNegArgument(Op1) == Op0))
1142  return ConstantFP::get(Op0->getType(), -1.0);
1143  }
1144 
1145  return nullptr;
1146 }
1147 
1149  const DataLayout &DL,
1150  const TargetLibraryInfo *TLI,
1151  const DominatorTree *DT, AssumptionCache *AC,
1152  const Instruction *CxtI) {
1153  return ::SimplifyFDivInst(Op0, Op1, FMF, Query(DL, TLI, DT, AC, CxtI),
1154  RecursionLimit);
1155 }
1156 
1157 /// SimplifyRem - Given operands for an SRem or URem, see if we can
1158 /// fold the result. If not, this returns null.
1160  const Query &Q, unsigned MaxRecurse) {
1161  if (Constant *C0 = dyn_cast<Constant>(Op0)) {
1162  if (Constant *C1 = dyn_cast<Constant>(Op1)) {
1163  Constant *Ops[] = { C0, C1 };
1164  return ConstantFoldInstOperands(Opcode, C0->getType(), Ops, Q.DL, Q.TLI);
1165  }
1166  }
1167 
1168  // X % undef -> undef
1169  if (match(Op1, m_Undef()))
1170  return Op1;
1171 
1172  // undef % X -> 0
1173  if (match(Op0, m_Undef()))
1174  return Constant::getNullValue(Op0->getType());
1175 
1176  // 0 % X -> 0, we don't need to preserve faults!
1177  if (match(Op0, m_Zero()))
1178  return Op0;
1179 
1180  // X % 0 -> undef, we don't need to preserve faults!
1181  if (match(Op1, m_Zero()))
1182  return UndefValue::get(Op0->getType());
1183 
1184  // X % 1 -> 0
1185  if (match(Op1, m_One()))
1186  return Constant::getNullValue(Op0->getType());
1187 
1188  if (Op0->getType()->isIntegerTy(1))
1189  // It can't be remainder by zero, hence it must be remainder by one.
1190  return Constant::getNullValue(Op0->getType());
1191 
1192  // X % X -> 0
1193  if (Op0 == Op1)
1194  return Constant::getNullValue(Op0->getType());
1195 
1196  // (X % Y) % Y -> X % Y
1197  if ((Opcode == Instruction::SRem &&
1198  match(Op0, m_SRem(m_Value(), m_Specific(Op1)))) ||
1199  (Opcode == Instruction::URem &&
1200  match(Op0, m_URem(m_Value(), m_Specific(Op1)))))
1201  return Op0;
1202 
1203  // If the operation is with the result of a select instruction, check whether
1204  // operating on either branch of the select always yields the same value.
1205  if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1))
1206  if (Value *V = ThreadBinOpOverSelect(Opcode, Op0, Op1, Q, MaxRecurse))
1207  return V;
1208 
1209  // If the operation is with the result of a phi instruction, check whether
1210  // operating on all incoming values of the phi always yields the same value.
1211  if (isa<PHINode>(Op0) || isa<PHINode>(Op1))
1212  if (Value *V = ThreadBinOpOverPHI(Opcode, Op0, Op1, Q, MaxRecurse))
1213  return V;
1214 
1215  return nullptr;
1216 }
1217 
1218 /// SimplifySRemInst - Given operands for an SRem, see if we can
1219 /// fold the result. If not, this returns null.
1220 static Value *SimplifySRemInst(Value *Op0, Value *Op1, const Query &Q,
1221  unsigned MaxRecurse) {
1222  if (Value *V = SimplifyRem(Instruction::SRem, Op0, Op1, Q, MaxRecurse))
1223  return V;
1224 
1225  return nullptr;
1226 }
1227 
1229  const TargetLibraryInfo *TLI,
1230  const DominatorTree *DT, AssumptionCache *AC,
1231  const Instruction *CxtI) {
1232  return ::SimplifySRemInst(Op0, Op1, Query(DL, TLI, DT, AC, CxtI),
1233  RecursionLimit);
1234 }
1235 
1236 /// SimplifyURemInst - Given operands for a URem, see if we can
1237 /// fold the result. If not, this returns null.
1238 static Value *SimplifyURemInst(Value *Op0, Value *Op1, const Query &Q,
1239  unsigned MaxRecurse) {
1240  if (Value *V = SimplifyRem(Instruction::URem, Op0, Op1, Q, MaxRecurse))
1241  return V;
1242 
1243  return nullptr;
1244 }
1245 
1247  const TargetLibraryInfo *TLI,
1248  const DominatorTree *DT, AssumptionCache *AC,
1249  const Instruction *CxtI) {
1250  return ::SimplifyURemInst(Op0, Op1, Query(DL, TLI, DT, AC, CxtI),
1251  RecursionLimit);
1252 }
1253 
1255  const Query &, unsigned) {
1256  // undef % X -> undef (the undef could be a snan).
1257  if (match(Op0, m_Undef()))
1258  return Op0;
1259 
1260  // X % undef -> undef
1261  if (match(Op1, m_Undef()))
1262  return Op1;
1263 
1264  // 0 % X -> 0
1265  // Requires that NaNs are off (X could be zero) and signed zeroes are
1266  // ignored (X could be positive or negative, so the output sign is unknown).
1267  if (FMF.noNaNs() && FMF.noSignedZeros() && match(Op0, m_AnyZero()))
1268  return Op0;
1269 
1270  return nullptr;
1271 }
1272 
1274  const DataLayout &DL,
1275  const TargetLibraryInfo *TLI,
1276  const DominatorTree *DT, AssumptionCache *AC,
1277  const Instruction *CxtI) {
1278  return ::SimplifyFRemInst(Op0, Op1, FMF, Query(DL, TLI, DT, AC, CxtI),
1279  RecursionLimit);
1280 }
1281 
1282 /// isUndefShift - Returns true if a shift by \c Amount always yields undef.
1283 static bool isUndefShift(Value *Amount) {
1284  Constant *C = dyn_cast<Constant>(Amount);
1285  if (!C)
1286  return false;
1287 
1288  // X shift by undef -> undef because it may shift by the bitwidth.
1289  if (isa<UndefValue>(C))
1290  return true;
1291 
1292  // Shifting by the bitwidth or more is undefined.
1293  if (ConstantInt *CI = dyn_cast<ConstantInt>(C))
1294  if (CI->getValue().getLimitedValue() >=
1295  CI->getType()->getScalarSizeInBits())
1296  return true;
1297 
1298  // If all lanes of a vector shift are undefined the whole shift is.
1299  if (isa<ConstantVector>(C) || isa<ConstantDataVector>(C)) {
1300  for (unsigned I = 0, E = C->getType()->getVectorNumElements(); I != E; ++I)
1302  return false;
1303  return true;
1304  }
1305 
1306  return false;
1307 }
1308 
1309 /// SimplifyShift - Given operands for an Shl, LShr or AShr, see if we can
1310 /// fold the result. If not, this returns null.
1311 static Value *SimplifyShift(unsigned Opcode, Value *Op0, Value *Op1,
1312  const Query &Q, unsigned MaxRecurse) {
1313  if (Constant *C0 = dyn_cast<Constant>(Op0)) {
1314  if (Constant *C1 = dyn_cast<Constant>(Op1)) {
1315  Constant *Ops[] = { C0, C1 };
1316  return ConstantFoldInstOperands(Opcode, C0->getType(), Ops, Q.DL, Q.TLI);
1317  }
1318  }
1319 
1320  // 0 shift by X -> 0
1321  if (match(Op0, m_Zero()))
1322  return Op0;
1323 
1324  // X shift by 0 -> X
1325  if (match(Op1, m_Zero()))
1326  return Op0;
1327 
1328  // Fold undefined shifts.
1329  if (isUndefShift(Op1))
1330  return UndefValue::get(Op0->getType());
1331 
1332  // If the operation is with the result of a select instruction, check whether
1333  // operating on either branch of the select always yields the same value.
1334  if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1))
1335  if (Value *V = ThreadBinOpOverSelect(Opcode, Op0, Op1, Q, MaxRecurse))
1336  return V;
1337 
1338  // If the operation is with the result of a phi instruction, check whether
1339  // operating on all incoming values of the phi always yields the same value.
1340  if (isa<PHINode>(Op0) || isa<PHINode>(Op1))
1341  if (Value *V = ThreadBinOpOverPHI(Opcode, Op0, Op1, Q, MaxRecurse))
1342  return V;
1343 
1344  return nullptr;
1345 }
1346 
1347 /// \brief Given operands for an Shl, LShr or AShr, see if we can
1348 /// fold the result. If not, this returns null.
1349 static Value *SimplifyRightShift(unsigned Opcode, Value *Op0, Value *Op1,
1350  bool isExact, const Query &Q,
1351  unsigned MaxRecurse) {
1352  if (Value *V = SimplifyShift(Opcode, Op0, Op1, Q, MaxRecurse))
1353  return V;
1354 
1355  // X >> X -> 0
1356  if (Op0 == Op1)
1357  return Constant::getNullValue(Op0->getType());
1358 
1359  // undef >> X -> 0
1360  // undef >> X -> undef (if it's exact)
1361  if (match(Op0, m_Undef()))
1362  return isExact ? Op0 : Constant::getNullValue(Op0->getType());
1363 
1364  // The low bit cannot be shifted out of an exact shift if it is set.
1365  if (isExact) {
1366  unsigned BitWidth = Op0->getType()->getScalarSizeInBits();
1367  APInt Op0KnownZero(BitWidth, 0);
1368  APInt Op0KnownOne(BitWidth, 0);
1369  computeKnownBits(Op0, Op0KnownZero, Op0KnownOne, Q.DL, /*Depth=*/0, Q.AC,
1370  Q.CxtI, Q.DT);
1371  if (Op0KnownOne[0])
1372  return Op0;
1373  }
1374 
1375  return nullptr;
1376 }
1377 
1378 /// SimplifyShlInst - Given operands for an Shl, see if we can
1379 /// fold the result. If not, this returns null.
1380 static Value *SimplifyShlInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW,
1381  const Query &Q, unsigned MaxRecurse) {
1382  if (Value *V = SimplifyShift(Instruction::Shl, Op0, Op1, Q, MaxRecurse))
1383  return V;
1384 
1385  // undef << X -> 0
1386  // undef << X -> undef if (if it's NSW/NUW)
1387  if (match(Op0, m_Undef()))
1388  return isNSW || isNUW ? Op0 : Constant::getNullValue(Op0->getType());
1389 
1390  // (X >> A) << A -> X
1391  Value *X;
1392  if (match(Op0, m_Exact(m_Shr(m_Value(X), m_Specific(Op1)))))
1393  return X;
1394  return nullptr;
1395 }
1396 
1397 Value *llvm::SimplifyShlInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW,
1398  const DataLayout &DL, const TargetLibraryInfo *TLI,
1399  const DominatorTree *DT, AssumptionCache *AC,
1400  const Instruction *CxtI) {
1401  return ::SimplifyShlInst(Op0, Op1, isNSW, isNUW, Query(DL, TLI, DT, AC, CxtI),
1402  RecursionLimit);
1403 }
1404 
1405 /// SimplifyLShrInst - Given operands for an LShr, see if we can
1406 /// fold the result. If not, this returns null.
1407 static Value *SimplifyLShrInst(Value *Op0, Value *Op1, bool isExact,
1408  const Query &Q, unsigned MaxRecurse) {
1409  if (Value *V = SimplifyRightShift(Instruction::LShr, Op0, Op1, isExact, Q,
1410  MaxRecurse))
1411  return V;
1412 
1413  // (X << A) >> A -> X
1414  Value *X;
1415  if (match(Op0, m_NUWShl(m_Value(X), m_Specific(Op1))))
1416  return X;
1417 
1418  return nullptr;
1419 }
1420 
1421 Value *llvm::SimplifyLShrInst(Value *Op0, Value *Op1, bool isExact,
1422  const DataLayout &DL,
1423  const TargetLibraryInfo *TLI,
1424  const DominatorTree *DT, AssumptionCache *AC,
1425  const Instruction *CxtI) {
1426  return ::SimplifyLShrInst(Op0, Op1, isExact, Query(DL, TLI, DT, AC, CxtI),
1427  RecursionLimit);
1428 }
1429 
1430 /// SimplifyAShrInst - Given operands for an AShr, see if we can
1431 /// fold the result. If not, this returns null.
1432 static Value *SimplifyAShrInst(Value *Op0, Value *Op1, bool isExact,
1433  const Query &Q, unsigned MaxRecurse) {
1434  if (Value *V = SimplifyRightShift(Instruction::AShr, Op0, Op1, isExact, Q,
1435  MaxRecurse))
1436  return V;
1437 
1438  // all ones >>a X -> all ones
1439  if (match(Op0, m_AllOnes()))
1440  return Op0;
1441 
1442  // (X << A) >> A -> X
1443  Value *X;
1444  if (match(Op0, m_NSWShl(m_Value(X), m_Specific(Op1))))
1445  return X;
1446 
1447  // Arithmetic shifting an all-sign-bit value is a no-op.
1448  unsigned NumSignBits = ComputeNumSignBits(Op0, Q.DL, 0, Q.AC, Q.CxtI, Q.DT);
1449  if (NumSignBits == Op0->getType()->getScalarSizeInBits())
1450  return Op0;
1451 
1452  return nullptr;
1453 }
1454 
1455 Value *llvm::SimplifyAShrInst(Value *Op0, Value *Op1, bool isExact,
1456  const DataLayout &DL,
1457  const TargetLibraryInfo *TLI,
1458  const DominatorTree *DT, AssumptionCache *AC,
1459  const Instruction *CxtI) {
1460  return ::SimplifyAShrInst(Op0, Op1, isExact, Query(DL, TLI, DT, AC, CxtI),
1461  RecursionLimit);
1462 }
1463 
1465  ICmpInst *UnsignedICmp, bool IsAnd) {
1466  Value *X, *Y;
1467 
1468  ICmpInst::Predicate EqPred;
1469  if (!match(ZeroICmp, m_ICmp(EqPred, m_Value(Y), m_Zero())) ||
1470  !ICmpInst::isEquality(EqPred))
1471  return nullptr;
1472 
1473  ICmpInst::Predicate UnsignedPred;
1474  if (match(UnsignedICmp, m_ICmp(UnsignedPred, m_Value(X), m_Specific(Y))) &&
1475  ICmpInst::isUnsigned(UnsignedPred))
1476  ;
1477  else if (match(UnsignedICmp,
1478  m_ICmp(UnsignedPred, m_Value(Y), m_Specific(X))) &&
1479  ICmpInst::isUnsigned(UnsignedPred))
1480  UnsignedPred = ICmpInst::getSwappedPredicate(UnsignedPred);
1481  else
1482  return nullptr;
1483 
1484  // X < Y && Y != 0 --> X < Y
1485  // X < Y || Y != 0 --> Y != 0
1486  if (UnsignedPred == ICmpInst::ICMP_ULT && EqPred == ICmpInst::ICMP_NE)
1487  return IsAnd ? UnsignedICmp : ZeroICmp;
1488 
1489  // X >= Y || Y != 0 --> true
1490  // X >= Y || Y == 0 --> X >= Y
1491  if (UnsignedPred == ICmpInst::ICMP_UGE && !IsAnd) {
1492  if (EqPred == ICmpInst::ICMP_NE)
1493  return getTrue(UnsignedICmp->getType());
1494  return UnsignedICmp;
1495  }
1496 
1497  // X < Y && Y == 0 --> false
1498  if (UnsignedPred == ICmpInst::ICMP_ULT && EqPred == ICmpInst::ICMP_EQ &&
1499  IsAnd)
1500  return getFalse(UnsignedICmp->getType());
1501 
1502  return nullptr;
1503 }
1504 
1505 // Simplify (and (icmp ...) (icmp ...)) to true when we can tell that the range
1506 // of possible values cannot be satisfied.
1508  ICmpInst::Predicate Pred0, Pred1;
1509  ConstantInt *CI1, *CI2;
1510  Value *V;
1511 
1512  if (Value *X = simplifyUnsignedRangeCheck(Op0, Op1, /*IsAnd=*/true))
1513  return X;
1514 
1515  if (!match(Op0, m_ICmp(Pred0, m_Add(m_Value(V), m_ConstantInt(CI1)),
1516  m_ConstantInt(CI2))))
1517  return nullptr;
1518 
1519  if (!match(Op1, m_ICmp(Pred1, m_Specific(V), m_Specific(CI1))))
1520  return nullptr;
1521 
1522  Type *ITy = Op0->getType();
1523 
1524  auto *AddInst = cast<BinaryOperator>(Op0->getOperand(0));
1525  bool isNSW = AddInst->hasNoSignedWrap();
1526  bool isNUW = AddInst->hasNoUnsignedWrap();
1527 
1528  const APInt &CI1V = CI1->getValue();
1529  const APInt &CI2V = CI2->getValue();
1530  const APInt Delta = CI2V - CI1V;
1531  if (CI1V.isStrictlyPositive()) {
1532  if (Delta == 2) {
1533  if (Pred0 == ICmpInst::ICMP_ULT && Pred1 == ICmpInst::ICMP_SGT)
1534  return getFalse(ITy);
1535  if (Pred0 == ICmpInst::ICMP_SLT && Pred1 == ICmpInst::ICMP_SGT && isNSW)
1536  return getFalse(ITy);
1537  }
1538  if (Delta == 1) {
1539  if (Pred0 == ICmpInst::ICMP_ULE && Pred1 == ICmpInst::ICMP_SGT)
1540  return getFalse(ITy);
1541  if (Pred0 == ICmpInst::ICMP_SLE && Pred1 == ICmpInst::ICMP_SGT && isNSW)
1542  return getFalse(ITy);
1543  }
1544  }
1545  if (CI1V.getBoolValue() && isNUW) {
1546  if (Delta == 2)
1547  if (Pred0 == ICmpInst::ICMP_ULT && Pred1 == ICmpInst::ICMP_UGT)
1548  return getFalse(ITy);
1549  if (Delta == 1)
1550  if (Pred0 == ICmpInst::ICMP_ULE && Pred1 == ICmpInst::ICMP_UGT)
1551  return getFalse(ITy);
1552  }
1553 
1554  return nullptr;
1555 }
1556 
1557 /// SimplifyAndInst - Given operands for an And, see if we can
1558 /// fold the result. If not, this returns null.
1559 static Value *SimplifyAndInst(Value *Op0, Value *Op1, const Query &Q,
1560  unsigned MaxRecurse) {
1561  if (Constant *CLHS = dyn_cast<Constant>(Op0)) {
1562  if (Constant *CRHS = dyn_cast<Constant>(Op1)) {
1563  Constant *Ops[] = { CLHS, CRHS };
1564  return ConstantFoldInstOperands(Instruction::And, CLHS->getType(),
1565  Ops, Q.DL, Q.TLI);
1566  }
1567 
1568  // Canonicalize the constant to the RHS.
1569  std::swap(Op0, Op1);
1570  }
1571 
1572  // X & undef -> 0
1573  if (match(Op1, m_Undef()))
1574  return Constant::getNullValue(Op0->getType());
1575 
1576  // X & X = X
1577  if (Op0 == Op1)
1578  return Op0;
1579 
1580  // X & 0 = 0
1581  if (match(Op1, m_Zero()))
1582  return Op1;
1583 
1584  // X & -1 = X
1585  if (match(Op1, m_AllOnes()))
1586  return Op0;
1587 
1588  // A & ~A = ~A & A = 0
1589  if (match(Op0, m_Not(m_Specific(Op1))) ||
1590  match(Op1, m_Not(m_Specific(Op0))))
1591  return Constant::getNullValue(Op0->getType());
1592 
1593  // (A | ?) & A = A
1594  Value *A = nullptr, *B = nullptr;
1595  if (match(Op0, m_Or(m_Value(A), m_Value(B))) &&
1596  (A == Op1 || B == Op1))
1597  return Op1;
1598 
1599  // A & (A | ?) = A
1600  if (match(Op1, m_Or(m_Value(A), m_Value(B))) &&
1601  (A == Op0 || B == Op0))
1602  return Op0;
1603 
1604  // A & (-A) = A if A is a power of two or zero.
1605  if (match(Op0, m_Neg(m_Specific(Op1))) ||
1606  match(Op1, m_Neg(m_Specific(Op0)))) {
1607  if (isKnownToBeAPowerOfTwo(Op0, Q.DL, /*OrZero*/ true, 0, Q.AC, Q.CxtI,
1608  Q.DT))
1609  return Op0;
1610  if (isKnownToBeAPowerOfTwo(Op1, Q.DL, /*OrZero*/ true, 0, Q.AC, Q.CxtI,
1611  Q.DT))
1612  return Op1;
1613  }
1614 
1615  if (auto *ICILHS = dyn_cast<ICmpInst>(Op0)) {
1616  if (auto *ICIRHS = dyn_cast<ICmpInst>(Op1)) {
1617  if (Value *V = SimplifyAndOfICmps(ICILHS, ICIRHS))
1618  return V;
1619  if (Value *V = SimplifyAndOfICmps(ICIRHS, ICILHS))
1620  return V;
1621  }
1622  }
1623 
1624  // Try some generic simplifications for associative operations.
1625  if (Value *V = SimplifyAssociativeBinOp(Instruction::And, Op0, Op1, Q,
1626  MaxRecurse))
1627  return V;
1628 
1629  // And distributes over Or. Try some generic simplifications based on this.
1630  if (Value *V = ExpandBinOp(Instruction::And, Op0, Op1, Instruction::Or,
1631  Q, MaxRecurse))
1632  return V;
1633 
1634  // And distributes over Xor. Try some generic simplifications based on this.
1635  if (Value *V = ExpandBinOp(Instruction::And, Op0, Op1, Instruction::Xor,
1636  Q, MaxRecurse))
1637  return V;
1638 
1639  // If the operation is with the result of a select instruction, check whether
1640  // operating on either branch of the select always yields the same value.
1641  if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1))
1642  if (Value *V = ThreadBinOpOverSelect(Instruction::And, Op0, Op1, Q,
1643  MaxRecurse))
1644  return V;
1645 
1646  // If the operation is with the result of a phi instruction, check whether
1647  // operating on all incoming values of the phi always yields the same value.
1648  if (isa<PHINode>(Op0) || isa<PHINode>(Op1))
1649  if (Value *V = ThreadBinOpOverPHI(Instruction::And, Op0, Op1, Q,
1650  MaxRecurse))
1651  return V;
1652 
1653  return nullptr;
1654 }
1655 
1657  const TargetLibraryInfo *TLI,
1658  const DominatorTree *DT, AssumptionCache *AC,
1659  const Instruction *CxtI) {
1660  return ::SimplifyAndInst(Op0, Op1, Query(DL, TLI, DT, AC, CxtI),
1661  RecursionLimit);
1662 }
1663 
1664 // Simplify (or (icmp ...) (icmp ...)) to true when we can tell that the union
1665 // contains all possible values.
1667  ICmpInst::Predicate Pred0, Pred1;
1668  ConstantInt *CI1, *CI2;
1669  Value *V;
1670 
1671  if (Value *X = simplifyUnsignedRangeCheck(Op0, Op1, /*IsAnd=*/false))
1672  return X;
1673 
1674  if (!match(Op0, m_ICmp(Pred0, m_Add(m_Value(V), m_ConstantInt(CI1)),
1675  m_ConstantInt(CI2))))
1676  return nullptr;
1677 
1678  if (!match(Op1, m_ICmp(Pred1, m_Specific(V), m_Specific(CI1))))
1679  return nullptr;
1680 
1681  Type *ITy = Op0->getType();
1682 
1683  auto *AddInst = cast<BinaryOperator>(Op0->getOperand(0));
1684  bool isNSW = AddInst->hasNoSignedWrap();
1685  bool isNUW = AddInst->hasNoUnsignedWrap();
1686 
1687  const APInt &CI1V = CI1->getValue();
1688  const APInt &CI2V = CI2->getValue();
1689  const APInt Delta = CI2V - CI1V;
1690  if (CI1V.isStrictlyPositive()) {
1691  if (Delta == 2) {
1692  if (Pred0 == ICmpInst::ICMP_UGE && Pred1 == ICmpInst::ICMP_SLE)
1693  return getTrue(ITy);
1694  if (Pred0 == ICmpInst::ICMP_SGE && Pred1 == ICmpInst::ICMP_SLE && isNSW)
1695  return getTrue(ITy);
1696  }
1697  if (Delta == 1) {
1698  if (Pred0 == ICmpInst::ICMP_UGT && Pred1 == ICmpInst::ICMP_SLE)
1699  return getTrue(ITy);
1700  if (Pred0 == ICmpInst::ICMP_SGT && Pred1 == ICmpInst::ICMP_SLE && isNSW)
1701  return getTrue(ITy);
1702  }
1703  }
1704  if (CI1V.getBoolValue() && isNUW) {
1705  if (Delta == 2)
1706  if (Pred0 == ICmpInst::ICMP_UGE && Pred1 == ICmpInst::ICMP_ULE)
1707  return getTrue(ITy);
1708  if (Delta == 1)
1709  if (Pred0 == ICmpInst::ICMP_UGT && Pred1 == ICmpInst::ICMP_ULE)
1710  return getTrue(ITy);
1711  }
1712 
1713  return nullptr;
1714 }
1715 
1716 /// SimplifyOrInst - Given operands for an Or, see if we can
1717 /// fold the result. If not, this returns null.
1718 static Value *SimplifyOrInst(Value *Op0, Value *Op1, const Query &Q,
1719  unsigned MaxRecurse) {
1720  if (Constant *CLHS = dyn_cast<Constant>(Op0)) {
1721  if (Constant *CRHS = dyn_cast<Constant>(Op1)) {
1722  Constant *Ops[] = { CLHS, CRHS };
1723  return ConstantFoldInstOperands(Instruction::Or, CLHS->getType(),
1724  Ops, Q.DL, Q.TLI);
1725  }
1726 
1727  // Canonicalize the constant to the RHS.
1728  std::swap(Op0, Op1);
1729  }
1730 
1731  // X | undef -> -1
1732  if (match(Op1, m_Undef()))
1733  return Constant::getAllOnesValue(Op0->getType());
1734 
1735  // X | X = X
1736  if (Op0 == Op1)
1737  return Op0;
1738 
1739  // X | 0 = X
1740  if (match(Op1, m_Zero()))
1741  return Op0;
1742 
1743  // X | -1 = -1
1744  if (match(Op1, m_AllOnes()))
1745  return Op1;
1746 
1747  // A | ~A = ~A | A = -1
1748  if (match(Op0, m_Not(m_Specific(Op1))) ||
1749  match(Op1, m_Not(m_Specific(Op0))))
1750  return Constant::getAllOnesValue(Op0->getType());
1751 
1752  // (A & ?) | A = A
1753  Value *A = nullptr, *B = nullptr;
1754  if (match(Op0, m_And(m_Value(A), m_Value(B))) &&
1755  (A == Op1 || B == Op1))
1756  return Op1;
1757 
1758  // A | (A & ?) = A
1759  if (match(Op1, m_And(m_Value(A), m_Value(B))) &&
1760  (A == Op0 || B == Op0))
1761  return Op0;
1762 
1763  // ~(A & ?) | A = -1
1764  if (match(Op0, m_Not(m_And(m_Value(A), m_Value(B)))) &&
1765  (A == Op1 || B == Op1))
1766  return Constant::getAllOnesValue(Op1->getType());
1767 
1768  // A | ~(A & ?) = -1
1769  if (match(Op1, m_Not(m_And(m_Value(A), m_Value(B)))) &&
1770  (A == Op0 || B == Op0))
1771  return Constant::getAllOnesValue(Op0->getType());
1772 
1773  if (auto *ICILHS = dyn_cast<ICmpInst>(Op0)) {
1774  if (auto *ICIRHS = dyn_cast<ICmpInst>(Op1)) {
1775  if (Value *V = SimplifyOrOfICmps(ICILHS, ICIRHS))
1776  return V;
1777  if (Value *V = SimplifyOrOfICmps(ICIRHS, ICILHS))
1778  return V;
1779  }
1780  }
1781 
1782  // Try some generic simplifications for associative operations.
1783  if (Value *V = SimplifyAssociativeBinOp(Instruction::Or, Op0, Op1, Q,
1784  MaxRecurse))
1785  return V;
1786 
1787  // Or distributes over And. Try some generic simplifications based on this.
1788  if (Value *V = ExpandBinOp(Instruction::Or, Op0, Op1, Instruction::And, Q,
1789  MaxRecurse))
1790  return V;
1791 
1792  // If the operation is with the result of a select instruction, check whether
1793  // operating on either branch of the select always yields the same value.
1794  if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1))
1795  if (Value *V = ThreadBinOpOverSelect(Instruction::Or, Op0, Op1, Q,
1796  MaxRecurse))
1797  return V;
1798 
1799  // (A & C)|(B & D)
1800  Value *C = nullptr, *D = nullptr;
1801  if (match(Op0, m_And(m_Value(A), m_Value(C))) &&
1802  match(Op1, m_And(m_Value(B), m_Value(D)))) {
1803  ConstantInt *C1 = dyn_cast<ConstantInt>(C);
1804  ConstantInt *C2 = dyn_cast<ConstantInt>(D);
1805  if (C1 && C2 && (C1->getValue() == ~C2->getValue())) {
1806  // (A & C1)|(B & C2)
1807  // If we have: ((V + N) & C1) | (V & C2)
1808  // .. and C2 = ~C1 and C2 is 0+1+ and (N & C2) == 0
1809  // replace with V+N.
1810  Value *V1, *V2;
1811  if ((C2->getValue() & (C2->getValue() + 1)) == 0 && // C2 == 0+1+
1812  match(A, m_Add(m_Value(V1), m_Value(V2)))) {
1813  // Add commutes, try both ways.
1814  if (V1 == B &&
1815  MaskedValueIsZero(V2, C2->getValue(), Q.DL, 0, Q.AC, Q.CxtI, Q.DT))
1816  return A;
1817  if (V2 == B &&
1818  MaskedValueIsZero(V1, C2->getValue(), Q.DL, 0, Q.AC, Q.CxtI, Q.DT))
1819  return A;
1820  }
1821  // Or commutes, try both ways.
1822  if ((C1->getValue() & (C1->getValue() + 1)) == 0 &&
1823  match(B, m_Add(m_Value(V1), m_Value(V2)))) {
1824  // Add commutes, try both ways.
1825  if (V1 == A &&
1826  MaskedValueIsZero(V2, C1->getValue(), Q.DL, 0, Q.AC, Q.CxtI, Q.DT))
1827  return B;
1828  if (V2 == A &&
1829  MaskedValueIsZero(V1, C1->getValue(), Q.DL, 0, Q.AC, Q.CxtI, Q.DT))
1830  return B;
1831  }
1832  }
1833  }
1834 
1835  // If the operation is with the result of a phi instruction, check whether
1836  // operating on all incoming values of the phi always yields the same value.
1837  if (isa<PHINode>(Op0) || isa<PHINode>(Op1))
1838  if (Value *V = ThreadBinOpOverPHI(Instruction::Or, Op0, Op1, Q, MaxRecurse))
1839  return V;
1840 
1841  return nullptr;
1842 }
1843 
1845  const TargetLibraryInfo *TLI,
1846  const DominatorTree *DT, AssumptionCache *AC,
1847  const Instruction *CxtI) {
1848  return ::SimplifyOrInst(Op0, Op1, Query(DL, TLI, DT, AC, CxtI),
1849  RecursionLimit);
1850 }
1851 
1852 /// SimplifyXorInst - Given operands for a Xor, see if we can
1853 /// fold the result. If not, this returns null.
1854 static Value *SimplifyXorInst(Value *Op0, Value *Op1, const Query &Q,
1855  unsigned MaxRecurse) {
1856  if (Constant *CLHS = dyn_cast<Constant>(Op0)) {
1857  if (Constant *CRHS = dyn_cast<Constant>(Op1)) {
1858  Constant *Ops[] = { CLHS, CRHS };
1859  return ConstantFoldInstOperands(Instruction::Xor, CLHS->getType(),
1860  Ops, Q.DL, Q.TLI);
1861  }
1862 
1863  // Canonicalize the constant to the RHS.
1864  std::swap(Op0, Op1);
1865  }
1866 
1867  // A ^ undef -> undef
1868  if (match(Op1, m_Undef()))
1869  return Op1;
1870 
1871  // A ^ 0 = A
1872  if (match(Op1, m_Zero()))
1873  return Op0;
1874 
1875  // A ^ A = 0
1876  if (Op0 == Op1)
1877  return Constant::getNullValue(Op0->getType());
1878 
1879  // A ^ ~A = ~A ^ A = -1
1880  if (match(Op0, m_Not(m_Specific(Op1))) ||
1881  match(Op1, m_Not(m_Specific(Op0))))
1882  return Constant::getAllOnesValue(Op0->getType());
1883 
1884  // Try some generic simplifications for associative operations.
1885  if (Value *V = SimplifyAssociativeBinOp(Instruction::Xor, Op0, Op1, Q,
1886  MaxRecurse))
1887  return V;
1888 
1889  // Threading Xor over selects and phi nodes is pointless, so don't bother.
1890  // Threading over the select in "A ^ select(cond, B, C)" means evaluating
1891  // "A^B" and "A^C" and seeing if they are equal; but they are equal if and
1892  // only if B and C are equal. If B and C are equal then (since we assume
1893  // that operands have already been simplified) "select(cond, B, C)" should
1894  // have been simplified to the common value of B and C already. Analysing
1895  // "A^B" and "A^C" thus gains nothing, but costs compile time. Similarly
1896  // for threading over phi nodes.
1897 
1898  return nullptr;
1899 }
1900 
1902  const TargetLibraryInfo *TLI,
1903  const DominatorTree *DT, AssumptionCache *AC,
1904  const Instruction *CxtI) {
1905  return ::SimplifyXorInst(Op0, Op1, Query(DL, TLI, DT, AC, CxtI),
1906  RecursionLimit);
1907 }
1908 
1909 static Type *GetCompareTy(Value *Op) {
1910  return CmpInst::makeCmpResultType(Op->getType());
1911 }
1912 
1913 /// ExtractEquivalentCondition - Rummage around inside V looking for something
1914 /// equivalent to the comparison "LHS Pred RHS". Return such a value if found,
1915 /// otherwise return null. Helper function for analyzing max/min idioms.
1917  Value *LHS, Value *RHS) {
1919  if (!SI)
1920  return nullptr;
1921  CmpInst *Cmp = dyn_cast<CmpInst>(SI->getCondition());
1922  if (!Cmp)
1923  return nullptr;
1924  Value *CmpLHS = Cmp->getOperand(0), *CmpRHS = Cmp->getOperand(1);
1925  if (Pred == Cmp->getPredicate() && LHS == CmpLHS && RHS == CmpRHS)
1926  return Cmp;
1927  if (Pred == CmpInst::getSwappedPredicate(Cmp->getPredicate()) &&
1928  LHS == CmpRHS && RHS == CmpLHS)
1929  return Cmp;
1930  return nullptr;
1931 }
1932 
1933 // A significant optimization not implemented here is assuming that alloca
1934 // addresses are not equal to incoming argument values. They don't *alias*,
1935 // as we say, but that doesn't mean they aren't equal, so we take a
1936 // conservative approach.
1937 //
1938 // This is inspired in part by C++11 5.10p1:
1939 // "Two pointers of the same type compare equal if and only if they are both
1940 // null, both point to the same function, or both represent the same
1941 // address."
1942 //
1943 // This is pretty permissive.
1944 //
1945 // It's also partly due to C11 6.5.9p6:
1946 // "Two pointers compare equal if and only if both are null pointers, both are
1947 // pointers to the same object (including a pointer to an object and a
1948 // subobject at its beginning) or function, both are pointers to one past the
1949 // last element of the same array object, or one is a pointer to one past the
1950 // end of one array object and the other is a pointer to the start of a
1951 // different array object that happens to immediately follow the first array
1952 // object in the address space.)
1953 //
1954 // C11's version is more restrictive, however there's no reason why an argument
1955 // couldn't be a one-past-the-end value for a stack object in the caller and be
1956 // equal to the beginning of a stack object in the callee.
1957 //
1958 // If the C and C++ standards are ever made sufficiently restrictive in this
1959 // area, it may be possible to update LLVM's semantics accordingly and reinstate
1960 // this optimization.
1962  const TargetLibraryInfo *TLI,
1963  CmpInst::Predicate Pred, Value *LHS,
1964  Value *RHS) {
1965  // First, skip past any trivial no-ops.
1966  LHS = LHS->stripPointerCasts();
1967  RHS = RHS->stripPointerCasts();
1968 
1969  // A non-null pointer is not equal to a null pointer.
1970  if (llvm::isKnownNonNull(LHS, TLI) && isa<ConstantPointerNull>(RHS) &&
1971  (Pred == CmpInst::ICMP_EQ || Pred == CmpInst::ICMP_NE))
1972  return ConstantInt::get(GetCompareTy(LHS),
1973  !CmpInst::isTrueWhenEqual(Pred));
1974 
1975  // We can only fold certain predicates on pointer comparisons.
1976  switch (Pred) {
1977  default:
1978  return nullptr;
1979 
1980  // Equality comaprisons are easy to fold.
1981  case CmpInst::ICMP_EQ:
1982  case CmpInst::ICMP_NE:
1983  break;
1984 
1985  // We can only handle unsigned relational comparisons because 'inbounds' on
1986  // a GEP only protects against unsigned wrapping.
1987  case CmpInst::ICMP_UGT:
1988  case CmpInst::ICMP_UGE:
1989  case CmpInst::ICMP_ULT:
1990  case CmpInst::ICMP_ULE:
1991  // However, we have to switch them to their signed variants to handle
1992  // negative indices from the base pointer.
1993  Pred = ICmpInst::getSignedPredicate(Pred);
1994  break;
1995  }
1996 
1997  // Strip off any constant offsets so that we can reason about them.
1998  // It's tempting to use getUnderlyingObject or even just stripInBoundsOffsets
1999  // here and compare base addresses like AliasAnalysis does, however there are
2000  // numerous hazards. AliasAnalysis and its utilities rely on special rules
2001  // governing loads and stores which don't apply to icmps. Also, AliasAnalysis
2002  // doesn't need to guarantee pointer inequality when it says NoAlias.
2003  Constant *LHSOffset = stripAndComputeConstantOffsets(DL, LHS);
2004  Constant *RHSOffset = stripAndComputeConstantOffsets(DL, RHS);
2005 
2006  // If LHS and RHS are related via constant offsets to the same base
2007  // value, we can replace it with an icmp which just compares the offsets.
2008  if (LHS == RHS)
2009  return ConstantExpr::getICmp(Pred, LHSOffset, RHSOffset);
2010 
2011  // Various optimizations for (in)equality comparisons.
2012  if (Pred == CmpInst::ICMP_EQ || Pred == CmpInst::ICMP_NE) {
2013  // Different non-empty allocations that exist at the same time have
2014  // different addresses (if the program can tell). Global variables always
2015  // exist, so they always exist during the lifetime of each other and all
2016  // allocas. Two different allocas usually have different addresses...
2017  //
2018  // However, if there's an @llvm.stackrestore dynamically in between two
2019  // allocas, they may have the same address. It's tempting to reduce the
2020  // scope of the problem by only looking at *static* allocas here. That would
2021  // cover the majority of allocas while significantly reducing the likelihood
2022  // of having an @llvm.stackrestore pop up in the middle. However, it's not
2023  // actually impossible for an @llvm.stackrestore to pop up in the middle of
2024  // an entry block. Also, if we have a block that's not attached to a
2025  // function, we can't tell if it's "static" under the current definition.
2026  // Theoretically, this problem could be fixed by creating a new kind of
2027  // instruction kind specifically for static allocas. Such a new instruction
2028  // could be required to be at the top of the entry block, thus preventing it
2029  // from being subject to a @llvm.stackrestore. Instcombine could even
2030  // convert regular allocas into these special allocas. It'd be nifty.
2031  // However, until then, this problem remains open.
2032  //
2033  // So, we'll assume that two non-empty allocas have different addresses
2034  // for now.
2035  //
2036  // With all that, if the offsets are within the bounds of their allocations
2037  // (and not one-past-the-end! so we can't use inbounds!), and their
2038  // allocations aren't the same, the pointers are not equal.
2039  //
2040  // Note that it's not necessary to check for LHS being a global variable
2041  // address, due to canonicalization and constant folding.
2042  if (isa<AllocaInst>(LHS) &&
2043  (isa<AllocaInst>(RHS) || isa<GlobalVariable>(RHS))) {
2044  ConstantInt *LHSOffsetCI = dyn_cast<ConstantInt>(LHSOffset);
2045  ConstantInt *RHSOffsetCI = dyn_cast<ConstantInt>(RHSOffset);
2046  uint64_t LHSSize, RHSSize;
2047  if (LHSOffsetCI && RHSOffsetCI &&
2048  getObjectSize(LHS, LHSSize, DL, TLI) &&
2049  getObjectSize(RHS, RHSSize, DL, TLI)) {
2050  const APInt &LHSOffsetValue = LHSOffsetCI->getValue();
2051  const APInt &RHSOffsetValue = RHSOffsetCI->getValue();
2052  if (!LHSOffsetValue.isNegative() &&
2053  !RHSOffsetValue.isNegative() &&
2054  LHSOffsetValue.ult(LHSSize) &&
2055  RHSOffsetValue.ult(RHSSize)) {
2056  return ConstantInt::get(GetCompareTy(LHS),
2057  !CmpInst::isTrueWhenEqual(Pred));
2058  }
2059  }
2060 
2061  // Repeat the above check but this time without depending on DataLayout
2062  // or being able to compute a precise size.
2063  if (!cast<PointerType>(LHS->getType())->isEmptyTy() &&
2064  !cast<PointerType>(RHS->getType())->isEmptyTy() &&
2065  LHSOffset->isNullValue() &&
2066  RHSOffset->isNullValue())
2067  return ConstantInt::get(GetCompareTy(LHS),
2068  !CmpInst::isTrueWhenEqual(Pred));
2069  }
2070 
2071  // Even if an non-inbounds GEP occurs along the path we can still optimize
2072  // equality comparisons concerning the result. We avoid walking the whole
2073  // chain again by starting where the last calls to
2074  // stripAndComputeConstantOffsets left off and accumulate the offsets.
2075  Constant *LHSNoBound = stripAndComputeConstantOffsets(DL, LHS, true);
2076  Constant *RHSNoBound = stripAndComputeConstantOffsets(DL, RHS, true);
2077  if (LHS == RHS)
2078  return ConstantExpr::getICmp(Pred,
2079  ConstantExpr::getAdd(LHSOffset, LHSNoBound),
2080  ConstantExpr::getAdd(RHSOffset, RHSNoBound));
2081 
2082  // If one side of the equality comparison must come from a noalias call
2083  // (meaning a system memory allocation function), and the other side must
2084  // come from a pointer that cannot overlap with dynamically-allocated
2085  // memory within the lifetime of the current function (allocas, byval
2086  // arguments, globals), then determine the comparison result here.
2087  SmallVector<Value *, 8> LHSUObjs, RHSUObjs;
2088  GetUnderlyingObjects(LHS, LHSUObjs, DL);
2089  GetUnderlyingObjects(RHS, RHSUObjs, DL);
2090 
2091  // Is the set of underlying objects all noalias calls?
2092  auto IsNAC = [](SmallVectorImpl<Value *> &Objects) {
2093  return std::all_of(Objects.begin(), Objects.end(),
2094  [](Value *V){ return isNoAliasCall(V); });
2095  };
2096 
2097  // Is the set of underlying objects all things which must be disjoint from
2098  // noalias calls. For allocas, we consider only static ones (dynamic
2099  // allocas might be transformed into calls to malloc not simultaneously
2100  // live with the compared-to allocation). For globals, we exclude symbols
2101  // that might be resolve lazily to symbols in another dynamically-loaded
2102  // library (and, thus, could be malloc'ed by the implementation).
2103  auto IsAllocDisjoint = [](SmallVectorImpl<Value *> &Objects) {
2104  return std::all_of(Objects.begin(), Objects.end(),
2105  [](Value *V){
2106  if (const AllocaInst *AI = dyn_cast<AllocaInst>(V))
2107  return AI->getParent() && AI->getParent()->getParent() &&
2108  AI->isStaticAlloca();
2109  if (const GlobalValue *GV = dyn_cast<GlobalValue>(V))
2110  return (GV->hasLocalLinkage() ||
2111  GV->hasHiddenVisibility() ||
2112  GV->hasProtectedVisibility() ||
2113  GV->hasUnnamedAddr()) &&
2114  !GV->isThreadLocal();
2115  if (const Argument *A = dyn_cast<Argument>(V))
2116  return A->hasByValAttr();
2117  return false;
2118  });
2119  };
2120 
2121  if ((IsNAC(LHSUObjs) && IsAllocDisjoint(RHSUObjs)) ||
2122  (IsNAC(RHSUObjs) && IsAllocDisjoint(LHSUObjs)))
2123  return ConstantInt::get(GetCompareTy(LHS),
2124  !CmpInst::isTrueWhenEqual(Pred));
2125  }
2126 
2127  // Otherwise, fail.
2128  return nullptr;
2129 }
2130 
2131 /// SimplifyICmpInst - Given operands for an ICmpInst, see if we can
2132 /// fold the result. If not, this returns null.
2133 static Value *SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS,
2134  const Query &Q, unsigned MaxRecurse) {
2135  CmpInst::Predicate Pred = (CmpInst::Predicate)Predicate;
2136  assert(CmpInst::isIntPredicate(Pred) && "Not an integer compare!");
2137 
2138  if (Constant *CLHS = dyn_cast<Constant>(LHS)) {
2139  if (Constant *CRHS = dyn_cast<Constant>(RHS))
2140  return ConstantFoldCompareInstOperands(Pred, CLHS, CRHS, Q.DL, Q.TLI);
2141 
2142  // If we have a constant, make sure it is on the RHS.
2143  std::swap(LHS, RHS);
2144  Pred = CmpInst::getSwappedPredicate(Pred);
2145  }
2146 
2147  Type *ITy = GetCompareTy(LHS); // The return type.
2148  Type *OpTy = LHS->getType(); // The operand type.
2149 
2150  // icmp X, X -> true/false
2151  // X icmp undef -> true/false. For example, icmp ugt %X, undef -> false
2152  // because X could be 0.
2153  if (LHS == RHS || isa<UndefValue>(RHS))
2154  return ConstantInt::get(ITy, CmpInst::isTrueWhenEqual(Pred));
2155 
2156  // Special case logic when the operands have i1 type.
2157  if (OpTy->getScalarType()->isIntegerTy(1)) {
2158  switch (Pred) {
2159  default: break;
2160  case ICmpInst::ICMP_EQ:
2161  // X == 1 -> X
2162  if (match(RHS, m_One()))
2163  return LHS;
2164  break;
2165  case ICmpInst::ICMP_NE:
2166  // X != 0 -> X
2167  if (match(RHS, m_Zero()))
2168  return LHS;
2169  break;
2170  case ICmpInst::ICMP_UGT:
2171  // X >u 0 -> X
2172  if (match(RHS, m_Zero()))
2173  return LHS;
2174  break;
2175  case ICmpInst::ICMP_UGE:
2176  // X >=u 1 -> X
2177  if (match(RHS, m_One()))
2178  return LHS;
2179  break;
2180  case ICmpInst::ICMP_SLT:
2181  // X <s 0 -> X
2182  if (match(RHS, m_Zero()))
2183  return LHS;
2184  break;
2185  case ICmpInst::ICMP_SLE:
2186  // X <=s -1 -> X
2187  if (match(RHS, m_One()))
2188  return LHS;
2189  break;
2190  }
2191  }
2192 
2193  // If we are comparing with zero then try hard since this is a common case.
2194  if (match(RHS, m_Zero())) {
2195  bool LHSKnownNonNegative, LHSKnownNegative;
2196  switch (Pred) {
2197  default: llvm_unreachable("Unknown ICmp predicate!");
2198  case ICmpInst::ICMP_ULT:
2199  return getFalse(ITy);
2200  case ICmpInst::ICMP_UGE:
2201  return getTrue(ITy);
2202  case ICmpInst::ICMP_EQ:
2203  case ICmpInst::ICMP_ULE:
2204  if (isKnownNonZero(LHS, Q.DL, 0, Q.AC, Q.CxtI, Q.DT))
2205  return getFalse(ITy);
2206  break;
2207  case ICmpInst::ICMP_NE:
2208  case ICmpInst::ICMP_UGT:
2209  if (isKnownNonZero(LHS, Q.DL, 0, Q.AC, Q.CxtI, Q.DT))
2210  return getTrue(ITy);
2211  break;
2212  case ICmpInst::ICMP_SLT:
2213  ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, Q.DL, 0, Q.AC,
2214  Q.CxtI, Q.DT);
2215  if (LHSKnownNegative)
2216  return getTrue(ITy);
2217  if (LHSKnownNonNegative)
2218  return getFalse(ITy);
2219  break;
2220  case ICmpInst::ICMP_SLE:
2221  ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, Q.DL, 0, Q.AC,
2222  Q.CxtI, Q.DT);
2223  if (LHSKnownNegative)
2224  return getTrue(ITy);
2225  if (LHSKnownNonNegative &&
2226  isKnownNonZero(LHS, Q.DL, 0, Q.AC, Q.CxtI, Q.DT))
2227  return getFalse(ITy);
2228  break;
2229  case ICmpInst::ICMP_SGE:
2230  ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, Q.DL, 0, Q.AC,
2231  Q.CxtI, Q.DT);
2232  if (LHSKnownNegative)
2233  return getFalse(ITy);
2234  if (LHSKnownNonNegative)
2235  return getTrue(ITy);
2236  break;
2237  case ICmpInst::ICMP_SGT:
2238  ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, Q.DL, 0, Q.AC,
2239  Q.CxtI, Q.DT);
2240  if (LHSKnownNegative)
2241  return getFalse(ITy);
2242  if (LHSKnownNonNegative &&
2243  isKnownNonZero(LHS, Q.DL, 0, Q.AC, Q.CxtI, Q.DT))
2244  return getTrue(ITy);
2245  break;
2246  }
2247  }
2248 
2249  // See if we are doing a comparison with a constant integer.
2250  if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) {
2251  // Rule out tautological comparisons (eg., ult 0 or uge 0).
2252  ConstantRange RHS_CR = ICmpInst::makeConstantRange(Pred, CI->getValue());
2253  if (RHS_CR.isEmptySet())
2254  return ConstantInt::getFalse(CI->getContext());
2255  if (RHS_CR.isFullSet())
2256  return ConstantInt::getTrue(CI->getContext());
2257 
2258  // Many binary operators with constant RHS have easy to compute constant
2259  // range. Use them to check whether the comparison is a tautology.
2260  unsigned Width = CI->getBitWidth();
2261  APInt Lower = APInt(Width, 0);
2262  APInt Upper = APInt(Width, 0);
2263  ConstantInt *CI2;
2264  if (match(LHS, m_URem(m_Value(), m_ConstantInt(CI2)))) {
2265  // 'urem x, CI2' produces [0, CI2).
2266  Upper = CI2->getValue();
2267  } else if (match(LHS, m_SRem(m_Value(), m_ConstantInt(CI2)))) {
2268  // 'srem x, CI2' produces (-|CI2|, |CI2|).
2269  Upper = CI2->getValue().abs();
2270  Lower = (-Upper) + 1;
2271  } else if (match(LHS, m_UDiv(m_ConstantInt(CI2), m_Value()))) {
2272  // 'udiv CI2, x' produces [0, CI2].
2273  Upper = CI2->getValue() + 1;
2274  } else if (match(LHS, m_UDiv(m_Value(), m_ConstantInt(CI2)))) {
2275  // 'udiv x, CI2' produces [0, UINT_MAX / CI2].
2276  APInt NegOne = APInt::getAllOnesValue(Width);
2277  if (!CI2->isZero())
2278  Upper = NegOne.udiv(CI2->getValue()) + 1;
2279  } else if (match(LHS, m_SDiv(m_ConstantInt(CI2), m_Value()))) {
2280  if (CI2->isMinSignedValue()) {
2281  // 'sdiv INT_MIN, x' produces [INT_MIN, INT_MIN / -2].
2282  Lower = CI2->getValue();
2283  Upper = Lower.lshr(1) + 1;
2284  } else {
2285  // 'sdiv CI2, x' produces [-|CI2|, |CI2|].
2286  Upper = CI2->getValue().abs() + 1;
2287  Lower = (-Upper) + 1;
2288  }
2289  } else if (match(LHS, m_SDiv(m_Value(), m_ConstantInt(CI2)))) {
2290  APInt IntMin = APInt::getSignedMinValue(Width);
2291  APInt IntMax = APInt::getSignedMaxValue(Width);
2292  APInt Val = CI2->getValue();
2293  if (Val.isAllOnesValue()) {
2294  // 'sdiv x, -1' produces [INT_MIN + 1, INT_MAX]
2295  // where CI2 != -1 and CI2 != 0 and CI2 != 1
2296  Lower = IntMin + 1;
2297  Upper = IntMax + 1;
2298  } else if (Val.countLeadingZeros() < Width - 1) {
2299  // 'sdiv x, CI2' produces [INT_MIN / CI2, INT_MAX / CI2]
2300  // where CI2 != -1 and CI2 != 0 and CI2 != 1
2301  Lower = IntMin.sdiv(Val);
2302  Upper = IntMax.sdiv(Val);
2303  if (Lower.sgt(Upper))
2304  std::swap(Lower, Upper);
2305  Upper = Upper + 1;
2306  assert(Upper != Lower && "Upper part of range has wrapped!");
2307  }
2308  } else if (match(LHS, m_NUWShl(m_ConstantInt(CI2), m_Value()))) {
2309  // 'shl nuw CI2, x' produces [CI2, CI2 << CLZ(CI2)]
2310  Lower = CI2->getValue();
2311  Upper = Lower.shl(Lower.countLeadingZeros()) + 1;
2312  } else if (match(LHS, m_NSWShl(m_ConstantInt(CI2), m_Value()))) {
2313  if (CI2->isNegative()) {
2314  // 'shl nsw CI2, x' produces [CI2 << CLO(CI2)-1, CI2]
2315  unsigned ShiftAmount = CI2->getValue().countLeadingOnes() - 1;
2316  Lower = CI2->getValue().shl(ShiftAmount);
2317  Upper = CI2->getValue() + 1;
2318  } else {
2319  // 'shl nsw CI2, x' produces [CI2, CI2 << CLZ(CI2)-1]
2320  unsigned ShiftAmount = CI2->getValue().countLeadingZeros() - 1;
2321  Lower = CI2->getValue();
2322  Upper = CI2->getValue().shl(ShiftAmount) + 1;
2323  }
2324  } else if (match(LHS, m_LShr(m_Value(), m_ConstantInt(CI2)))) {
2325  // 'lshr x, CI2' produces [0, UINT_MAX >> CI2].
2326  APInt NegOne = APInt::getAllOnesValue(Width);
2327  if (CI2->getValue().ult(Width))
2328  Upper = NegOne.lshr(CI2->getValue()) + 1;
2329  } else if (match(LHS, m_LShr(m_ConstantInt(CI2), m_Value()))) {
2330  // 'lshr CI2, x' produces [CI2 >> (Width-1), CI2].
2331  unsigned ShiftAmount = Width - 1;
2332  if (!CI2->isZero() && cast<BinaryOperator>(LHS)->isExact())
2333  ShiftAmount = CI2->getValue().countTrailingZeros();
2334  Lower = CI2->getValue().lshr(ShiftAmount);
2335  Upper = CI2->getValue() + 1;
2336  } else if (match(LHS, m_AShr(m_Value(), m_ConstantInt(CI2)))) {
2337  // 'ashr x, CI2' produces [INT_MIN >> CI2, INT_MAX >> CI2].
2338  APInt IntMin = APInt::getSignedMinValue(Width);
2339  APInt IntMax = APInt::getSignedMaxValue(Width);
2340  if (CI2->getValue().ult(Width)) {
2341  Lower = IntMin.ashr(CI2->getValue());
2342  Upper = IntMax.ashr(CI2->getValue()) + 1;
2343  }
2344  } else if (match(LHS, m_AShr(m_ConstantInt(CI2), m_Value()))) {
2345  unsigned ShiftAmount = Width - 1;
2346  if (!CI2->isZero() && cast<BinaryOperator>(LHS)->isExact())
2347  ShiftAmount = CI2->getValue().countTrailingZeros();
2348  if (CI2->isNegative()) {
2349  // 'ashr CI2, x' produces [CI2, CI2 >> (Width-1)]
2350  Lower = CI2->getValue();
2351  Upper = CI2->getValue().ashr(ShiftAmount) + 1;
2352  } else {
2353  // 'ashr CI2, x' produces [CI2 >> (Width-1), CI2]
2354  Lower = CI2->getValue().ashr(ShiftAmount);
2355  Upper = CI2->getValue() + 1;
2356  }
2357  } else if (match(LHS, m_Or(m_Value(), m_ConstantInt(CI2)))) {
2358  // 'or x, CI2' produces [CI2, UINT_MAX].
2359  Lower = CI2->getValue();
2360  } else if (match(LHS, m_And(m_Value(), m_ConstantInt(CI2)))) {
2361  // 'and x, CI2' produces [0, CI2].
2362  Upper = CI2->getValue() + 1;
2363  }
2364  if (Lower != Upper) {
2365  ConstantRange LHS_CR = ConstantRange(Lower, Upper);
2366  if (RHS_CR.contains(LHS_CR))
2367  return ConstantInt::getTrue(RHS->getContext());
2368  if (RHS_CR.inverse().contains(LHS_CR))
2369  return ConstantInt::getFalse(RHS->getContext());
2370  }
2371  }
2372 
2373  // Compare of cast, for example (zext X) != 0 -> X != 0
2374  if (isa<CastInst>(LHS) && (isa<Constant>(RHS) || isa<CastInst>(RHS))) {
2375  Instruction *LI = cast<CastInst>(LHS);
2376  Value *SrcOp = LI->getOperand(0);
2377  Type *SrcTy = SrcOp->getType();
2378  Type *DstTy = LI->getType();
2379 
2380  // Turn icmp (ptrtoint x), (ptrtoint/constant) into a compare of the input
2381  // if the integer type is the same size as the pointer type.
2382  if (MaxRecurse && isa<PtrToIntInst>(LI) &&
2383  Q.DL.getTypeSizeInBits(SrcTy) == DstTy->getPrimitiveSizeInBits()) {
2384  if (Constant *RHSC = dyn_cast<Constant>(RHS)) {
2385  // Transfer the cast to the constant.
2386  if (Value *V = SimplifyICmpInst(Pred, SrcOp,
2387  ConstantExpr::getIntToPtr(RHSC, SrcTy),
2388  Q, MaxRecurse-1))
2389  return V;
2390  } else if (PtrToIntInst *RI = dyn_cast<PtrToIntInst>(RHS)) {
2391  if (RI->getOperand(0)->getType() == SrcTy)
2392  // Compare without the cast.
2393  if (Value *V = SimplifyICmpInst(Pred, SrcOp, RI->getOperand(0),
2394  Q, MaxRecurse-1))
2395  return V;
2396  }
2397  }
2398 
2399  if (isa<ZExtInst>(LHS)) {
2400  // Turn icmp (zext X), (zext Y) into a compare of X and Y if they have the
2401  // same type.
2402  if (ZExtInst *RI = dyn_cast<ZExtInst>(RHS)) {
2403  if (MaxRecurse && SrcTy == RI->getOperand(0)->getType())
2404  // Compare X and Y. Note that signed predicates become unsigned.
2406  SrcOp, RI->getOperand(0), Q,
2407  MaxRecurse-1))
2408  return V;
2409  }
2410  // Turn icmp (zext X), Cst into a compare of X and Cst if Cst is extended
2411  // too. If not, then try to deduce the result of the comparison.
2412  else if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) {
2413  // Compute the constant that would happen if we truncated to SrcTy then
2414  // reextended to DstTy.
2415  Constant *Trunc = ConstantExpr::getTrunc(CI, SrcTy);
2416  Constant *RExt = ConstantExpr::getCast(CastInst::ZExt, Trunc, DstTy);
2417 
2418  // If the re-extended constant didn't change then this is effectively
2419  // also a case of comparing two zero-extended values.
2420  if (RExt == CI && MaxRecurse)
2422  SrcOp, Trunc, Q, MaxRecurse-1))
2423  return V;
2424 
2425  // Otherwise the upper bits of LHS are zero while RHS has a non-zero bit
2426  // there. Use this to work out the result of the comparison.
2427  if (RExt != CI) {
2428  switch (Pred) {
2429  default: llvm_unreachable("Unknown ICmp predicate!");
2430  // LHS <u RHS.
2431  case ICmpInst::ICMP_EQ:
2432  case ICmpInst::ICMP_UGT:
2433  case ICmpInst::ICMP_UGE:
2434  return ConstantInt::getFalse(CI->getContext());
2435 
2436  case ICmpInst::ICMP_NE:
2437  case ICmpInst::ICMP_ULT:
2438  case ICmpInst::ICMP_ULE:
2439  return ConstantInt::getTrue(CI->getContext());
2440 
2441  // LHS is non-negative. If RHS is negative then LHS >s LHS. If RHS
2442  // is non-negative then LHS <s RHS.
2443  case ICmpInst::ICMP_SGT:
2444  case ICmpInst::ICMP_SGE:
2445  return CI->getValue().isNegative() ?
2446  ConstantInt::getTrue(CI->getContext()) :
2447  ConstantInt::getFalse(CI->getContext());
2448 
2449  case ICmpInst::ICMP_SLT:
2450  case ICmpInst::ICMP_SLE:
2451  return CI->getValue().isNegative() ?
2452  ConstantInt::getFalse(CI->getContext()) :
2453  ConstantInt::getTrue(CI->getContext());
2454  }
2455  }
2456  }
2457  }
2458 
2459  if (isa<SExtInst>(LHS)) {
2460  // Turn icmp (sext X), (sext Y) into a compare of X and Y if they have the
2461  // same type.
2462  if (SExtInst *RI = dyn_cast<SExtInst>(RHS)) {
2463  if (MaxRecurse && SrcTy == RI->getOperand(0)->getType())
2464  // Compare X and Y. Note that the predicate does not change.
2465  if (Value *V = SimplifyICmpInst(Pred, SrcOp, RI->getOperand(0),
2466  Q, MaxRecurse-1))
2467  return V;
2468  }
2469  // Turn icmp (sext X), Cst into a compare of X and Cst if Cst is extended
2470  // too. If not, then try to deduce the result of the comparison.
2471  else if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) {
2472  // Compute the constant that would happen if we truncated to SrcTy then
2473  // reextended to DstTy.
2474  Constant *Trunc = ConstantExpr::getTrunc(CI, SrcTy);
2475  Constant *RExt = ConstantExpr::getCast(CastInst::SExt, Trunc, DstTy);
2476 
2477  // If the re-extended constant didn't change then this is effectively
2478  // also a case of comparing two sign-extended values.
2479  if (RExt == CI && MaxRecurse)
2480  if (Value *V = SimplifyICmpInst(Pred, SrcOp, Trunc, Q, MaxRecurse-1))
2481  return V;
2482 
2483  // Otherwise the upper bits of LHS are all equal, while RHS has varying
2484  // bits there. Use this to work out the result of the comparison.
2485  if (RExt != CI) {
2486  switch (Pred) {
2487  default: llvm_unreachable("Unknown ICmp predicate!");
2488  case ICmpInst::ICMP_EQ:
2489  return ConstantInt::getFalse(CI->getContext());
2490  case ICmpInst::ICMP_NE:
2491  return ConstantInt::getTrue(CI->getContext());
2492 
2493  // If RHS is non-negative then LHS <s RHS. If RHS is negative then
2494  // LHS >s RHS.
2495  case ICmpInst::ICMP_SGT:
2496  case ICmpInst::ICMP_SGE:
2497  return CI->getValue().isNegative() ?
2498  ConstantInt::getTrue(CI->getContext()) :
2499  ConstantInt::getFalse(CI->getContext());
2500  case ICmpInst::ICMP_SLT:
2501  case ICmpInst::ICMP_SLE:
2502  return CI->getValue().isNegative() ?
2503  ConstantInt::getFalse(CI->getContext()) :
2504  ConstantInt::getTrue(CI->getContext());
2505 
2506  // If LHS is non-negative then LHS <u RHS. If LHS is negative then
2507  // LHS >u RHS.
2508  case ICmpInst::ICMP_UGT:
2509  case ICmpInst::ICMP_UGE:
2510  // Comparison is true iff the LHS <s 0.
2511  if (MaxRecurse)
2512  if (Value *V = SimplifyICmpInst(ICmpInst::ICMP_SLT, SrcOp,
2513  Constant::getNullValue(SrcTy),
2514  Q, MaxRecurse-1))
2515  return V;
2516  break;
2517  case ICmpInst::ICMP_ULT:
2518  case ICmpInst::ICMP_ULE:
2519  // Comparison is true iff the LHS >=s 0.
2520  if (MaxRecurse)
2521  if (Value *V = SimplifyICmpInst(ICmpInst::ICMP_SGE, SrcOp,
2522  Constant::getNullValue(SrcTy),
2523  Q, MaxRecurse-1))
2524  return V;
2525  break;
2526  }
2527  }
2528  }
2529  }
2530  }
2531 
2532  // Special logic for binary operators.
2533  BinaryOperator *LBO = dyn_cast<BinaryOperator>(LHS);
2534  BinaryOperator *RBO = dyn_cast<BinaryOperator>(RHS);
2535  if (MaxRecurse && (LBO || RBO)) {
2536  // Analyze the case when either LHS or RHS is an add instruction.
2537  Value *A = nullptr, *B = nullptr, *C = nullptr, *D = nullptr;
2538  // LHS = A + B (or A and B are null); RHS = C + D (or C and D are null).
2539  bool NoLHSWrapProblem = false, NoRHSWrapProblem = false;
2540  if (LBO && LBO->getOpcode() == Instruction::Add) {
2541  A = LBO->getOperand(0); B = LBO->getOperand(1);
2542  NoLHSWrapProblem = ICmpInst::isEquality(Pred) ||
2543  (CmpInst::isUnsigned(Pred) && LBO->hasNoUnsignedWrap()) ||
2544  (CmpInst::isSigned(Pred) && LBO->hasNoSignedWrap());
2545  }
2546  if (RBO && RBO->getOpcode() == Instruction::Add) {
2547  C = RBO->getOperand(0); D = RBO->getOperand(1);
2548  NoRHSWrapProblem = ICmpInst::isEquality(Pred) ||
2549  (CmpInst::isUnsigned(Pred) && RBO->hasNoUnsignedWrap()) ||
2550  (CmpInst::isSigned(Pred) && RBO->hasNoSignedWrap());
2551  }
2552 
2553  // icmp (X+Y), X -> icmp Y, 0 for equalities or if there is no overflow.
2554  if ((A == RHS || B == RHS) && NoLHSWrapProblem)
2555  if (Value *V = SimplifyICmpInst(Pred, A == RHS ? B : A,
2557  Q, MaxRecurse-1))
2558  return V;
2559 
2560  // icmp X, (X+Y) -> icmp 0, Y for equalities or if there is no overflow.
2561  if ((C == LHS || D == LHS) && NoRHSWrapProblem)
2562  if (Value *V = SimplifyICmpInst(Pred,
2564  C == LHS ? D : C, Q, MaxRecurse-1))
2565  return V;
2566 
2567  // icmp (X+Y), (X+Z) -> icmp Y,Z for equalities or if there is no overflow.
2568  if (A && C && (A == C || A == D || B == C || B == D) &&
2569  NoLHSWrapProblem && NoRHSWrapProblem) {
2570  // Determine Y and Z in the form icmp (X+Y), (X+Z).
2571  Value *Y, *Z;
2572  if (A == C) {
2573  // C + B == C + D -> B == D
2574  Y = B;
2575  Z = D;
2576  } else if (A == D) {
2577  // D + B == C + D -> B == C
2578  Y = B;
2579  Z = C;
2580  } else if (B == C) {
2581  // A + C == C + D -> A == D
2582  Y = A;
2583  Z = D;
2584  } else {
2585  assert(B == D);
2586  // A + D == C + D -> A == C
2587  Y = A;
2588  Z = C;
2589  }
2590  if (Value *V = SimplifyICmpInst(Pred, Y, Z, Q, MaxRecurse-1))
2591  return V;
2592  }
2593  }
2594 
2595  // icmp pred (or X, Y), X
2596  if (LBO && match(LBO, m_CombineOr(m_Or(m_Value(), m_Specific(RHS)),
2597  m_Or(m_Specific(RHS), m_Value())))) {
2598  if (Pred == ICmpInst::ICMP_ULT)
2599  return getFalse(ITy);
2600  if (Pred == ICmpInst::ICMP_UGE)
2601  return getTrue(ITy);
2602  }
2603  // icmp pred X, (or X, Y)
2604  if (RBO && match(RBO, m_CombineOr(m_Or(m_Value(), m_Specific(LHS)),
2605  m_Or(m_Specific(LHS), m_Value())))) {
2606  if (Pred == ICmpInst::ICMP_ULE)
2607  return getTrue(ITy);
2608  if (Pred == ICmpInst::ICMP_UGT)
2609  return getFalse(ITy);
2610  }
2611 
2612  // icmp pred (and X, Y), X
2613  if (LBO && match(LBO, m_CombineOr(m_And(m_Value(), m_Specific(RHS)),
2614  m_And(m_Specific(RHS), m_Value())))) {
2615  if (Pred == ICmpInst::ICMP_UGT)
2616  return getFalse(ITy);
2617  if (Pred == ICmpInst::ICMP_ULE)
2618  return getTrue(ITy);
2619  }
2620  // icmp pred X, (and X, Y)
2621  if (RBO && match(RBO, m_CombineOr(m_And(m_Value(), m_Specific(LHS)),
2622  m_And(m_Specific(LHS), m_Value())))) {
2623  if (Pred == ICmpInst::ICMP_UGE)
2624  return getTrue(ITy);
2625  if (Pred == ICmpInst::ICMP_ULT)
2626  return getFalse(ITy);
2627  }
2628 
2629  // 0 - (zext X) pred C
2630  if (!CmpInst::isUnsigned(Pred) && match(LHS, m_Neg(m_ZExt(m_Value())))) {
2631  if (ConstantInt *RHSC = dyn_cast<ConstantInt>(RHS)) {
2632  if (RHSC->getValue().isStrictlyPositive()) {
2633  if (Pred == ICmpInst::ICMP_SLT)
2634  return ConstantInt::getTrue(RHSC->getContext());
2635  if (Pred == ICmpInst::ICMP_SGE)
2636  return ConstantInt::getFalse(RHSC->getContext());
2637  if (Pred == ICmpInst::ICMP_EQ)
2638  return ConstantInt::getFalse(RHSC->getContext());
2639  if (Pred == ICmpInst::ICMP_NE)
2640  return ConstantInt::getTrue(RHSC->getContext());
2641  }
2642  if (RHSC->getValue().isNonNegative()) {
2643  if (Pred == ICmpInst::ICMP_SLE)
2644  return ConstantInt::getTrue(RHSC->getContext());
2645  if (Pred == ICmpInst::ICMP_SGT)
2646  return ConstantInt::getFalse(RHSC->getContext());
2647  }
2648  }
2649  }
2650 
2651  // icmp pred (urem X, Y), Y
2652  if (LBO && match(LBO, m_URem(m_Value(), m_Specific(RHS)))) {
2653  bool KnownNonNegative, KnownNegative;
2654  switch (Pred) {
2655  default:
2656  break;
2657  case ICmpInst::ICMP_SGT:
2658  case ICmpInst::ICMP_SGE:
2659  ComputeSignBit(RHS, KnownNonNegative, KnownNegative, Q.DL, 0, Q.AC,
2660  Q.CxtI, Q.DT);
2661  if (!KnownNonNegative)
2662  break;
2663  // fall-through
2664  case ICmpInst::ICMP_EQ:
2665  case ICmpInst::ICMP_UGT:
2666  case ICmpInst::ICMP_UGE:
2667  return getFalse(ITy);
2668  case ICmpInst::ICMP_SLT:
2669  case ICmpInst::ICMP_SLE:
2670  ComputeSignBit(RHS, KnownNonNegative, KnownNegative, Q.DL, 0, Q.AC,
2671  Q.CxtI, Q.DT);
2672  if (!KnownNonNegative)
2673  break;
2674  // fall-through
2675  case ICmpInst::ICMP_NE:
2676  case ICmpInst::ICMP_ULT:
2677  case ICmpInst::ICMP_ULE:
2678  return getTrue(ITy);
2679  }
2680  }
2681 
2682  // icmp pred X, (urem Y, X)
2683  if (RBO && match(RBO, m_URem(m_Value(), m_Specific(LHS)))) {
2684  bool KnownNonNegative, KnownNegative;
2685  switch (Pred) {
2686  default:
2687  break;
2688  case ICmpInst::ICMP_SGT:
2689  case ICmpInst::ICMP_SGE:
2690  ComputeSignBit(LHS, KnownNonNegative, KnownNegative, Q.DL, 0, Q.AC,
2691  Q.CxtI, Q.DT);
2692  if (!KnownNonNegative)
2693  break;
2694  // fall-through
2695  case ICmpInst::ICMP_NE:
2696  case ICmpInst::ICMP_UGT:
2697  case ICmpInst::ICMP_UGE:
2698  return getTrue(ITy);
2699  case ICmpInst::ICMP_SLT:
2700  case ICmpInst::ICMP_SLE:
2701  ComputeSignBit(LHS, KnownNonNegative, KnownNegative, Q.DL, 0, Q.AC,
2702  Q.CxtI, Q.DT);
2703  if (!KnownNonNegative)
2704  break;
2705  // fall-through
2706  case ICmpInst::ICMP_EQ:
2707  case ICmpInst::ICMP_ULT:
2708  case ICmpInst::ICMP_ULE:
2709  return getFalse(ITy);
2710  }
2711  }
2712 
2713  // x udiv y <=u x.
2714  if (LBO && match(LBO, m_UDiv(m_Specific(RHS), m_Value()))) {
2715  // icmp pred (X /u Y), X
2716  if (Pred == ICmpInst::ICMP_UGT)
2717  return getFalse(ITy);
2718  if (Pred == ICmpInst::ICMP_ULE)
2719  return getTrue(ITy);
2720  }
2721 
2722  // handle:
2723  // CI2 << X == CI
2724  // CI2 << X != CI
2725  //
2726  // where CI2 is a power of 2 and CI isn't
2727  if (auto *CI = dyn_cast<ConstantInt>(RHS)) {
2728  const APInt *CI2Val, *CIVal = &CI->getValue();
2729  if (LBO && match(LBO, m_Shl(m_APInt(CI2Val), m_Value())) &&
2730  CI2Val->isPowerOf2()) {
2731  if (!CIVal->isPowerOf2()) {
2732  // CI2 << X can equal zero in some circumstances,
2733  // this simplification is unsafe if CI is zero.
2734  //
2735  // We know it is safe if:
2736  // - The shift is nsw, we can't shift out the one bit.
2737  // - The shift is nuw, we can't shift out the one bit.
2738  // - CI2 is one
2739  // - CI isn't zero
2740  if (LBO->hasNoSignedWrap() || LBO->hasNoUnsignedWrap() ||
2741  *CI2Val == 1 || !CI->isZero()) {
2742  if (Pred == ICmpInst::ICMP_EQ)
2743  return ConstantInt::getFalse(RHS->getContext());
2744  if (Pred == ICmpInst::ICMP_NE)
2745  return ConstantInt::getTrue(RHS->getContext());
2746  }
2747  }
2748  if (CIVal->isSignBit() && *CI2Val == 1) {
2749  if (Pred == ICmpInst::ICMP_UGT)
2750  return ConstantInt::getFalse(RHS->getContext());
2751  if (Pred == ICmpInst::ICMP_ULE)
2752  return ConstantInt::getTrue(RHS->getContext());
2753  }
2754  }
2755  }
2756 
2757  if (MaxRecurse && LBO && RBO && LBO->getOpcode() == RBO->getOpcode() &&
2758  LBO->getOperand(1) == RBO->getOperand(1)) {
2759  switch (LBO->getOpcode()) {
2760  default: break;
2761  case Instruction::UDiv:
2762  case Instruction::LShr:
2763  if (ICmpInst::isSigned(Pred))
2764  break;
2765  // fall-through
2766  case Instruction::SDiv:
2767  case Instruction::AShr:
2768  if (!LBO->isExact() || !RBO->isExact())
2769  break;
2770  if (Value *V = SimplifyICmpInst(Pred, LBO->getOperand(0),
2771  RBO->getOperand(0), Q, MaxRecurse-1))
2772  return V;
2773  break;
2774  case Instruction::Shl: {
2775  bool NUW = LBO->hasNoUnsignedWrap() && RBO->hasNoUnsignedWrap();
2776  bool NSW = LBO->hasNoSignedWrap() && RBO->hasNoSignedWrap();
2777  if (!NUW && !NSW)
2778  break;
2779  if (!NSW && ICmpInst::isSigned(Pred))
2780  break;
2781  if (Value *V = SimplifyICmpInst(Pred, LBO->getOperand(0),
2782  RBO->getOperand(0), Q, MaxRecurse-1))
2783  return V;
2784  break;
2785  }
2786  }
2787  }
2788 
2789  // Simplify comparisons involving max/min.
2790  Value *A, *B;
2792  CmpInst::Predicate EqP; // Chosen so that "A == max/min(A,B)" iff "A EqP B".
2793 
2794  // Signed variants on "max(a,b)>=a -> true".
2795  if (match(LHS, m_SMax(m_Value(A), m_Value(B))) && (A == RHS || B == RHS)) {
2796  if (A != RHS) std::swap(A, B); // smax(A, B) pred A.
2797  EqP = CmpInst::ICMP_SGE; // "A == smax(A, B)" iff "A sge B".
2798  // We analyze this as smax(A, B) pred A.
2799  P = Pred;
2800  } else if (match(RHS, m_SMax(m_Value(A), m_Value(B))) &&
2801  (A == LHS || B == LHS)) {
2802  if (A != LHS) std::swap(A, B); // A pred smax(A, B).
2803  EqP = CmpInst::ICMP_SGE; // "A == smax(A, B)" iff "A sge B".
2804  // We analyze this as smax(A, B) swapped-pred A.
2805  P = CmpInst::getSwappedPredicate(Pred);
2806  } else if (match(LHS, m_SMin(m_Value(A), m_Value(B))) &&
2807  (A == RHS || B == RHS)) {
2808  if (A != RHS) std::swap(A, B); // smin(A, B) pred A.
2809  EqP = CmpInst::ICMP_SLE; // "A == smin(A, B)" iff "A sle B".
2810  // We analyze this as smax(-A, -B) swapped-pred -A.
2811  // Note that we do not need to actually form -A or -B thanks to EqP.
2812  P = CmpInst::getSwappedPredicate(Pred);
2813  } else if (match(RHS, m_SMin(m_Value(A), m_Value(B))) &&
2814  (A == LHS || B == LHS)) {
2815  if (A != LHS) std::swap(A, B); // A pred smin(A, B).
2816  EqP = CmpInst::ICMP_SLE; // "A == smin(A, B)" iff "A sle B".
2817  // We analyze this as smax(-A, -B) pred -A.
2818  // Note that we do not need to actually form -A or -B thanks to EqP.
2819  P = Pred;
2820  }
2821  if (P != CmpInst::BAD_ICMP_PREDICATE) {
2822  // Cases correspond to "max(A, B) p A".
2823  switch (P) {
2824  default:
2825  break;
2826  case CmpInst::ICMP_EQ:
2827  case CmpInst::ICMP_SLE:
2828  // Equivalent to "A EqP B". This may be the same as the condition tested
2829  // in the max/min; if so, we can just return that.
2830  if (Value *V = ExtractEquivalentCondition(LHS, EqP, A, B))
2831  return V;
2832  if (Value *V = ExtractEquivalentCondition(RHS, EqP, A, B))
2833  return V;
2834  // Otherwise, see if "A EqP B" simplifies.
2835  if (MaxRecurse)
2836  if (Value *V = SimplifyICmpInst(EqP, A, B, Q, MaxRecurse-1))
2837  return V;
2838  break;
2839  case CmpInst::ICMP_NE:
2840  case CmpInst::ICMP_SGT: {
2842  // Equivalent to "A InvEqP B". This may be the same as the condition
2843  // tested in the max/min; if so, we can just return that.
2844  if (Value *V = ExtractEquivalentCondition(LHS, InvEqP, A, B))
2845  return V;
2846  if (Value *V = ExtractEquivalentCondition(RHS, InvEqP, A, B))
2847  return V;
2848  // Otherwise, see if "A InvEqP B" simplifies.
2849  if (MaxRecurse)
2850  if (Value *V = SimplifyICmpInst(InvEqP, A, B, Q, MaxRecurse-1))
2851  return V;
2852  break;
2853  }
2854  case CmpInst::ICMP_SGE:
2855  // Always true.
2856  return getTrue(ITy);
2857  case CmpInst::ICMP_SLT:
2858  // Always false.
2859  return getFalse(ITy);
2860  }
2861  }
2862 
2863  // Unsigned variants on "max(a,b)>=a -> true".
2865  if (match(LHS, m_UMax(m_Value(A), m_Value(B))) && (A == RHS || B == RHS)) {
2866  if (A != RHS) std::swap(A, B); // umax(A, B) pred A.
2867  EqP = CmpInst::ICMP_UGE; // "A == umax(A, B)" iff "A uge B".
2868  // We analyze this as umax(A, B) pred A.
2869  P = Pred;
2870  } else if (match(RHS, m_UMax(m_Value(A), m_Value(B))) &&
2871  (A == LHS || B == LHS)) {
2872  if (A != LHS) std::swap(A, B); // A pred umax(A, B).
2873  EqP = CmpInst::ICMP_UGE; // "A == umax(A, B)" iff "A uge B".
2874  // We analyze this as umax(A, B) swapped-pred A.
2875  P = CmpInst::getSwappedPredicate(Pred);
2876  } else if (match(LHS, m_UMin(m_Value(A), m_Value(B))) &&
2877  (A == RHS || B == RHS)) {
2878  if (A != RHS) std::swap(A, B); // umin(A, B) pred A.
2879  EqP = CmpInst::ICMP_ULE; // "A == umin(A, B)" iff "A ule B".
2880  // We analyze this as umax(-A, -B) swapped-pred -A.
2881  // Note that we do not need to actually form -A or -B thanks to EqP.
2882  P = CmpInst::getSwappedPredicate(Pred);
2883  } else if (match(RHS, m_UMin(m_Value(A), m_Value(B))) &&
2884  (A == LHS || B == LHS)) {
2885  if (A != LHS) std::swap(A, B); // A pred umin(A, B).
2886  EqP = CmpInst::ICMP_ULE; // "A == umin(A, B)" iff "A ule B".
2887  // We analyze this as umax(-A, -B) pred -A.
2888  // Note that we do not need to actually form -A or -B thanks to EqP.
2889  P = Pred;
2890  }
2891  if (P != CmpInst::BAD_ICMP_PREDICATE) {
2892  // Cases correspond to "max(A, B) p A".
2893  switch (P) {
2894  default:
2895  break;
2896  case CmpInst::ICMP_EQ:
2897  case CmpInst::ICMP_ULE:
2898  // Equivalent to "A EqP B". This may be the same as the condition tested
2899  // in the max/min; if so, we can just return that.
2900  if (Value *V = ExtractEquivalentCondition(LHS, EqP, A, B))
2901  return V;
2902  if (Value *V = ExtractEquivalentCondition(RHS, EqP, A, B))
2903  return V;
2904  // Otherwise, see if "A EqP B" simplifies.
2905  if (MaxRecurse)
2906  if (Value *V = SimplifyICmpInst(EqP, A, B, Q, MaxRecurse-1))
2907  return V;
2908  break;
2909  case CmpInst::ICMP_NE:
2910  case CmpInst::ICMP_UGT: {
2912  // Equivalent to "A InvEqP B". This may be the same as the condition
2913  // tested in the max/min; if so, we can just return that.
2914  if (Value *V = ExtractEquivalentCondition(LHS, InvEqP, A, B))
2915  return V;
2916  if (Value *V = ExtractEquivalentCondition(RHS, InvEqP, A, B))
2917  return V;
2918  // Otherwise, see if "A InvEqP B" simplifies.
2919  if (MaxRecurse)
2920  if (Value *V = SimplifyICmpInst(InvEqP, A, B, Q, MaxRecurse-1))
2921  return V;
2922  break;
2923  }
2924  case CmpInst::ICMP_UGE:
2925  // Always true.
2926  return getTrue(ITy);
2927  case CmpInst::ICMP_ULT:
2928  // Always false.
2929  return getFalse(ITy);
2930  }
2931  }
2932 
2933  // Variants on "max(x,y) >= min(x,z)".
2934  Value *C, *D;
2935  if (match(LHS, m_SMax(m_Value(A), m_Value(B))) &&
2936  match(RHS, m_SMin(m_Value(C), m_Value(D))) &&
2937  (A == C || A == D || B == C || B == D)) {
2938  // max(x, ?) pred min(x, ?).
2939  if (Pred == CmpInst::ICMP_SGE)
2940  // Always true.
2941  return getTrue(ITy);
2942  if (Pred == CmpInst::ICMP_SLT)
2943  // Always false.
2944  return getFalse(ITy);
2945  } else if (match(LHS, m_SMin(m_Value(A), m_Value(B))) &&
2946  match(RHS, m_SMax(m_Value(C), m_Value(D))) &&
2947  (A == C || A == D || B == C || B == D)) {
2948  // min(x, ?) pred max(x, ?).
2949  if (Pred == CmpInst::ICMP_SLE)
2950  // Always true.
2951  return getTrue(ITy);
2952  if (Pred == CmpInst::ICMP_SGT)
2953  // Always false.
2954  return getFalse(ITy);
2955  } else if (match(LHS, m_UMax(m_Value(A), m_Value(B))) &&
2956  match(RHS, m_UMin(m_Value(C), m_Value(D))) &&
2957  (A == C || A == D || B == C || B == D)) {
2958  // max(x, ?) pred min(x, ?).
2959  if (Pred == CmpInst::ICMP_UGE)
2960  // Always true.
2961  return getTrue(ITy);
2962  if (Pred == CmpInst::ICMP_ULT)
2963  // Always false.
2964  return getFalse(ITy);
2965  } else if (match(LHS, m_UMin(m_Value(A), m_Value(B))) &&
2966  match(RHS, m_UMax(m_Value(C), m_Value(D))) &&
2967  (A == C || A == D || B == C || B == D)) {
2968  // min(x, ?) pred max(x, ?).
2969  if (Pred == CmpInst::ICMP_ULE)
2970  // Always true.
2971  return getTrue(ITy);
2972  if (Pred == CmpInst::ICMP_UGT)
2973  // Always false.
2974  return getFalse(ITy);
2975  }
2976 
2977  // Simplify comparisons of related pointers using a powerful, recursive
2978  // GEP-walk when we have target data available..
2979  if (LHS->getType()->isPointerTy())
2980  if (Constant *C = computePointerICmp(Q.DL, Q.TLI, Pred, LHS, RHS))
2981  return C;
2982 
2983  if (GetElementPtrInst *GLHS = dyn_cast<GetElementPtrInst>(LHS)) {
2984  if (GEPOperator *GRHS = dyn_cast<GEPOperator>(RHS)) {
2985  if (GLHS->getPointerOperand() == GRHS->getPointerOperand() &&
2986  GLHS->hasAllConstantIndices() && GRHS->hasAllConstantIndices() &&
2987  (ICmpInst::isEquality(Pred) ||
2988  (GLHS->isInBounds() && GRHS->isInBounds() &&
2989  Pred == ICmpInst::getSignedPredicate(Pred)))) {
2990  // The bases are equal and the indices are constant. Build a constant
2991  // expression GEP with the same indices and a null base pointer to see
2992  // what constant folding can make out of it.
2993  Constant *Null = Constant::getNullValue(GLHS->getPointerOperandType());
2994  SmallVector<Value *, 4> IndicesLHS(GLHS->idx_begin(), GLHS->idx_end());
2996  GLHS->getSourceElementType(), Null, IndicesLHS);
2997 
2998  SmallVector<Value *, 4> IndicesRHS(GRHS->idx_begin(), GRHS->idx_end());
3000  GLHS->getSourceElementType(), Null, IndicesRHS);
3001  return ConstantExpr::getICmp(Pred, NewLHS, NewRHS);
3002  }
3003  }
3004  }
3005 
3006  // If a bit is known to be zero for A and known to be one for B,
3007  // then A and B cannot be equal.
3008  if (ICmpInst::isEquality(Pred)) {
3009  if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) {
3010  uint32_t BitWidth = CI->getBitWidth();
3011  APInt LHSKnownZero(BitWidth, 0);
3012  APInt LHSKnownOne(BitWidth, 0);
3013  computeKnownBits(LHS, LHSKnownZero, LHSKnownOne, Q.DL, /*Depth=*/0, Q.AC,
3014  Q.CxtI, Q.DT);
3015  const APInt &RHSVal = CI->getValue();
3016  if (((LHSKnownZero & RHSVal) != 0) || ((LHSKnownOne & ~RHSVal) != 0))
3017  return Pred == ICmpInst::ICMP_EQ
3018  ? ConstantInt::getFalse(CI->getContext())
3019  : ConstantInt::getTrue(CI->getContext());
3020  }
3021  }
3022 
3023  // If the comparison is with the result of a select instruction, check whether
3024  // comparing with either branch of the select always yields the same value.
3025  if (isa<SelectInst>(LHS) || isa<SelectInst>(RHS))
3026  if (Value *V = ThreadCmpOverSelect(Pred, LHS, RHS, Q, MaxRecurse))
3027  return V;
3028 
3029  // If the comparison is with the result of a phi instruction, check whether
3030  // doing the compare with each incoming phi value yields a common result.
3031  if (isa<PHINode>(LHS) || isa<PHINode>(RHS))
3032  if (Value *V = ThreadCmpOverPHI(Pred, LHS, RHS, Q, MaxRecurse))
3033  return V;
3034 
3035  return nullptr;
3036 }
3037 
3039  const DataLayout &DL,
3040  const TargetLibraryInfo *TLI,
3041  const DominatorTree *DT, AssumptionCache *AC,
3042  Instruction *CxtI) {
3043  return ::SimplifyICmpInst(Predicate, LHS, RHS, Query(DL, TLI, DT, AC, CxtI),
3044  RecursionLimit);
3045 }
3046 
3047 /// SimplifyFCmpInst - Given operands for an FCmpInst, see if we can
3048 /// fold the result. If not, this returns null.
3049 static Value *SimplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS,
3050  FastMathFlags FMF, const Query &Q,
3051  unsigned MaxRecurse) {
3052  CmpInst::Predicate Pred = (CmpInst::Predicate)Predicate;
3053  assert(CmpInst::isFPPredicate(Pred) && "Not an FP compare!");
3054 
3055  if (Constant *CLHS = dyn_cast<Constant>(LHS)) {
3056  if (Constant *CRHS = dyn_cast<Constant>(RHS))
3057  return ConstantFoldCompareInstOperands(Pred, CLHS, CRHS, Q.DL, Q.TLI);
3058 
3059  // If we have a constant, make sure it is on the RHS.
3060  std::swap(LHS, RHS);
3061  Pred = CmpInst::getSwappedPredicate(Pred);
3062  }
3063 
3064  // Fold trivial predicates.
3065  if (Pred == FCmpInst::FCMP_FALSE)
3066  return ConstantInt::get(GetCompareTy(LHS), 0);
3067  if (Pred == FCmpInst::FCMP_TRUE)
3068  return ConstantInt::get(GetCompareTy(LHS), 1);
3069 
3070  // UNO/ORD predicates can be trivially folded if NaNs are ignored.
3071  if (FMF.noNaNs()) {
3072  if (Pred == FCmpInst::FCMP_UNO)
3073  return ConstantInt::get(GetCompareTy(LHS), 0);
3074  if (Pred == FCmpInst::FCMP_ORD)
3075  return ConstantInt::get(GetCompareTy(LHS), 1);
3076  }
3077 
3078  // fcmp pred x, undef and fcmp pred undef, x
3079  // fold to true if unordered, false if ordered
3080  if (isa<UndefValue>(LHS) || isa<UndefValue>(RHS)) {
3081  // Choosing NaN for the undef will always make unordered comparison succeed
3082  // and ordered comparison fail.
3084  }
3085 
3086  // fcmp x,x -> true/false. Not all compares are foldable.
3087  if (LHS == RHS) {
3088  if (CmpInst::isTrueWhenEqual(Pred))
3089  return ConstantInt::get(GetCompareTy(LHS), 1);
3090  if (CmpInst::isFalseWhenEqual(Pred))
3091  return ConstantInt::get(GetCompareTy(LHS), 0);
3092  }
3093 
3094  // Handle fcmp with constant RHS
3095  if (ConstantFP *CFP = dyn_cast<ConstantFP>(RHS)) {
3096  // If the constant is a nan, see if we can fold the comparison based on it.
3097  if (CFP->getValueAPF().isNaN()) {
3098  if (FCmpInst::isOrdered(Pred)) // True "if ordered and foo"
3099  return ConstantInt::getFalse(CFP->getContext());
3100  assert(FCmpInst::isUnordered(Pred) &&
3101  "Comparison must be either ordered or unordered!");
3102  // True if unordered.
3103  return ConstantInt::getTrue(CFP->getContext());
3104  }
3105  // Check whether the constant is an infinity.
3106  if (CFP->getValueAPF().isInfinity()) {
3107  if (CFP->getValueAPF().isNegative()) {
3108  switch (Pred) {
3109  case FCmpInst::FCMP_OLT:
3110  // No value is ordered and less than negative infinity.
3111  return ConstantInt::getFalse(CFP->getContext());
3112  case FCmpInst::FCMP_UGE:
3113  // All values are unordered with or at least negative infinity.
3114  return ConstantInt::getTrue(CFP->getContext());
3115  default:
3116  break;
3117  }
3118  } else {
3119  switch (Pred) {
3120  case FCmpInst::FCMP_OGT:
3121  // No value is ordered and greater than infinity.
3122  return ConstantInt::getFalse(CFP->getContext());
3123  case FCmpInst::FCMP_ULE:
3124  // All values are unordered with and at most infinity.
3125  return ConstantInt::getTrue(CFP->getContext());
3126  default:
3127  break;
3128  }
3129  }
3130  }
3131  if (CFP->getValueAPF().isZero()) {
3132  switch (Pred) {
3133  case FCmpInst::FCMP_UGE:
3134  if (CannotBeOrderedLessThanZero(LHS))
3135  return ConstantInt::getTrue(CFP->getContext());
3136  break;
3137  case FCmpInst::FCMP_OLT:
3138  // X < 0
3139  if (CannotBeOrderedLessThanZero(LHS))
3140  return ConstantInt::getFalse(CFP->getContext());
3141  break;
3142  default:
3143  break;
3144  }
3145  }
3146  }
3147 
3148  // If the comparison is with the result of a select instruction, check whether
3149  // comparing with either branch of the select always yields the same value.
3150  if (isa<SelectInst>(LHS) || isa<SelectInst>(RHS))
3151  if (Value *V = ThreadCmpOverSelect(Pred, LHS, RHS, Q, MaxRecurse))
3152  return V;
3153 
3154  // If the comparison is with the result of a phi instruction, check whether
3155  // doing the compare with each incoming phi value yields a common result.
3156  if (isa<PHINode>(LHS) || isa<PHINode>(RHS))
3157  if (Value *V = ThreadCmpOverPHI(Pred, LHS, RHS, Q, MaxRecurse))
3158  return V;
3159 
3160  return nullptr;
3161 }
3162 
3164  FastMathFlags FMF, const DataLayout &DL,
3165  const TargetLibraryInfo *TLI,
3166  const DominatorTree *DT, AssumptionCache *AC,
3167  const Instruction *CxtI) {
3168  return ::SimplifyFCmpInst(Predicate, LHS, RHS, FMF,
3169  Query(DL, TLI, DT, AC, CxtI), RecursionLimit);
3170 }
3171 
3172 /// SimplifyWithOpReplaced - See if V simplifies when its operand Op is
3173 /// replaced with RepOp.
3174 static const Value *SimplifyWithOpReplaced(Value *V, Value *Op, Value *RepOp,
3175  const Query &Q,
3176  unsigned MaxRecurse) {
3177  // Trivial replacement.
3178  if (V == Op)
3179  return RepOp;
3180 
3181  auto *I = dyn_cast<Instruction>(V);
3182  if (!I)
3183  return nullptr;
3184 
3185  // If this is a binary operator, try to simplify it with the replaced op.
3186  if (auto *B = dyn_cast<BinaryOperator>(I)) {
3187  // Consider:
3188  // %cmp = icmp eq i32 %x, 2147483647
3189  // %add = add nsw i32 %x, 1
3190  // %sel = select i1 %cmp, i32 -2147483648, i32 %add
3191  //
3192  // We can't replace %sel with %add unless we strip away the flags.
3193  if (isa<OverflowingBinaryOperator>(B))
3194  if (B->hasNoSignedWrap() || B->hasNoUnsignedWrap())
3195  return nullptr;
3196  if (isa<PossiblyExactOperator>(B))
3197  if (B->isExact())
3198  return nullptr;
3199 
3200  if (MaxRecurse) {
3201  if (B->getOperand(0) == Op)
3202  return SimplifyBinOp(B->getOpcode(), RepOp, B->getOperand(1), Q,
3203  MaxRecurse - 1);
3204  if (B->getOperand(1) == Op)
3205  return SimplifyBinOp(B->getOpcode(), B->getOperand(0), RepOp, Q,
3206  MaxRecurse - 1);
3207  }
3208  }
3209 
3210  // Same for CmpInsts.
3211  if (CmpInst *C = dyn_cast<CmpInst>(I)) {
3212  if (MaxRecurse) {
3213  if (C->getOperand(0) == Op)
3214  return SimplifyCmpInst(C->getPredicate(), RepOp, C->getOperand(1), Q,
3215  MaxRecurse - 1);
3216  if (C->getOperand(1) == Op)
3217  return SimplifyCmpInst(C->getPredicate(), C->getOperand(0), RepOp, Q,
3218  MaxRecurse - 1);
3219  }
3220  }
3221 
3222  // TODO: We could hand off more cases to instsimplify here.
3223 
3224  // If all operands are constant after substituting Op for RepOp then we can
3225  // constant fold the instruction.
3226  if (Constant *CRepOp = dyn_cast<Constant>(RepOp)) {
3227  // Build a list of all constant operands.
3228  SmallVector<Constant *, 8> ConstOps;
3229  for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i) {
3230  if (I->getOperand(i) == Op)
3231  ConstOps.push_back(CRepOp);
3232  else if (Constant *COp = dyn_cast<Constant>(I->getOperand(i)))
3233  ConstOps.push_back(COp);
3234  else
3235  break;
3236  }
3237 
3238  // All operands were constants, fold it.
3239  if (ConstOps.size() == I->getNumOperands()) {
3240  if (CmpInst *C = dyn_cast<CmpInst>(I))
3241  return ConstantFoldCompareInstOperands(C->getPredicate(), ConstOps[0],
3242  ConstOps[1], Q.DL, Q.TLI);
3243 
3244  if (LoadInst *LI = dyn_cast<LoadInst>(I))
3245  if (!LI->isVolatile())
3246  return ConstantFoldLoadFromConstPtr(ConstOps[0], Q.DL);
3247 
3248  return ConstantFoldInstOperands(I->getOpcode(), I->getType(), ConstOps,
3249  Q.DL, Q.TLI);
3250  }
3251  }
3252 
3253  return nullptr;
3254 }
3255 
3256 /// SimplifySelectInst - Given operands for a SelectInst, see if we can fold
3257 /// the result. If not, this returns null.
3258 static Value *SimplifySelectInst(Value *CondVal, Value *TrueVal,
3259  Value *FalseVal, const Query &Q,
3260  unsigned MaxRecurse) {
3261  // select true, X, Y -> X
3262  // select false, X, Y -> Y
3263  if (Constant *CB = dyn_cast<Constant>(CondVal)) {
3264  if (CB->isAllOnesValue())
3265  return TrueVal;
3266  if (CB->isNullValue())
3267  return FalseVal;
3268  }
3269 
3270  // select C, X, X -> X
3271  if (TrueVal == FalseVal)
3272  return TrueVal;
3273 
3274  if (isa<UndefValue>(CondVal)) { // select undef, X, Y -> X or Y
3275  if (isa<Constant>(TrueVal))
3276  return TrueVal;
3277  return FalseVal;
3278  }
3279  if (isa<UndefValue>(TrueVal)) // select C, undef, X -> X
3280  return FalseVal;
3281  if (isa<UndefValue>(FalseVal)) // select C, X, undef -> X
3282  return TrueVal;
3283 
3284  if (const auto *ICI = dyn_cast<ICmpInst>(CondVal)) {
3285  unsigned BitWidth = Q.DL.getTypeSizeInBits(TrueVal->getType());
3286  ICmpInst::Predicate Pred = ICI->getPredicate();
3287  Value *CmpLHS = ICI->getOperand(0);
3288  Value *CmpRHS = ICI->getOperand(1);
3289  APInt MinSignedValue = APInt::getSignBit(BitWidth);
3290  Value *X;
3291  const APInt *Y;
3292  bool TrueWhenUnset;
3293  bool IsBitTest = false;
3294  if (ICmpInst::isEquality(Pred) &&
3295  match(CmpLHS, m_And(m_Value(X), m_APInt(Y))) &&
3296  match(CmpRHS, m_Zero())) {
3297  IsBitTest = true;
3298  TrueWhenUnset = Pred == ICmpInst::ICMP_EQ;
3299  } else if (Pred == ICmpInst::ICMP_SLT && match(CmpRHS, m_Zero())) {
3300  X = CmpLHS;
3301  Y = &MinSignedValue;
3302  IsBitTest = true;
3303  TrueWhenUnset = false;
3304  } else if (Pred == ICmpInst::ICMP_SGT && match(CmpRHS, m_AllOnes())) {
3305  X = CmpLHS;
3306  Y = &MinSignedValue;
3307  IsBitTest = true;
3308  TrueWhenUnset = true;
3309  }
3310  if (IsBitTest) {
3311  const APInt *C;
3312  // (X & Y) == 0 ? X & ~Y : X --> X
3313  // (X & Y) != 0 ? X & ~Y : X --> X & ~Y
3314  if (FalseVal == X && match(TrueVal, m_And(m_Specific(X), m_APInt(C))) &&
3315  *Y == ~*C)
3316  return TrueWhenUnset ? FalseVal : TrueVal;
3317  // (X & Y) == 0 ? X : X & ~Y --> X & ~Y
3318  // (X & Y) != 0 ? X : X & ~Y --> X
3319  if (TrueVal == X && match(FalseVal, m_And(m_Specific(X), m_APInt(C))) &&
3320  *Y == ~*C)
3321  return TrueWhenUnset ? FalseVal : TrueVal;
3322 
3323  if (Y->isPowerOf2()) {
3324  // (X & Y) == 0 ? X | Y : X --> X | Y
3325  // (X & Y) != 0 ? X | Y : X --> X
3326  if (FalseVal == X && match(TrueVal, m_Or(m_Specific(X), m_APInt(C))) &&
3327  *Y == *C)
3328  return TrueWhenUnset ? TrueVal : FalseVal;
3329  // (X & Y) == 0 ? X : X | Y --> X
3330  // (X & Y) != 0 ? X : X | Y --> X | Y
3331  if (TrueVal == X && match(FalseVal, m_Or(m_Specific(X), m_APInt(C))) &&
3332  *Y == *C)
3333  return TrueWhenUnset ? TrueVal : FalseVal;
3334  }
3335  }
3336  if (ICI->hasOneUse()) {
3337  const APInt *C;
3338  if (match(CmpRHS, m_APInt(C))) {
3339  // X < MIN ? T : F --> F
3340  if (Pred == ICmpInst::ICMP_SLT && C->isMinSignedValue())
3341  return FalseVal;
3342  // X < MIN ? T : F --> F
3343  if (Pred == ICmpInst::ICMP_ULT && C->isMinValue())
3344  return FalseVal;
3345  // X > MAX ? T : F --> F
3346  if (Pred == ICmpInst::ICMP_SGT && C->isMaxSignedValue())
3347  return FalseVal;
3348  // X > MAX ? T : F --> F
3349  if (Pred == ICmpInst::ICMP_UGT && C->isMaxValue())
3350  return FalseVal;
3351  }
3352  }
3353 
3354  // If we have an equality comparison then we know the value in one of the
3355  // arms of the select. See if substituting this value into the arm and
3356  // simplifying the result yields the same value as the other arm.
3357  if (Pred == ICmpInst::ICMP_EQ) {
3358  if (SimplifyWithOpReplaced(FalseVal, CmpLHS, CmpRHS, Q, MaxRecurse) ==
3359  TrueVal ||
3360  SimplifyWithOpReplaced(FalseVal, CmpRHS, CmpLHS, Q, MaxRecurse) ==
3361  TrueVal)
3362  return FalseVal;
3363  if (SimplifyWithOpReplaced(TrueVal, CmpLHS, CmpRHS, Q, MaxRecurse) ==
3364  FalseVal ||
3365  SimplifyWithOpReplaced(TrueVal, CmpRHS, CmpLHS, Q, MaxRecurse) ==
3366  FalseVal)
3367  return FalseVal;
3368  } else if (Pred == ICmpInst::ICMP_NE) {
3369  if (SimplifyWithOpReplaced(TrueVal, CmpLHS, CmpRHS, Q, MaxRecurse) ==
3370  FalseVal ||
3371  SimplifyWithOpReplaced(TrueVal, CmpRHS, CmpLHS, Q, MaxRecurse) ==
3372  FalseVal)
3373  return TrueVal;
3374  if (SimplifyWithOpReplaced(FalseVal, CmpLHS, CmpRHS, Q, MaxRecurse) ==
3375  TrueVal ||
3376  SimplifyWithOpReplaced(FalseVal, CmpRHS, CmpLHS, Q, MaxRecurse) ==
3377  TrueVal)
3378  return TrueVal;
3379  }
3380  }
3381 
3382  return nullptr;
3383 }
3384 
3385 Value *llvm::SimplifySelectInst(Value *Cond, Value *TrueVal, Value *FalseVal,
3386  const DataLayout &DL,
3387  const TargetLibraryInfo *TLI,
3388  const DominatorTree *DT, AssumptionCache *AC,
3389  const Instruction *CxtI) {
3390  return ::SimplifySelectInst(Cond, TrueVal, FalseVal,
3391  Query(DL, TLI, DT, AC, CxtI), RecursionLimit);
3392 }
3393 
3394 /// SimplifyGEPInst - Given operands for an GetElementPtrInst, see if we can
3395 /// fold the result. If not, this returns null.
3397  const Query &Q, unsigned) {
3398  // The type of the GEP pointer operand.
3399  unsigned AS =
3400  cast<PointerType>(Ops[0]->getType()->getScalarType())->getAddressSpace();
3401 
3402  // getelementptr P -> P.
3403  if (Ops.size() == 1)
3404  return Ops[0];
3405 
3406  // Compute the (pointer) type returned by the GEP instruction.
3407  Type *LastType = GetElementPtrInst::getIndexedType(SrcTy, Ops.slice(1));
3408  Type *GEPTy = PointerType::get(LastType, AS);
3409  if (VectorType *VT = dyn_cast<VectorType>(Ops[0]->getType()))
3410  GEPTy = VectorType::get(GEPTy, VT->getNumElements());
3411 
3412  if (isa<UndefValue>(Ops[0]))
3413  return UndefValue::get(GEPTy);
3414 
3415  if (Ops.size() == 2) {
3416  // getelementptr P, 0 -> P.
3417  if (match(Ops[1], m_Zero()))
3418  return Ops[0];
3419 
3420  Type *Ty = SrcTy;
3421  if (Ty->isSized()) {
3422  Value *P;
3423  uint64_t C;
3424  uint64_t TyAllocSize = Q.DL.getTypeAllocSize(Ty);
3425  // getelementptr P, N -> P if P points to a type of zero size.
3426  if (TyAllocSize == 0)
3427  return Ops[0];
3428 
3429  // The following transforms are only safe if the ptrtoint cast
3430  // doesn't truncate the pointers.
3431  if (Ops[1]->getType()->getScalarSizeInBits() ==
3432  Q.DL.getPointerSizeInBits(AS)) {
3433  auto PtrToIntOrZero = [GEPTy](Value *P) -> Value * {
3434  if (match(P, m_Zero()))
3435  return Constant::getNullValue(GEPTy);
3436  Value *Temp;
3437  if (match(P, m_PtrToInt(m_Value(Temp))))
3438  if (Temp->getType() == GEPTy)
3439  return Temp;
3440  return nullptr;
3441  };
3442 
3443  // getelementptr V, (sub P, V) -> P if P points to a type of size 1.
3444  if (TyAllocSize == 1 &&
3445  match(Ops[1], m_Sub(m_Value(P), m_PtrToInt(m_Specific(Ops[0])))))
3446  if (Value *R = PtrToIntOrZero(P))
3447  return R;
3448 
3449  // getelementptr V, (ashr (sub P, V), C) -> Q
3450  // if P points to a type of size 1 << C.
3451  if (match(Ops[1],
3452  m_AShr(m_Sub(m_Value(P), m_PtrToInt(m_Specific(Ops[0]))),
3453  m_ConstantInt(C))) &&
3454  TyAllocSize == 1ULL << C)
3455  if (Value *R = PtrToIntOrZero(P))
3456  return R;
3457 
3458  // getelementptr V, (sdiv (sub P, V), C) -> Q
3459  // if P points to a type of size C.
3460  if (match(Ops[1],
3461  m_SDiv(m_Sub(m_Value(P), m_PtrToInt(m_Specific(Ops[0]))),
3462  m_SpecificInt(TyAllocSize))))
3463  if (Value *R = PtrToIntOrZero(P))
3464  return R;
3465  }
3466  }
3467  }
3468 
3469  // Check to see if this is constant foldable.
3470  for (unsigned i = 0, e = Ops.size(); i != e; ++i)
3471  if (!isa<Constant>(Ops[i]))
3472  return nullptr;
3473 
3474  return ConstantExpr::getGetElementPtr(SrcTy, cast<Constant>(Ops[0]),
3475  Ops.slice(1));
3476 }
3477 
3479  const TargetLibraryInfo *TLI,
3480  const DominatorTree *DT, AssumptionCache *AC,
3481  const Instruction *CxtI) {
3483  cast<PointerType>(Ops[0]->getType()->getScalarType())->getElementType(),
3484  Ops, Query(DL, TLI, DT, AC, CxtI), RecursionLimit);
3485 }
3486 
3487 /// SimplifyInsertValueInst - Given operands for an InsertValueInst, see if we
3488 /// can fold the result. If not, this returns null.
3490  ArrayRef<unsigned> Idxs, const Query &Q,
3491  unsigned) {
3492  if (Constant *CAgg = dyn_cast<Constant>(Agg))
3493  if (Constant *CVal = dyn_cast<Constant>(Val))
3494  return ConstantFoldInsertValueInstruction(CAgg, CVal, Idxs);
3495 
3496  // insertvalue x, undef, n -> x
3497  if (match(Val, m_Undef()))
3498  return Agg;
3499 
3500  // insertvalue x, (extractvalue y, n), n
3501  if (ExtractValueInst *EV = dyn_cast<ExtractValueInst>(Val))
3502  if (EV->getAggregateOperand()->getType() == Agg->getType() &&
3503  EV->getIndices() == Idxs) {
3504  // insertvalue undef, (extractvalue y, n), n -> y
3505  if (match(Agg, m_Undef()))
3506  return EV->getAggregateOperand();
3507 
3508  // insertvalue y, (extractvalue y, n), n -> y
3509  if (Agg == EV->getAggregateOperand())
3510  return Agg;
3511  }
3512 
3513  return nullptr;
3514 }
3515 
3517  Value *Agg, Value *Val, ArrayRef<unsigned> Idxs, const DataLayout &DL,
3518  const TargetLibraryInfo *TLI, const DominatorTree *DT, AssumptionCache *AC,
3519  const Instruction *CxtI) {
3520  return ::SimplifyInsertValueInst(Agg, Val, Idxs, Query(DL, TLI, DT, AC, CxtI),
3521  RecursionLimit);
3522 }
3523 
3524 /// SimplifyExtractValueInst - Given operands for an ExtractValueInst, see if we
3525 /// can fold the result. If not, this returns null.
3527  const Query &, unsigned) {
3528  if (auto *CAgg = dyn_cast<Constant>(Agg))
3529  return ConstantFoldExtractValueInstruction(CAgg, Idxs);
3530 
3531  // extractvalue x, (insertvalue y, elt, n), n -> elt
3532  unsigned NumIdxs = Idxs.size();
3533  for (auto *IVI = dyn_cast<InsertValueInst>(Agg); IVI != nullptr;
3534  IVI = dyn_cast<InsertValueInst>(IVI->getAggregateOperand())) {
3535  ArrayRef<unsigned> InsertValueIdxs = IVI->getIndices();
3536  unsigned NumInsertValueIdxs = InsertValueIdxs.size();
3537  unsigned NumCommonIdxs = std::min(NumInsertValueIdxs, NumIdxs);
3538  if (InsertValueIdxs.slice(0, NumCommonIdxs) ==
3539  Idxs.slice(0, NumCommonIdxs)) {
3540  if (NumIdxs == NumInsertValueIdxs)
3541  return IVI->getInsertedValueOperand();
3542  break;
3543  }
3544  }
3545 
3546  return nullptr;
3547 }
3548 
3550  const DataLayout &DL,
3551  const TargetLibraryInfo *TLI,
3552  const DominatorTree *DT,
3553  AssumptionCache *AC,
3554  const Instruction *CxtI) {
3555  return ::SimplifyExtractValueInst(Agg, Idxs, Query(DL, TLI, DT, AC, CxtI),
3556  RecursionLimit);
3557 }
3558 
3559 /// SimplifyExtractElementInst - Given operands for an ExtractElementInst, see if we
3560 /// can fold the result. If not, this returns null.
3561 static Value *SimplifyExtractElementInst(Value *Vec, Value *Idx, const Query &,
3562  unsigned) {
3563  if (auto *CVec = dyn_cast<Constant>(Vec)) {
3564  if (auto *CIdx = dyn_cast<Constant>(Idx))
3565  return ConstantFoldExtractElementInstruction(CVec, CIdx);
3566 
3567  // The index is not relevant if our vector is a splat.
3568  if (auto *Splat = CVec->getSplatValue())
3569  return Splat;
3570 
3571  if (isa<UndefValue>(Vec))
3572  return UndefValue::get(Vec->getType()->getVectorElementType());
3573  }
3574 
3575  // If extracting a specified index from the vector, see if we can recursively
3576  // find a previously computed scalar that was inserted into the vector.
3577  if (auto *IdxC = dyn_cast<ConstantInt>(Idx))
3578  if (Value *Elt = findScalarElement(Vec, IdxC->getZExtValue()))
3579  return Elt;
3580 
3581  return nullptr;
3582 }
3583 
3585  Value *Vec, Value *Idx, const DataLayout &DL, const TargetLibraryInfo *TLI,
3586  const DominatorTree *DT, AssumptionCache *AC, const Instruction *CxtI) {
3587  return ::SimplifyExtractElementInst(Vec, Idx, Query(DL, TLI, DT, AC, CxtI),
3588  RecursionLimit);
3589 }
3590 
3591 /// SimplifyPHINode - See if we can fold the given phi. If not, returns null.
3592 static Value *SimplifyPHINode(PHINode *PN, const Query &Q) {
3593  // If all of the PHI's incoming values are the same then replace the PHI node
3594  // with the common value.
3595  Value *CommonValue = nullptr;
3596  bool HasUndefInput = false;
3597  for (Value *Incoming : PN->incoming_values()) {
3598  // If the incoming value is the phi node itself, it can safely be skipped.
3599  if (Incoming == PN) continue;
3600  if (isa<UndefValue>(Incoming)) {
3601  // Remember that we saw an undef value, but otherwise ignore them.
3602  HasUndefInput = true;
3603  continue;
3604  }
3605  if (CommonValue && Incoming != CommonValue)
3606  return nullptr; // Not the same, bail out.
3607  CommonValue = Incoming;
3608  }
3609 
3610  // If CommonValue is null then all of the incoming values were either undef or
3611  // equal to the phi node itself.
3612  if (!CommonValue)
3613  return UndefValue::get(PN->getType());
3614 
3615  // If we have a PHI node like phi(X, undef, X), where X is defined by some
3616  // instruction, we cannot return X as the result of the PHI node unless it
3617  // dominates the PHI block.
3618  if (HasUndefInput)
3619  return ValueDominatesPHI(CommonValue, PN, Q.DT) ? CommonValue : nullptr;
3620 
3621  return CommonValue;
3622 }
3623 
3624 static Value *SimplifyTruncInst(Value *Op, Type *Ty, const Query &Q, unsigned) {
3625  if (Constant *C = dyn_cast<Constant>(Op))
3626  return ConstantFoldInstOperands(Instruction::Trunc, Ty, C, Q.DL, Q.TLI);
3627 
3628  return nullptr;
3629 }
3630 
3632  const TargetLibraryInfo *TLI,
3633  const DominatorTree *DT, AssumptionCache *AC,
3634  const Instruction *CxtI) {
3635  return ::SimplifyTruncInst(Op, Ty, Query(DL, TLI, DT, AC, CxtI),
3636  RecursionLimit);
3637 }
3638 
3639 //=== Helper functions for higher up the class hierarchy.
3640 
3641 /// SimplifyBinOp - Given operands for a BinaryOperator, see if we can
3642 /// fold the result. If not, this returns null.
3643 static Value *SimplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS,
3644  const Query &Q, unsigned MaxRecurse) {
3645  switch (Opcode) {
3646  case Instruction::Add:
3647  return SimplifyAddInst(LHS, RHS, /*isNSW*/false, /*isNUW*/false,
3648  Q, MaxRecurse);
3649  case Instruction::FAdd:
3650  return SimplifyFAddInst(LHS, RHS, FastMathFlags(), Q, MaxRecurse);
3651 
3652  case Instruction::Sub:
3653  return SimplifySubInst(LHS, RHS, /*isNSW*/false, /*isNUW*/false,
3654  Q, MaxRecurse);
3655  case Instruction::FSub:
3656  return SimplifyFSubInst(LHS, RHS, FastMathFlags(), Q, MaxRecurse);
3657 
3658  case Instruction::Mul: return SimplifyMulInst (LHS, RHS, Q, MaxRecurse);
3659  case Instruction::FMul:
3660  return SimplifyFMulInst (LHS, RHS, FastMathFlags(), Q, MaxRecurse);
3661  case Instruction::SDiv: return SimplifySDivInst(LHS, RHS, Q, MaxRecurse);
3662  case Instruction::UDiv: return SimplifyUDivInst(LHS, RHS, Q, MaxRecurse);
3663  case Instruction::FDiv:
3664  return SimplifyFDivInst(LHS, RHS, FastMathFlags(), Q, MaxRecurse);
3665  case Instruction::SRem: return SimplifySRemInst(LHS, RHS, Q, MaxRecurse);
3666  case Instruction::URem: return SimplifyURemInst(LHS, RHS, Q, MaxRecurse);
3667  case Instruction::FRem:
3668  return SimplifyFRemInst(LHS, RHS, FastMathFlags(), Q, MaxRecurse);
3669  case Instruction::Shl:
3670  return SimplifyShlInst(LHS, RHS, /*isNSW*/false, /*isNUW*/false,
3671  Q, MaxRecurse);
3672  case Instruction::LShr:
3673  return SimplifyLShrInst(LHS, RHS, /*isExact*/false, Q, MaxRecurse);
3674  case Instruction::AShr:
3675  return SimplifyAShrInst(LHS, RHS, /*isExact*/false, Q, MaxRecurse);
3676  case Instruction::And: return SimplifyAndInst(LHS, RHS, Q, MaxRecurse);
3677  case Instruction::Or: return SimplifyOrInst (LHS, RHS, Q, MaxRecurse);
3678  case Instruction::Xor: return SimplifyXorInst(LHS, RHS, Q, MaxRecurse);
3679  default:
3680  if (Constant *CLHS = dyn_cast<Constant>(LHS))
3681  if (Constant *CRHS = dyn_cast<Constant>(RHS)) {
3682  Constant *COps[] = {CLHS, CRHS};
3683  return ConstantFoldInstOperands(Opcode, LHS->getType(), COps, Q.DL,
3684  Q.TLI);
3685  }
3686 
3687  // If the operation is associative, try some generic simplifications.
3688  if (Instruction::isAssociative(Opcode))
3689  if (Value *V = SimplifyAssociativeBinOp(Opcode, LHS, RHS, Q, MaxRecurse))
3690  return V;
3691 
3692  // If the operation is with the result of a select instruction check whether
3693  // operating on either branch of the select always yields the same value.
3694  if (isa<SelectInst>(LHS) || isa<SelectInst>(RHS))
3695  if (Value *V = ThreadBinOpOverSelect(Opcode, LHS, RHS, Q, MaxRecurse))
3696  return V;
3697 
3698  // If the operation is with the result of a phi instruction, check whether
3699  // operating on all incoming values of the phi always yields the same value.
3700  if (isa<PHINode>(LHS) || isa<PHINode>(RHS))
3701  if (Value *V = ThreadBinOpOverPHI(Opcode, LHS, RHS, Q, MaxRecurse))
3702  return V;
3703 
3704  return nullptr;
3705  }
3706 }
3707 
3708 /// SimplifyFPBinOp - Given operands for a BinaryOperator, see if we can
3709 /// fold the result. If not, this returns null.
3710 /// In contrast to SimplifyBinOp, try to use FastMathFlag when folding the
3711 /// result. In case we don't need FastMathFlags, simply fall to SimplifyBinOp.
3712 static Value *SimplifyFPBinOp(unsigned Opcode, Value *LHS, Value *RHS,
3713  const FastMathFlags &FMF, const Query &Q,
3714  unsigned MaxRecurse) {
3715  switch (Opcode) {
3716  case Instruction::FAdd:
3717  return SimplifyFAddInst(LHS, RHS, FMF, Q, MaxRecurse);
3718  case Instruction::FSub:
3719  return SimplifyFSubInst(LHS, RHS, FMF, Q, MaxRecurse);
3720  case Instruction::FMul:
3721  return SimplifyFMulInst(LHS, RHS, FMF, Q, MaxRecurse);
3722  default:
3723  return SimplifyBinOp(Opcode, LHS, RHS, Q, MaxRecurse);
3724  }
3725 }
3726 
3727 Value *llvm::SimplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS,
3728  const DataLayout &DL, const TargetLibraryInfo *TLI,
3729  const DominatorTree *DT, AssumptionCache *AC,
3730  const Instruction *CxtI) {
3731  return ::SimplifyBinOp(Opcode, LHS, RHS, Query(DL, TLI, DT, AC, CxtI),
3732  RecursionLimit);
3733 }
3734 
3735 Value *llvm::SimplifyFPBinOp(unsigned Opcode, Value *LHS, Value *RHS,
3736  const FastMathFlags &FMF, const DataLayout &DL,
3737  const TargetLibraryInfo *TLI,
3738  const DominatorTree *DT, AssumptionCache *AC,
3739  const Instruction *CxtI) {
3740  return ::SimplifyFPBinOp(Opcode, LHS, RHS, FMF, Query(DL, TLI, DT, AC, CxtI),
3741  RecursionLimit);
3742 }
3743 
3744 /// SimplifyCmpInst - Given operands for a CmpInst, see if we can
3745 /// fold the result.
3746 static Value *SimplifyCmpInst(unsigned Predicate, Value *LHS, Value *RHS,
3747  const Query &Q, unsigned MaxRecurse) {
3749  return SimplifyICmpInst(Predicate, LHS, RHS, Q, MaxRecurse);
3750  return SimplifyFCmpInst(Predicate, LHS, RHS, FastMathFlags(), Q, MaxRecurse);
3751 }
3752 
3754  const DataLayout &DL, const TargetLibraryInfo *TLI,
3755  const DominatorTree *DT, AssumptionCache *AC,
3756  const Instruction *CxtI) {
3757  return ::SimplifyCmpInst(Predicate, LHS, RHS, Query(DL, TLI, DT, AC, CxtI),
3758  RecursionLimit);
3759 }
3760 
3762  switch (ID) {
3763  default: return false;
3764 
3765  // Unary idempotent: f(f(x)) = f(x)
3766  case Intrinsic::fabs:
3767  case Intrinsic::floor:
3768  case Intrinsic::ceil:
3769  case Intrinsic::trunc:
3770  case Intrinsic::rint:
3771  case Intrinsic::nearbyint:
3772  case Intrinsic::round:
3773  return true;
3774  }
3775 }
3776 
3777 template <typename IterTy>
3778 static Value *SimplifyIntrinsic(Function *F, IterTy ArgBegin, IterTy ArgEnd,
3779  const Query &Q, unsigned MaxRecurse) {
3780  Intrinsic::ID IID = F->getIntrinsicID();
3781  unsigned NumOperands = std::distance(ArgBegin, ArgEnd);
3782  Type *ReturnType = F->getReturnType();
3783 
3784  // Binary Ops
3785  if (NumOperands == 2) {
3786  Value *LHS = *ArgBegin;
3787  Value *RHS = *(ArgBegin + 1);
3788  if (IID == Intrinsic::usub_with_overflow ||
3789  IID == Intrinsic::ssub_with_overflow) {
3790  // X - X -> { 0, false }
3791  if (LHS == RHS)
3792  return Constant::getNullValue(ReturnType);
3793 
3794  // X - undef -> undef
3795  // undef - X -> undef
3796  if (isa<UndefValue>(LHS) || isa<UndefValue>(RHS))
3797  return UndefValue::get(ReturnType);
3798  }
3799 
3800  if (IID == Intrinsic::uadd_with_overflow ||
3801  IID == Intrinsic::sadd_with_overflow) {
3802  // X + undef -> undef
3803  if (isa<UndefValue>(RHS))
3804  return UndefValue::get(ReturnType);
3805  }
3806 
3807  if (IID == Intrinsic::umul_with_overflow ||
3808  IID == Intrinsic::smul_with_overflow) {
3809  // X * 0 -> { 0, false }
3810  if (match(RHS, m_Zero()))
3811  return Constant::getNullValue(ReturnType);
3812 
3813  // X * undef -> { 0, false }
3814  if (match(RHS, m_Undef()))
3815  return Constant::getNullValue(ReturnType);
3816  }
3817  }
3818 
3819  // Perform idempotent optimizations
3820  if (!IsIdempotent(IID))
3821  return nullptr;
3822 
3823  // Unary Ops
3824  if (NumOperands == 1)
3825  if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(*ArgBegin))
3826  if (II->getIntrinsicID() == IID)
3827  return II;
3828 
3829  return nullptr;
3830 }
3831 
3832 template <typename IterTy>
3833 static Value *SimplifyCall(Value *V, IterTy ArgBegin, IterTy ArgEnd,
3834  const Query &Q, unsigned MaxRecurse) {
3835  Type *Ty = V->getType();
3836  if (PointerType *PTy = dyn_cast<PointerType>(Ty))
3837  Ty = PTy->getElementType();
3838  FunctionType *FTy = cast<FunctionType>(Ty);
3839 
3840  // call undef -> undef
3841  if (isa<UndefValue>(V))
3842  return UndefValue::get(FTy->getReturnType());
3843 
3844  Function *F = dyn_cast<Function>(V);
3845  if (!F)
3846  return nullptr;
3847 
3848  if (F->isIntrinsic())
3849  if (Value *Ret = SimplifyIntrinsic(F, ArgBegin, ArgEnd, Q, MaxRecurse))
3850  return Ret;
3851 
3852  if (!canConstantFoldCallTo(F))
3853  return nullptr;
3854 
3855  SmallVector<Constant *, 4> ConstantArgs;
3856  ConstantArgs.reserve(ArgEnd - ArgBegin);
3857  for (IterTy I = ArgBegin, E = ArgEnd; I != E; ++I) {
3858  Constant *C = dyn_cast<Constant>(*I);
3859  if (!C)
3860  return nullptr;
3861  ConstantArgs.push_back(C);
3862  }
3863 
3864  return ConstantFoldCall(F, ConstantArgs, Q.TLI);
3865 }
3866 
3868  User::op_iterator ArgEnd, const DataLayout &DL,
3869  const TargetLibraryInfo *TLI, const DominatorTree *DT,
3870  AssumptionCache *AC, const Instruction *CxtI) {
3871  return ::SimplifyCall(V, ArgBegin, ArgEnd, Query(DL, TLI, DT, AC, CxtI),
3872  RecursionLimit);
3873 }
3874 
3876  const DataLayout &DL, const TargetLibraryInfo *TLI,
3877  const DominatorTree *DT, AssumptionCache *AC,
3878  const Instruction *CxtI) {
3879  return ::SimplifyCall(V, Args.begin(), Args.end(),
3880  Query(DL, TLI, DT, AC, CxtI), RecursionLimit);
3881 }
3882 
3883 /// SimplifyInstruction - See if we can compute a simplified version of this
3884 /// instruction. If not, this returns null.
3886  const TargetLibraryInfo *TLI,
3887  const DominatorTree *DT, AssumptionCache *AC) {
3888  Value *Result;
3889 
3890  switch (I->getOpcode()) {
3891  default:
3892  Result = ConstantFoldInstruction(I, DL, TLI);
3893  break;
3894  case Instruction::FAdd:
3895  Result = SimplifyFAddInst(I->getOperand(0), I->getOperand(1),
3896  I->getFastMathFlags(), DL, TLI, DT, AC, I);
3897  break;
3898  case Instruction::Add:
3899  Result = SimplifyAddInst(I->getOperand(0), I->getOperand(1),
3900  cast<BinaryOperator>(I)->hasNoSignedWrap(),
3901  cast<BinaryOperator>(I)->hasNoUnsignedWrap(), DL,
3902  TLI, DT, AC, I);
3903  break;
3904  case Instruction::FSub:
3905  Result = SimplifyFSubInst(I->getOperand(0), I->getOperand(1),
3906  I->getFastMathFlags(), DL, TLI, DT, AC, I);
3907  break;
3908  case Instruction::Sub:
3909  Result = SimplifySubInst(I->getOperand(0), I->getOperand(1),
3910  cast<BinaryOperator>(I)->hasNoSignedWrap(),
3911  cast<BinaryOperator>(I)->hasNoUnsignedWrap(), DL,
3912  TLI, DT, AC, I);
3913  break;
3914  case Instruction::FMul:
3915  Result = SimplifyFMulInst(I->getOperand(0), I->getOperand(1),
3916  I->getFastMathFlags(), DL, TLI, DT, AC, I);
3917  break;
3918  case Instruction::Mul:
3919  Result =
3920  SimplifyMulInst(I->getOperand(0), I->getOperand(1), DL, TLI, DT, AC, I);
3921  break;
3922  case Instruction::SDiv:
3923  Result = SimplifySDivInst(I->getOperand(0), I->getOperand(1), DL, TLI, DT,
3924  AC, I);
3925  break;
3926  case Instruction::UDiv:
3927  Result = SimplifyUDivInst(I->getOperand(0), I->getOperand(1), DL, TLI, DT,
3928  AC, I);
3929  break;
3930  case Instruction::FDiv:
3931  Result = SimplifyFDivInst(I->getOperand(0), I->getOperand(1),
3932  I->getFastMathFlags(), DL, TLI, DT, AC, I);
3933  break;
3934  case Instruction::SRem:
3935  Result = SimplifySRemInst(I->getOperand(0), I->getOperand(1), DL, TLI, DT,
3936  AC, I);
3937  break;
3938  case Instruction::URem:
3939  Result = SimplifyURemInst(I->getOperand(0), I->getOperand(1), DL, TLI, DT,
3940  AC, I);
3941  break;
3942  case Instruction::FRem:
3943  Result = SimplifyFRemInst(I->getOperand(0), I->getOperand(1),
3944  I->getFastMathFlags(), DL, TLI, DT, AC, I);
3945  break;
3946  case Instruction::Shl:
3947  Result = SimplifyShlInst(I->getOperand(0), I->getOperand(1),
3948  cast<BinaryOperator>(I)->hasNoSignedWrap(),
3949  cast<BinaryOperator>(I)->hasNoUnsignedWrap(), DL,
3950  TLI, DT, AC, I);
3951  break;
3952  case Instruction::LShr:
3953  Result = SimplifyLShrInst(I->getOperand(0), I->getOperand(1),
3954  cast<BinaryOperator>(I)->isExact(), DL, TLI, DT,
3955  AC, I);
3956  break;
3957  case Instruction::AShr:
3958  Result = SimplifyAShrInst(I->getOperand(0), I->getOperand(1),
3959  cast<BinaryOperator>(I)->isExact(), DL, TLI, DT,
3960  AC, I);
3961  break;
3962  case Instruction::And:
3963  Result =
3964  SimplifyAndInst(I->getOperand(0), I->getOperand(1), DL, TLI, DT, AC, I);
3965  break;
3966  case Instruction::Or:
3967  Result =
3968  SimplifyOrInst(I->getOperand(0), I->getOperand(1), DL, TLI, DT, AC, I);
3969  break;
3970  case Instruction::Xor:
3971  Result =
3972  SimplifyXorInst(I->getOperand(0), I->getOperand(1), DL, TLI, DT, AC, I);
3973  break;
3974  case Instruction::ICmp:
3975  Result =
3976  SimplifyICmpInst(cast<ICmpInst>(I)->getPredicate(), I->getOperand(0),
3977  I->getOperand(1), DL, TLI, DT, AC, I);
3978  break;
3979  case Instruction::FCmp:
3980  Result = SimplifyFCmpInst(cast<FCmpInst>(I)->getPredicate(),
3981  I->getOperand(0), I->getOperand(1),
3982  I->getFastMathFlags(), DL, TLI, DT, AC, I);
3983  break;
3984  case Instruction::Select:
3985  Result = SimplifySelectInst(I->getOperand(0), I->getOperand(1),
3986  I->getOperand(2), DL, TLI, DT, AC, I);
3987  break;
3988  case Instruction::GetElementPtr: {
3989  SmallVector<Value*, 8> Ops(I->op_begin(), I->op_end());
3990  Result = SimplifyGEPInst(Ops, DL, TLI, DT, AC, I);
3991  break;
3992  }
3993  case Instruction::InsertValue: {
3994  InsertValueInst *IV = cast<InsertValueInst>(I);
3997  IV->getIndices(), DL, TLI, DT, AC, I);
3998  break;
3999  }
4000  case Instruction::ExtractValue: {
4001  auto *EVI = cast<ExtractValueInst>(I);
4002  Result = SimplifyExtractValueInst(EVI->getAggregateOperand(),
4003  EVI->getIndices(), DL, TLI, DT, AC, I);
4004  break;
4005  }
4007  auto *EEI = cast<ExtractElementInst>(I);
4008  Result = SimplifyExtractElementInst(
4009  EEI->getVectorOperand(), EEI->getIndexOperand(), DL, TLI, DT, AC, I);
4010  break;
4011  }
4012  case Instruction::PHI:
4013  Result = SimplifyPHINode(cast<PHINode>(I), Query(DL, TLI, DT, AC, I));
4014  break;
4015  case Instruction::Call: {
4016  CallSite CS(cast<CallInst>(I));
4017  Result = SimplifyCall(CS.getCalledValue(), CS.arg_begin(), CS.arg_end(), DL,
4018  TLI, DT, AC, I);
4019  break;
4020  }
4021  case Instruction::Trunc:
4022  Result =
4023  SimplifyTruncInst(I->getOperand(0), I->getType(), DL, TLI, DT, AC, I);
4024  break;
4025  }
4026 
4027  /// If called on unreachable code, the above logic may report that the
4028  /// instruction simplified to itself. Make life easier for users by
4029  /// detecting that case here, returning a safe value instead.
4030  return Result == I ? UndefValue::get(I->getType()) : Result;
4031 }
4032 
4033 /// \brief Implementation of recursive simplification through an instructions
4034 /// uses.
4035 ///
4036 /// This is the common implementation of the recursive simplification routines.
4037 /// If we have a pre-simplified value in 'SimpleV', that is forcibly used to
4038 /// replace the instruction 'I'. Otherwise, we simply add 'I' to the list of
4039 /// instructions to process and attempt to simplify it using
4040 /// InstructionSimplify.
4041 ///
4042 /// This routine returns 'true' only when *it* simplifies something. The passed
4043 /// in simplified value does not count toward this.
4045  const TargetLibraryInfo *TLI,
4046  const DominatorTree *DT,
4047  AssumptionCache *AC) {
4048  bool Simplified = false;
4050  const DataLayout &DL = I->getModule()->getDataLayout();
4051 
4052  // If we have an explicit value to collapse to, do that round of the
4053  // simplification loop by hand initially.
4054  if (SimpleV) {
4055  for (User *U : I->users())
4056  if (U != I)
4057  Worklist.insert(cast<Instruction>(U));
4058 
4059  // Replace the instruction with its simplified value.
4060  I->replaceAllUsesWith(SimpleV);
4061 
4062  // Gracefully handle edge cases where the instruction is not wired into any
4063  // parent block.
4064  if (I->getParent())
4065  I->eraseFromParent();
4066  } else {
4067  Worklist.insert(I);
4068  }
4069 
4070  // Note that we must test the size on each iteration, the worklist can grow.
4071  for (unsigned Idx = 0; Idx != Worklist.size(); ++Idx) {
4072  I = Worklist[Idx];
4073 
4074  // See if this instruction simplifies.
4075  SimpleV = SimplifyInstruction(I, DL, TLI, DT, AC);
4076  if (!SimpleV)
4077  continue;
4078 
4079  Simplified = true;
4080 
4081  // Stash away all the uses of the old instruction so we can check them for
4082  // recursive simplifications after a RAUW. This is cheaper than checking all
4083  // uses of To on the recursive step in most cases.
4084  for (User *U : I->users())
4085  Worklist.insert(cast<Instruction>(U));
4086 
4087  // Replace the instruction with its simplified value.
4088  I->replaceAllUsesWith(SimpleV);
4089 
4090  // Gracefully handle edge cases where the instruction is not wired into any
4091  // parent block.
4092  if (I->getParent())
4093  I->eraseFromParent();
4094  }
4095  return Simplified;
4096 }
4097 
4099  const TargetLibraryInfo *TLI,
4100  const DominatorTree *DT,
4101  AssumptionCache *AC) {
4102  return replaceAndRecursivelySimplifyImpl(I, nullptr, TLI, DT, AC);
4103 }
4104 
4106  const TargetLibraryInfo *TLI,
4107  const DominatorTree *DT,
4108  AssumptionCache *AC) {
4109  assert(I != SimpleV && "replaceAndRecursivelySimplify(X,X) is not valid!");
4110  assert(SimpleV && "Must provide a simplified value.");
4111  return replaceAndRecursivelySimplifyImpl(I, SimpleV, TLI, DT, AC);
4112 }
MaxMin_match< ICmpInst, LHS, RHS, umin_pred_ty > m_UMin(const LHS &L, const RHS &R)
static Value * SimplifyBinOp(unsigned, Value *, Value *, const Query &, unsigned)
SimplifyBinOp - Given operands for a BinaryOperator, see if we can fold the result.
BinaryOp_match< LHS, RHS, Instruction::And > m_And(const LHS &L, const RHS &R)
Definition: PatternMatch.h:506
APInt LLVM_ATTRIBUTE_UNUSED_RESULT ashr(unsigned shiftAmt) const
Arithmetic right-shift function.
Definition: APInt.cpp:1051
iplist< Instruction >::iterator eraseFromParent()
eraseFromParent - This method unlinks 'this' from the containing basic block and deletes it...
Definition: Instruction.cpp:70
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:104
static ConstantInt * getFalse(LLVMContext &Context)
Definition: Constants.cpp:537
class_match< Value > m_Value()
Match an arbitrary value and ignore it.
Definition: PatternMatch.h:64
This class is the base class for the comparison instructions.
Definition: InstrTypes.h:679
static APInt getSignBit(unsigned BitWidth)
Get the SignBit for a specific bit width.
Definition: APInt.h:446
class_match< UndefValue > m_Undef()
Match an arbitrary undef constant.
Definition: PatternMatch.h:80
static const Value * SimplifyWithOpReplaced(Value *V, Value *Op, Value *RepOp, const Query &Q, unsigned MaxRecurse)
SimplifyWithOpReplaced - See if V simplifies when its operand Op is replaced with RepOp...
Value * SimplifyCall(Value *V, User::op_iterator ArgBegin, User::op_iterator ArgEnd, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
Given a function and iterators over arguments, see if we can fold the result.
APInt LLVM_ATTRIBUTE_UNUSED_RESULT abs() const
Get the absolute value;.
Definition: APInt.h:1571
ExtractValueInst - This instruction extracts a struct member or array element value from an aggregate...
Value * SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, Instruction *CxtI=nullptr)
SimplifyICmpInst - Given operands for an ICmpInst, see if we can fold the result. ...
static Constant * computePointerICmp(const DataLayout &DL, const TargetLibraryInfo *TLI, CmpInst::Predicate Pred, Value *LHS, Value *RHS)
static Value * SimplifyAddInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, const Query &Q, unsigned MaxRecurse)
SimplifyAddInst - Given operands for an Add, see if we can fold the result.
static APInt getAllOnesValue(unsigned numBits)
Get the all-ones value.
Definition: APInt.h:453
LLVM Argument representation.
Definition: Argument.h:35
BinaryOp_match< LHS, RHS, Instruction::Sub > m_Sub(const LHS &L, const RHS &R)
Definition: PatternMatch.h:446
Value * getAggregateOperand()
static const Value * getFNegArgument(const Value *BinOp)
static Type * makeCmpResultType(Type *opnd_type)
Create a result type for fcmp/icmp.
Definition: InstrTypes.h:878
STATISTIC(NumFunctions,"Total number of functions")
ArrayRef< unsigned > getIndices() const
bool canConstantFoldCallTo(const Function *F)
canConstantFoldCallTo - Return true if its even possible to fold a call to the specified function...
static Value * SimplifyCmpInst(unsigned, Value *, Value *, const Query &, unsigned)
SimplifyCmpInst - Given operands for a CmpInst, see if we can fold the result.
static Value * SimplifyAndInst(Value *, Value *, const Query &, unsigned)
SimplifyAndInst - Given operands for an And, see if we can fold the result.
BinaryOp_match< LHS, RHS, Instruction::SRem > m_SRem(const LHS &L, const RHS &R)
Definition: PatternMatch.h:494
match_zero m_Zero()
Match an arbitrary zero/null constant.
Definition: PatternMatch.h:137
unsigned getBitWidth() const
getBitWidth - Return the bitwidth of this constant.
Definition: Constants.h:111
This class represents zero extension of integer types.
bool hasNoSignedWrap() const
Test whether this operation is known to never undergo signed overflow, aka the nsw property...
Definition: Operator.h:102
static bool isOrdered(unsigned short predicate)
Determine if the predicate is an ordered operation.
bool getObjectSize(const Value *Ptr, uint64_t &Size, const DataLayout &DL, const TargetLibraryInfo *TLI, bool RoundToAlign=false)
Compute the size of the object pointed by Ptr.
BinaryOp_match< LHS, RHS, Instruction::Mul > m_Mul(const LHS &L, const RHS &R)
Definition: PatternMatch.h:458
iterator end() const
Definition: ArrayRef.h:123
Constant * ConstantFoldExtractElementInstruction(Constant *Val, Constant *Idx)
Attempt to constant fold an extractelement instruction with the specified operands and indices...
static Value * SimplifyAssociativeBinOp(unsigned Opc, Value *LHS, Value *RHS, const Query &Q, unsigned MaxRecurse)
SimplifyAssociativeBinOp - Generic simplifications for associative binary operations.
bool isIntrinsic() const
Definition: Function.h:160
Predicate getInversePredicate() const
For example, EQ -> NE, UGT -> ULE, SLT -> SGE, OEQ -> UNE, UGT -> OLE, OLT -> UGE, etc.
Definition: InstrTypes.h:783
static Value * simplifyUnsignedRangeCheck(ICmpInst *ZeroICmp, ICmpInst *UnsignedICmp, bool IsAnd)
void computeKnownBits(Value *V, APInt &KnownZero, APInt &KnownOne, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr)
Determine which bits of V are known to be either zero or one and return them in the KnownZero/KnownOn...
static PointerType * get(Type *ElementType, unsigned AddressSpace)
PointerType::get - This constructs a pointer to an object of the specified type in a numbered address...
Definition: Type.cpp:738
unsigned less or equal
Definition: InstrTypes.h:723
unsigned less than
Definition: InstrTypes.h:722
BinaryOp_match< LHS, RHS, Instruction::AShr > m_AShr(const LHS &L, const RHS &R)
Definition: PatternMatch.h:536
Value * SimplifySDivInst(Value *LHS, Value *RHS, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
SimplifySDivInst - Given operands for an SDiv, see if we can fold the result.
static Constant * getIntToPtr(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:1822
static Constant * getGetElementPtr(Type *Ty, Constant *C, ArrayRef< Constant * > IdxList, bool InBounds=false, Type *OnlyIfReducedTy=nullptr)
Getelementptr form.
Definition: Constants.h:1092
bool isSigned() const
Determine if this instruction is using a signed comparison.
Definition: InstrTypes.h:826
A cache of .assume calls within a function.
0 1 0 0 True if ordered and less than
Definition: InstrTypes.h:703
Type * getReturnType() const
Definition: Function.cpp:233
Value * SimplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS, FastMathFlags FMF, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
SimplifyFCmpInst - Given operands for an FCmpInst, see if we can fold the result. ...
FastMathFlags getFastMathFlags() const
Convenience function for getting all the fast-math flags, which must be an operator which supports th...
const Function * getParent() const
Return the enclosing method, or null if none.
Definition: BasicBlock.h:111
F(f)
This class represents a sign extension of integer types.
bool isNoAliasCall(const Value *V)
isNoAliasCall - Return true if this pointer is returned by a noalias function.
BinaryOp_match< LHS, RHS, Instruction::FSub > m_FSub(const LHS &L, const RHS &R)
Definition: PatternMatch.h:452
LoadInst - an instruction for reading from memory.
Definition: Instructions.h:177
FunctionType * getType(LLVMContext &Context, ID id, ArrayRef< Type * > Tys=None)
Return the function type for an intrinsic.
Definition: Function.cpp:822
void GetUnderlyingObjects(Value *V, SmallVectorImpl< Value * > &Objects, const DataLayout &DL, LoopInfo *LI=nullptr, unsigned MaxLookup=6)
This method is similar to GetUnderlyingObject except that it can look through phi and select instruct...
Hexagon Common GEP
static Value * SimplifyOrOfICmps(ICmpInst *Op0, ICmpInst *Op1)
static Constant * getTrue(Type *Ty)
getTrue - For a boolean type, or a vector of boolean type, return true, or a vector with every elemen...
static Constant * getSub(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
Definition: Constants.cpp:2269
Value * SimplifyAddInst(Value *LHS, Value *RHS, bool isNSW, bool isNUW, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
SimplifyAddInst - Given operands for an Add, see if we can fold the result.
static Value * SimplifySubInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, const Query &Q, unsigned MaxRecurse)
SimplifySubInst - Given operands for a Sub, see if we can fold the result.
void reserve(size_type N)
Definition: SmallVector.h:401
static Value * SimplifyLShrInst(Value *Op0, Value *Op1, bool isExact, const Query &Q, unsigned MaxRecurse)
SimplifyLShrInst - Given operands for an LShr, see if we can fold the result.
size_type size() const
Determine the number of elements in the SetVector.
Definition: SetVector.h:64
static Value * SimplifyXorInst(Value *, Value *, const Query &, unsigned)
SimplifyXorInst - Given operands for a Xor, see if we can fold the result.
op_iterator op_begin()
Definition: User.h:183
static APInt getSignedMaxValue(unsigned numBits)
Gets maximum signed value of APInt for a specific bit width.
Definition: APInt.h:426
static Value * SimplifyExtractValueInst(Value *Agg, ArrayRef< unsigned > Idxs, const Query &, unsigned)
SimplifyExtractValueInst - Given operands for an ExtractValueInst, see if we can fold the result...
static Constant * getNullValue(Type *Ty)
Definition: Constants.cpp:178
static Constant * getAdd(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
Definition: Constants.cpp:2258
bool isNegative() const
Determine sign of this APInt.
Definition: APInt.h:319
static Value * ThreadCmpOverPHI(CmpInst::Predicate Pred, Value *LHS, Value *RHS, const Query &Q, unsigned MaxRecurse)
ThreadCmpOverPHI - In the case of a comparison with a PHI instruction, try try to simplify the compar...
IterTy arg_end() const
Definition: CallSite.h:157
bool match(Val *V, const Pattern &P)
Definition: PatternMatch.h:41
static Value * SimplifySDivInst(Value *Op0, Value *Op1, const Query &Q, unsigned MaxRecurse)
SimplifySDivInst - Given operands for an SDiv, see if we can fold the result.
1 0 0 0 True if unordered: isnan(X) | isnan(Y)
Definition: InstrTypes.h:707
bool hasNoNaNs() const
Determine whether the no-NaNs flag is set.
static Constant * getIntegerCast(Constant *C, Type *Ty, bool isSigned)
Create a ZExt, Bitcast or Trunc for integer -> integer casts.
Definition: Constants.cpp:1674
SelectInst - This class represents the LLVM 'select' instruction.
bool noSignedZeros() const
Definition: Operator.h:191
const APInt & getValue() const
Return the constant as an APInt value reference.
Definition: Constants.h:106
static Value * SimplifyFDivInst(Value *Op0, Value *Op1, FastMathFlags FMF, const Query &Q, unsigned)
Exact_match< T > m_Exact(const T &SubPattern)
Definition: PatternMatch.h:691
BinOp2_match< LHS, RHS, Instruction::LShr, Instruction::AShr > m_Shr(const LHS &L, const RHS &R)
Matches LShr or AShr.
Definition: PatternMatch.h:658
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:98
A Use represents the edge between a Value definition and its users.
Definition: Use.h:69
Value * SimplifyFSubInst(Value *LHS, Value *RHS, FastMathFlags FMF, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
Given operands for an FSub, see if we can fold the result.
APInt LLVM_ATTRIBUTE_UNUSED_RESULT lshr(unsigned shiftAmt) const
Logical right-shift function.
Definition: APInt.cpp:1142
Constant * ConstantFoldLoadFromConstPtr(Constant *C, const DataLayout &DL)
ConstantFoldLoadFromConstPtr - Return the value that a load from C would produce if it is constant an...
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APInt.h:33
CastClass_match< OpTy, Instruction::Trunc > m_Trunc(const OpTy &Op)
Matches Trunc.
Definition: PatternMatch.h:801
Value * SimplifyFAddInst(Value *LHS, Value *RHS, FastMathFlags FMF, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
Given operands for an FAdd, see if we can fold the result.
bool isSized(SmallPtrSetImpl< const Type * > *Visited=nullptr) const
isSized - Return true if it makes sense to take the size of this type.
Definition: Type.h:268
bool MaskedValueIsZero(Value *V, const APInt &Mask, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr)
MaskedValueIsZero - Return true if 'V & Mask' is known to be zero.
Number of individual test Apply this number of consecutive mutations to each input exit after the first new interesting input is found the minimized corpus is saved into the first input directory Number of jobs to run If min(jobs, NumberOfCpuCores()/2)\" is used.") FUZZER_FLAG_INT(reload
static Value * SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS, const Query &Q, unsigned MaxRecurse)
SimplifyICmpInst - Given operands for an ICmpInst, see if we can fold the result. ...
static ConstantInt * ExtractElement(Constant *V, Constant *Idx)
Type * getVectorElementType() const
Definition: Type.h:364
static Value * SimplifyAShrInst(Value *Op0, Value *Op1, bool isExact, const Query &Q, unsigned MaxRecurse)
SimplifyAShrInst - Given operands for an AShr, see if we can fold the result.
not_match< LHS > m_Not(const LHS &L)
Definition: PatternMatch.h:854
bool isNegative() const
Definition: Constants.h:156
BinaryOp_match< LHS, RHS, Instruction::Add > m_Add(const LHS &L, const RHS &R)
Definition: PatternMatch.h:434
This class represents a cast from a pointer to an integer.
static Value * SimplifyFAddInst(Value *Op0, Value *Op1, FastMathFlags FMF, const Query &Q, unsigned MaxRecurse)
Given operands for an FAdd, see if we can fold the result.
FunctionType - Class to represent function types.
Definition: DerivedTypes.h:96
bool insert(const value_type &X)
Insert a new element into the SetVector.
Definition: SetVector.h:102
match_combine_or< LTy, RTy > m_CombineOr(const LTy &L, const RTy &R)
Combine two pattern matchers matching L || R.
Definition: PatternMatch.h:117
ValTy * getCalledValue() const
getCalledValue - Return the pointer to function that is being called.
Definition: CallSite.h:91
bool contains(const APInt &Val) const
Return true if the specified value is in the set.
static Value * ExtractEquivalentCondition(Value *V, CmpInst::Predicate Pred, Value *LHS, Value *RHS)
ExtractEquivalentCondition - Rummage around inside V looking for something equivalent to the comparis...
bool isAssociative() const
isAssociative - Return true if the instruction is associative:
static Value * SimplifyPHINode(PHINode *PN, const Query &Q)
SimplifyPHINode - See if we can fold the given phi. If not, returns null.
CastClass_match< OpTy, Instruction::ZExt > m_ZExt(const OpTy &Op)
Matches ZExt.
Definition: PatternMatch.h:813
ArrayRef< T > slice(unsigned N) const
slice(n) - Chop off the first N elements of the array.
Definition: ArrayRef.h:165
bool isReachableFromEntry(const Use &U) const
Provide an overload for a Use.
Definition: Dominators.cpp:265
bool isKnownToBeAPowerOfTwo(Value *V, const DataLayout &DL, bool OrZero=false, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr)
isKnownToBeAPowerOfTwo - Return true if the given value is known to have exactly one bit set when def...
bool sgt(const APInt &RHS) const
Signed greather than comparison.
Definition: APInt.h:1119
MaxMin_match< ICmpInst, LHS, RHS, smin_pred_ty > m_SMin(const LHS &L, const RHS &R)
static Value * SimplifyTruncInst(Value *, Type *, const Query &, unsigned)
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory)...
Definition: ArrayRef.h:31
Value * getInsertedValueOperand()
class_match< ConstantInt > m_ConstantInt()
Match an arbitrary ConstantInt and ignore it.
Definition: PatternMatch.h:75
Value * SimplifyFMulInst(Value *LHS, Value *RHS, FastMathFlags FMF, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
Given operands for an FMul, see if we can fold the result.
Predicate getUnsignedPredicate() const
For example, EQ->EQ, SLE->ULE, UGT->UGT, etc.
Constant * ConstantFoldInsertValueInstruction(Constant *Agg, Constant *Val, ArrayRef< unsigned > Idxs)
ConstantFoldInsertValueInstruction - Attempt to constant fold an insertvalue instruction with the spe...
APInt LLVM_ATTRIBUTE_UNUSED_RESULT shl(unsigned shiftAmt) const
Left-shift function.
Definition: APInt.h:868
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
Definition: Value.cpp:351
static Value * ThreadBinOpOverSelect(unsigned Opcode, Value *LHS, Value *RHS, const Query &Q, unsigned MaxRecurse)
ThreadBinOpOverSelect - In the case of a binary operation with a select instruction as an operand...
static Value * SimplifyFSubInst(Value *Op0, Value *Op1, FastMathFlags FMF, const Query &Q, unsigned MaxRecurse)
Given operands for an FSub, see if we can fold the result.
APInt umul_ov(const APInt &RHS, bool &Overflow) const
Definition: APInt.cpp:2047
bool noInfs() const
Definition: Operator.h:190
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree...
Definition: Dominators.h:67
static Value * SimplifyOrInst(Value *, Value *, const Query &, unsigned)
SimplifyOrInst - Given operands for an Or, see if we can fold the result.
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:134
static Value * SimplifyURemInst(Value *Op0, Value *Op1, const Query &Q, unsigned MaxRecurse)
SimplifyURemInst - Given operands for a URem, see if we can fold the result.
PointerType - Class to represent pointers.
Definition: DerivedTypes.h:449
bool ult(const APInt &RHS) const
Unsigned less than comparison.
Definition: APInt.cpp:520
Value * findScalarElement(Value *V, unsigned EltNo)
Given a vector and an element number, see if the scalar value is already around as a register...
Value * SimplifyOrInst(Value *LHS, Value *RHS, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
SimplifyOrInst - Given operands for an Or, see if we can fold the result.
GetElementPtrInst - an instruction for type-safe pointer arithmetic to access elements of arrays and ...
Definition: Instructions.h:830
#define P(N)
BinaryOp_match< LHS, RHS, Instruction::LShr > m_LShr(const LHS &L, const RHS &R)
Definition: PatternMatch.h:530
MaxMin_match< ICmpInst, LHS, RHS, umax_pred_ty > m_UMax(const LHS &L, const RHS &R)
apint_match m_APInt(const APInt *&Res)
Match a ConstantInt or splatted ConstantVector, binding the specified pointer to the contained APInt...
Definition: PatternMatch.h:180
BinaryOp_match< LHS, RHS, Instruction::SDiv > m_SDiv(const LHS &L, const RHS &R)
Definition: PatternMatch.h:476
OverflowingBinaryOp_match< LHS, RHS, Instruction::Shl, OverflowingBinaryOperator::NoUnsignedWrap > m_NUWShl(const LHS &L, const RHS &R)
Definition: PatternMatch.h:626
static Value * SimplifySelectInst(Value *CondVal, Value *TrueVal, Value *FalseVal, const Query &Q, unsigned MaxRecurse)
SimplifySelectInst - Given operands for a SelectInst, see if we can fold the result.
bool isFullSet() const
Return true if this set contains all of the elements possible for this data-type. ...
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
BinaryOp_match< LHS, RHS, Instruction::Or > m_Or(const LHS &L, const RHS &R)
Definition: PatternMatch.h:512
bool isVectorTy() const
isVectorTy - True if this is an instance of VectorType.
Definition: Type.h:226
bool isEquality() const
isEquality - Return true if this predicate is either EQ or NE.
static Constant * stripAndComputeConstantOffsets(const DataLayout &DL, Value *&V, bool AllowNonInbounds=false)
Compute the base pointer and cumulative constant offsets for V.
This is an important base class in LLVM.
Definition: Constant.h:41
static Value * SimplifyCall(Value *V, IterTy ArgBegin, IterTy ArgEnd, const Query &Q, unsigned MaxRecurse)
bool isMaxSignedValue() const
Determine if this is the largest signed value.
Definition: APInt.h:353
const Value * getCondition() const
static Value * ThreadCmpOverSelect(CmpInst::Predicate Pred, Value *LHS, Value *RHS, const Query &Q, unsigned MaxRecurse)
ThreadCmpOverSelect - In the case of a comparison with a select instruction, try to simplify the comp...
static Value * SimplifySRemInst(Value *Op0, Value *Op1, const Query &Q, unsigned MaxRecurse)
SimplifySRemInst - Given operands for an SRem, see if we can fold the result.
static Value * SimplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS, FastMathFlags FMF, const Query &Q, unsigned MaxRecurse)
SimplifyFCmpInst - Given operands for an FCmpInst, see if we can fold the result. ...
APInt Or(const APInt &LHS, const APInt &RHS)
Bitwise OR function for APInt.
Definition: APInt.h:1895
static Value * SimplifyFMulInst(Value *Op0, Value *Op1, FastMathFlags FMF, const Query &Q, unsigned MaxRecurse)
Given the operands for an FMul, see if we can fold the result.
ConstantFP - Floating Point Values [float, double].
Definition: Constants.h:233
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
Definition: SmallPtrSet.h:264
APInt Xor(const APInt &LHS, const APInt &RHS)
Bitwise XOR function for APInt.
Definition: APInt.h:1900
static Value * SimplifyDiv(Instruction::BinaryOps Opcode, Value *Op0, Value *Op1, const Query &Q, unsigned MaxRecurse)
SimplifyDiv - Given operands for an SDiv or UDiv, see if we can fold the result.
Constant * ConstantFoldInstruction(Instruction *I, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr)
ConstantFoldInstruction - Try to constant fold the specified instruction.
cst_pred_ty< is_all_ones > m_AllOnes()
Match an integer or vector with all bits set to true.
Definition: PatternMatch.h:252
bool isIntPredicate() const
Definition: InstrTypes.h:776
Value * SimplifyShlInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
SimplifyShlInst - Given operands for a Shl, see if we can fold the result.
specificval_ty m_Specific(const Value *V)
Match if we have a specific specified value.
Definition: PatternMatch.h:322
op_iterator op_end()
Definition: User.h:185
BinaryOp_match< LHS, RHS, Instruction::Shl > m_Shl(const LHS &L, const RHS &R)
Definition: PatternMatch.h:524
bool isFalseWhenEqual() const
This is just a convenience.
Definition: InstrTypes.h:844
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang","erlang-compatible garbage collector")
This instruction compares its operands according to the predicate given to the constructor.
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:697
Utility class for integer arithmetic operators which may exhibit overflow - Add, Sub, and Mul.
Definition: Operator.h:74
iterator begin() const
Definition: ArrayRef.h:122
bool isMaxValue() const
Determine if this is the largest unsigned value.
Definition: APInt.h:347
APInt LLVM_ATTRIBUTE_UNUSED_RESULT sdiv(const APInt &RHS) const
Signed division function for APInt.
Definition: APInt.cpp:1876
Value * getOperand(unsigned i) const
Definition: User.h:118
0 1 1 1 True if ordered (no nans)
Definition: InstrTypes.h:706
Value * SimplifyFPBinOp(unsigned Opcode, Value *LHS, Value *RHS, const FastMathFlags &FMF, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
SimplifyFPBinOp - Given operands for a BinaryOperator, see if we can fold the result.
bool isCommutative() const
isCommutative - Return true if the instruction is commutative:
Definition: Instruction.h:327
static Constant * getICmp(unsigned short pred, Constant *LHS, Constant *RHS, bool OnlyIfReduced=false)
get* - Return some common constants without having to specify the full Instruction::OPCODE identifier...
Definition: Constants.cpp:2074
Predicate getPredicate() const
Return the predicate for this instruction.
Definition: InstrTypes.h:760
static bool ValueDominatesPHI(Value *V, PHINode *P, const DominatorTree *DT)
ValueDominatesPHI - Does the given value dominate the specified phi node?
void ComputeSignBit(Value *V, bool &KnownZero, bool &KnownOne, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr)
ComputeSignBit - Determine whether the sign bit is known to be zero or one.
Constant * getAggregateElement(unsigned Elt) const
getAggregateElement - For aggregates (struct/array/vector) return the constant that corresponds to th...
Definition: Constants.cpp:250
Value * SimplifySRemInst(Value *LHS, Value *RHS, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
SimplifySRemInst - Given operands for an SRem, see if we can fold the result.
static Constant * getAllOnesValue(Type *Ty)
Get the all ones value.
Definition: Constants.cpp:230
1 1 1 1 Always true (always folded)
Definition: InstrTypes.h:714
static Value * SimplifyInsertValueInst(Value *Agg, Value *Val, ArrayRef< unsigned > Idxs, const Query &Q, unsigned)
SimplifyInsertValueInst - Given operands for an InsertValueInst, see if we can fold the result...
match_combine_or< match_zero, match_neg_zero > m_AnyZero()
Match an arbitrary zero/null constant.
Definition: PatternMatch.h:156
bool isEmptySet() const
Return true if this set contains no members.
bool isPointerTy() const
isPointerTy - True if this is an instance of PointerType.
Definition: Type.h:217
Value * SimplifySelectInst(Value *Cond, Value *TrueVal, Value *FalseVal, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
SimplifySelectInst - Given operands for a SelectInst, see if we can fold the result.
static UndefValue * get(Type *T)
get() - Static factory methods - Return an 'undef' object of the specified type.
Definition: Constants.cpp:1473
static Value * SimplifyAndOfICmps(ICmpInst *Op0, ICmpInst *Op1)
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:519
bool hasNoSignedWrap() const
Determine whether the no signed wrap flag is set.
const Value * getTrueValue() const
Constant * ConstantFoldCompareInstOperands(unsigned Predicate, Constant *LHS, Constant *RHS, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr)
ConstantFoldCompareInstOperands - Attempt to constant fold a compare instruction (icmp/fcmp) with the...
bool isPowerOf2() const
Check if this APInt's value is a power of two greater than zero.
Definition: APInt.h:386
1 1 0 1 True if unordered, less than, or equal
Definition: InstrTypes.h:712
signed greater than
Definition: InstrTypes.h:724
static Value * ExpandBinOp(unsigned Opcode, Value *LHS, Value *RHS, unsigned OpcToExpand, const Query &Q, unsigned MaxRecurse)
ExpandBinOp - Simplify "A op (B op' C)" by distributing op over op', turning it into "(A op B) op'...
bool recursivelySimplifyInstruction(Instruction *I, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr)
Recursively attempt to simplify an instruction.
neg_match< LHS > m_Neg(const LHS &L)
Match an integer negate.
Definition: PatternMatch.h:877
bool dominates(const Instruction *Def, const Use &U) const
Return true if Def dominates a use in User.
Definition: Dominators.cpp:214
static Value * SimplifyIntrinsic(Function *F, IterTy ArgBegin, IterTy ArgEnd, const Query &Q, unsigned MaxRecurse)
unsigned countTrailingZeros() const
Count the number of trailing zero bits.
Definition: APInt.cpp:749
IntegerType * getIntPtrType(LLVMContext &C, unsigned AddressSpace=0) const
Returns an integer type with size at least as big as that of a pointer in the given address space...
Definition: DataLayout.cpp:694
static Value * SimplifyUDivInst(Value *Op0, Value *Op1, const Query &Q, unsigned MaxRecurse)
SimplifyUDivInst - Given operands for a UDiv, see if we can fold the result.
0 0 1 0 True if ordered and greater than
Definition: InstrTypes.h:701
BinaryOps getOpcode() const
Definition: InstrTypes.h:323
static Constant * getSplat(unsigned NumElts, Constant *Elt)
getSplat - Return a ConstantVector with the specified constant in each element.
Definition: Constants.cpp:1162
A SetVector that performs no allocations if smaller than a certain size.
Definition: SetVector.h:217
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements...
Definition: SmallPtrSet.h:299
static Value * SimplifyRem(Instruction::BinaryOps Opcode, Value *Op0, Value *Op1, const Query &Q, unsigned MaxRecurse)
SimplifyRem - Given operands for an SRem or URem, see if we can fold the result.
This is the shared class of boolean and integer constants.
Definition: Constants.h:47
static Value * SimplifyShlInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, const Query &Q, unsigned MaxRecurse)
SimplifyShlInst - Given operands for an Shl, see if we can fold the result.
unsigned getVectorNumElements() const
Definition: Type.cpp:212
unsigned getScalarSizeInBits() const LLVM_READONLY
getScalarSizeInBits - If this is a vector type, return the getPrimitiveSizeInBits value for the eleme...
Definition: Type.cpp:139
const Module * getModule() const
Return the module owning the function this instruction belongs to or nullptr it the function does not...
Definition: Instruction.cpp:57
ConstantRange inverse() const
Return a new range that is the logical not of the current set.
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:861
Constant * ConstantFoldInstOperands(unsigned Opcode, Type *DestTy, ArrayRef< Constant * > Ops, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr)
ConstantFoldInstOperands - Attempt to constant fold an instruction with the specified operands...
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:222
Provides information about what library functions are available for the current target.
BinaryOp_match< LHS, RHS, Instruction::URem > m_URem(const LHS &L, const RHS &R)
Definition: PatternMatch.h:488
This class represents a range of values.
Definition: ConstantRange.h:43
Value * SimplifyCmpInst(unsigned Predicate, Value *LHS, Value *RHS, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
SimplifyCmpInst - Given operands for a CmpInst, see if we can fold the result.
unsigned ComputeNumSignBits(Value *Op, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr)
ComputeNumSignBits - Return the number of times the sign bit of the register is replicated into the o...
BinaryOp_match< LHS, RHS, Instruction::UDiv > m_UDiv(const LHS &L, const RHS &R)
Definition: PatternMatch.h:470
signed less than
Definition: InstrTypes.h:726
bool isTrueWhenEqual() const
This is just a convenience.
Definition: InstrTypes.h:838
Value * SimplifyGEPInst(ArrayRef< Value * > Ops, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
SimplifyGEPInst - Given operands for an GetElementPtrInst, see if we can fold the result...
Value * stripPointerCasts()
Strip off pointer casts, all-zero GEPs, and aliases.
Definition: Value.cpp:458
Predicate getSwappedPredicate() const
For example, EQ->EQ, SLE->SGE, ULT->UGT, OEQ->OEQ, ULE->UGE, OLT->OGT, etc.
Definition: InstrTypes.h:799
static Constant * getTrunc(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:1699
static Constant * get(Type *Ty, uint64_t V, bool isSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
Definition: Constants.cpp:582
bool isZero() const
This is just a convenience method to make client code smaller for a common code.
Definition: Constants.h:161
Value * SimplifyInsertValueInst(Value *Agg, Value *Val, ArrayRef< unsigned > Idxs, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
SimplifyInsertValueInst - Given operands for an InsertValueInst, see if we can fold the result...
static Value * SimplifyShift(unsigned Opcode, Value *Op0, Value *Op1, const Query &Q, unsigned MaxRecurse)
SimplifyShift - Given operands for an Shl, LShr or AShr, see if we can fold the result.
const BasicBlock & getEntryBlock() const
Definition: Function.h:442
static Constant * get(Type *Ty, double V)
get() - This returns a ConstantFP, or a vector containing a splat of a ConstantFP, for the specified value in the specified type.
Definition: Constants.cpp:652
bool isNullValue() const
isNullValue - Return true if this is the value that would be returned by getNullValue.
Definition: Constants.cpp:75
bool isExact() const
Determine whether the exact flag is set.
static ConstantInt * getTrue(LLVMContext &Context)
Definition: Constants.cpp:530
Intrinsic::ID getIntrinsicID() const LLVM_READONLY
getIntrinsicID - This method returns the ID number of the specified function, or Intrinsic::not_intri...
Definition: Function.h:159
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
Definition: BitVector.h:576
signed less or equal
Definition: InstrTypes.h:727
VectorType - Class to represent vector types.
Definition: DerivedTypes.h:362
Value * SimplifyExtractElementInst(Value *Vec, Value *Idx, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
Given operands for an ExtractElementInst, see if we can fold the result.
Class for arbitrary precision integers.
Definition: APInt.h:73
static Constant * getFalse(Type *Ty)
getFalse - For a boolean type, or a vector of boolean type, return false, or a vector with every elem...
static Value * SimplifyFRemInst(Value *Op0, Value *Op1, FastMathFlags FMF, const Query &, unsigned)
bool isIntegerTy() const
isIntegerTy - True if this is an instance of IntegerType.
Definition: Type.h:193
CastClass_match< OpTy, Instruction::PtrToInt > m_PtrToInt(const OpTy &Op)
Matches PtrToInt.
Definition: PatternMatch.h:795
iterator_range< user_iterator > users()
Definition: Value.h:300
Value * SimplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
SimplifyBinOp - Given operands for a BinaryOperator, see if we can fold the result.
static Constant * getCast(unsigned ops, Constant *C, Type *Ty, bool OnlyIfReduced=false)
Convenience function for getting a Cast operation.
Definition: Constants.cpp:1591
LLVM_ATTRIBUTE_UNUSED_RESULT std::enable_if< !is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:285
Value * SimplifySubInst(Value *LHS, Value *RHS, bool isNSW, bool isNUW, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
SimplifySubInst - Given operands for a Sub, see if we can fold the result.
bool isMinValue() const
Determine if this is the smallest unsigned value.
Definition: APInt.h:361
bool isKnownNonNull(const Value *V, const TargetLibraryInfo *TLI=nullptr)
isKnownNonNull - Return true if this pointer couldn't possibly be null by its definition.
const Type * getScalarType() const LLVM_READONLY
getScalarType - If this is a vector type, return the element type, otherwise return 'this'...
Definition: Type.cpp:51
bool isFPPredicate() const
Definition: InstrTypes.h:775
APInt And(const APInt &LHS, const APInt &RHS)
Bitwise AND function for APInt.
Definition: APInt.h:1890
Value * SimplifyTruncInst(Value *Op, Type *Ty, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
SimplifyTruncInst - Given operands for an TruncInst, see if we can fold the result.
unsigned getOpcode() const
Return the opcode for this Instruction or ConstantExpr.
Definition: Operator.h:48
static Type * getIndexedType(Type *Ty, ArrayRef< Value * > IdxList)
getIndexedType - Returns the type of the element that would be loaded with a load instruction with th...
bool isKnownNonZero(Value *V, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr)
isKnownNonZero - Return true if the given value is known to be non-zero when defined.
specific_fpval m_FPOne()
Match a float 1.0 or vector with all elements equal to 1.0.
Definition: PatternMatch.h:346
bool isAllOnesValue() const
Determine if all bits are set.
Definition: APInt.h:337
unsigned countLeadingOnes() const
Count the number of leading one bits.
Definition: APInt.cpp:722
bool CannotBeOrderedLessThanZero(const Value *V, unsigned Depth=0)
CannotBeOrderedLessThanZero - Return true if we can prove that the specified FP value is either a NaN...
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.cpp:372
static Constant * computePointerDifference(const DataLayout &DL, Value *LHS, Value *RHS)
Compute the constant difference between two pointer values.
bool isMinSignedValue() const
Determine if this is the smallest signed value.
Definition: APInt.h:367
Value * SimplifyAndInst(Value *LHS, Value *RHS, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
SimplifyAndInst - Given operands for an And, see if we can fold the result.
APInt LLVM_ATTRIBUTE_UNUSED_RESULT udiv(const APInt &RHS) const
Unsigned division operation.
Definition: APInt.cpp:1839
static Value * SimplifyGEPInst(Type *SrcTy, ArrayRef< Value * > Ops, const Query &Q, unsigned)
SimplifyGEPInst - Given operands for an GetElementPtrInst, see if we can fold the result...
static Value * SimplifyFPBinOp(unsigned, Value *, Value *, const FastMathFlags &, const Query &, unsigned)
SimplifyFPBinOp - Given operands for a BinaryOperator, see if we can fold the result.
unsigned greater or equal
Definition: InstrTypes.h:721
static bool replaceAndRecursivelySimplifyImpl(Instruction *I, Value *SimpleV, const TargetLibraryInfo *TLI, const DominatorTree *DT, AssumptionCache *AC)
Implementation of recursive simplification through an instructions uses.
static bool isFNeg(const Value *V, bool IgnoreZeroSign=false)
#define I(x, y, z)
Definition: MD5.cpp:54
OverflowingBinaryOp_match< LHS, RHS, Instruction::Shl, OverflowingBinaryOperator::NoSignedWrap > m_NSWShl(const LHS &L, const RHS &R)
Definition: PatternMatch.h:593
bool hasNoInfs() const
Determine whether the no-infs flag is set.
MaxMin_match< ICmpInst, LHS, RHS, smax_pred_ty > m_SMax(const LHS &L, const RHS &R)
bool isSignBit() const
Check if the APInt's value is returned by getSignBit.
Definition: APInt.h:395
Value * SimplifyURemInst(Value *LHS, Value *RHS, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
SimplifyURemInst - Given operands for a URem, see if we can fold the result.
static Value * SimplifyMulInst(Value *Op0, Value *Op1, const Query &Q, unsigned MaxRecurse)
SimplifyMulInst - Given operands for a Mul, see if we can fold the result.
static ConstantRange makeConstantRange(Predicate pred, const APInt &C)
Initialize a set of values that all satisfy the predicate with C.
static bool IsIdempotent(Intrinsic::ID ID)
Value * SimplifyMulInst(Value *LHS, Value *RHS, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
SimplifyMulInst - Given operands for a Mul, see if we can fold the result.
Value * SimplifyExtractValueInst(Value *Agg, ArrayRef< unsigned > Idxs, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
Given operands for an ExtractValueInst, see if we can fold the result.
static Value * SimplifyExtractElementInst(Value *Vec, Value *Idx, const Query &, unsigned)
SimplifyExtractElementInst - Given operands for an ExtractElementInst, see if we can fold the result...
Value * SimplifyLShrInst(Value *Op0, Value *Op1, bool isExact, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
SimplifyLShrInst - Given operands for a LShr, see if we can fold the result.
bool all_of(R &&Range, UnaryPredicate &&P)
Provide wrappers to std::all_of which take ranges instead of having to pass being/end explicitly...
Definition: STLExtras.h:334
Value * SimplifyUDivInst(Value *LHS, Value *RHS, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
SimplifyUDivInst - Given operands for a UDiv, see if we can fold the result.
BinOp2_match< LHS, RHS, Instruction::SDiv, Instruction::UDiv > m_IDiv(const LHS &L, const RHS &R)
Matches UDiv and SDiv.
Definition: PatternMatch.h:672
bool CannotBeNegativeZero(const Value *V, unsigned Depth=0)
CannotBeNegativeZero - Return true if we can prove that the specified FP value is never equal to -0...
bool isUnsigned() const
Determine if this instruction is using an unsigned comparison.
Definition: InstrTypes.h:832
Value * SimplifyXorInst(Value *LHS, Value *RHS, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
SimplifyXorInst - Given operands for a Xor, see if we can fold the result.
match_neg_zero m_NegZero()
Match an arbitrary zero/null constant.
Definition: PatternMatch.h:151
Type * getReturnType() const
Definition: DerivedTypes.h:121
Value * SimplifyFRemInst(Value *LHS, Value *RHS, FastMathFlags FMF, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
SimplifyFRemInst - Given operands for an FRem, see if we can fold the result.
static APInt getSignedMinValue(unsigned numBits)
Gets minimum signed value of APInt for a specific bit width.
Definition: APInt.h:436
unsigned getPrimitiveSizeInBits() const LLVM_READONLY
getPrimitiveSizeInBits - Return the basic size of this type if it is a primitive type.
Definition: Type.cpp:121
LLVM Value Representation.
Definition: Value.h:69
Value * SimplifyAShrInst(Value *Op0, Value *Op1, bool isExact, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
SimplifyAShrInst - Given operands for a AShr, see if we can fold the result.
bool hasNoUnsignedWrap() const
Determine whether the no unsigned wrap flag is set.
1 0 1 1 True if unordered, greater than, or equal
Definition: InstrTypes.h:710
unsigned getOpcode() const
getOpcode() returns a member of one of the enums like Instruction::Add.
Definition: Instruction.h:112
cst_pred_ty< is_one > m_One()
Match an integer 1 or a vector with all elements equal to 1.
Definition: PatternMatch.h:244
static VectorType * get(Type *ElementType, unsigned NumElements)
VectorType::get - This static method is the primary way to construct an VectorType.
Definition: Type.cpp:713
static Value * SimplifyRightShift(unsigned Opcode, Value *Op0, Value *Op1, bool isExact, const Query &Q, unsigned MaxRecurse)
Given operands for an Shl, LShr or AShr, see if we can fold the result.
static bool isUnordered(unsigned short predicate)
Determine if the predicate is an unordered operation.
static Value * ThreadBinOpOverPHI(unsigned Opcode, Value *LHS, Value *RHS, const Query &Q, unsigned MaxRecurse)
ThreadBinOpOverPHI - In the case of a binary operation with an operand that is a PHI instruction...
unsigned countLeadingZeros() const
The APInt version of the countLeadingZeros functions in MathExtras.h.
Definition: APInt.h:1361
IterTy arg_begin() const
arg_begin/arg_end - Return iterators corresponding to the actual argument list for a call site...
Definition: CallSite.h:151
Predicate getSignedPredicate() const
For example, EQ->EQ, SLE->SLE, UGT->SGT, etc.
const Value * getFalseValue() const
Convenience struct for specifying and reasoning about fast-math flags.
Definition: Operator.h:164
unsigned greater than
Definition: InstrTypes.h:720
static bool isUndefShift(Value *Amount)
isUndefShift - Returns true if a shift by Amount always yields undef.
Constant * ConstantFoldExtractValueInstruction(Constant *Agg, ArrayRef< unsigned > Idxs)
Attempt to constant fold an extractvalue instruction with the specified operands and indices...
Value * SimplifyInstruction(Instruction *I, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr)
SimplifyInstruction - See if we can compute a simplified version of this instruction.
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml","ocaml 3.10-compatible collector")
static APInt getNullValue(unsigned numBits)
Get the '0' value.
Definition: APInt.h:460
specific_intval m_SpecificInt(uint64_t V)
Match a specific integer value or vector with all elements equal to the value.
Definition: PatternMatch.h:383
static bool isSameCompare(Value *V, CmpInst::Predicate Pred, Value *LHS, Value *RHS)
isSameCompare - Is V equivalent to the comparison "LHS Pred RHS"?
bool replaceAndRecursivelySimplify(Instruction *I, Value *SimpleV, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr)
Replace all uses of 'I' with 'SimpleV' and simplify the uses recursively.
op_range incoming_values()
const BasicBlock * getParent() const
Definition: Instruction.h:72
static Type * GetCompareTy(Value *Op)
bool hasNoUnsignedWrap() const
Test whether this operation is known to never undergo unsigned overflow, aka the nuw property...
Definition: Operator.h:96
0 0 0 0 Always false (always folded)
Definition: InstrTypes.h:699
signed greater or equal
Definition: InstrTypes.h:725
bool noNaNs() const
Flag queries.
Definition: Operator.h:189
IntrinsicInst - A useful wrapper class for inspecting calls to intrinsic functions.
Definition: IntrinsicInst.h:37
Constant * ConstantFoldCall(Function *F, ArrayRef< Constant * > Operands, const TargetLibraryInfo *TLI=nullptr)
ConstantFoldCall - Attempt to constant fold a call to the specified function with the specified argum...
bool isMinSignedValue() const
Return true if the value is the smallest signed value.
Definition: Constants.cpp:132
Value * SimplifyFDivInst(Value *LHS, Value *RHS, FastMathFlags FMF, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
SimplifyFDivInst - Given operands for an FDiv, see if we can fold the result.
AllocaInst - an instruction to allocate memory on the stack.
Definition: Instructions.h:76
InsertValueInst - This instruction inserts a struct field of array element value into an aggregate va...
CmpClass_match< LHS, RHS, ICmpInst, ICmpInst::Predicate > m_ICmp(ICmpInst::Predicate &Pred, const LHS &L, const RHS &R)
Definition: PatternMatch.h:726