LLVM  4.0.0
ValueTracking.cpp
Go to the documentation of this file.
1 //===- ValueTracking.cpp - Walk computations to compute properties --------===//
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 contains routines that help analyze properties that chains of
11 // computations have.
12 //
13 //===----------------------------------------------------------------------===//
14 
16 #include "llvm/ADT/Optional.h"
17 #include "llvm/ADT/SmallPtrSet.h"
21 #include "llvm/Analysis/Loads.h"
22 #include "llvm/Analysis/LoopInfo.h"
24 #include "llvm/IR/CallSite.h"
25 #include "llvm/IR/ConstantRange.h"
26 #include "llvm/IR/Constants.h"
27 #include "llvm/IR/DataLayout.h"
28 #include "llvm/IR/Dominators.h"
30 #include "llvm/IR/GlobalAlias.h"
31 #include "llvm/IR/GlobalVariable.h"
32 #include "llvm/IR/Instructions.h"
33 #include "llvm/IR/IntrinsicInst.h"
34 #include "llvm/IR/LLVMContext.h"
35 #include "llvm/IR/Metadata.h"
36 #include "llvm/IR/Operator.h"
37 #include "llvm/IR/PatternMatch.h"
38 #include "llvm/IR/Statepoint.h"
39 #include "llvm/Support/Debug.h"
41 #include <algorithm>
42 #include <array>
43 #include <cstring>
44 using namespace llvm;
45 using namespace llvm::PatternMatch;
46 
47 const unsigned MaxDepth = 6;
48 
49 // Controls the number of uses of the value searched for possible
50 // dominating comparisons.
51 static cl::opt<unsigned> DomConditionsMaxUses("dom-conditions-max-uses",
52  cl::Hidden, cl::init(20));
53 
54 // This optimization is known to cause performance regressions is some cases,
55 // keep it under a temporary flag for now.
56 static cl::opt<bool>
57 DontImproveNonNegativePhiBits("dont-improve-non-negative-phi-bits",
58  cl::Hidden, cl::init(true));
59 
60 /// Returns the bitwidth of the given scalar or pointer type (if unknown returns
61 /// 0). For vector types, returns the element type's bitwidth.
62 static unsigned getBitWidth(Type *Ty, const DataLayout &DL) {
63  if (unsigned BitWidth = Ty->getScalarSizeInBits())
64  return BitWidth;
65 
66  return DL.getPointerTypeSizeInBits(Ty);
67 }
68 
69 namespace {
70 // Simplifying using an assume can only be done in a particular control-flow
71 // context (the context instruction provides that context). If an assume and
72 // the context instruction are not in the same block then the DT helps in
73 // figuring out if we can use it.
74 struct Query {
75  const DataLayout &DL;
76  AssumptionCache *AC;
77  const Instruction *CxtI;
78  const DominatorTree *DT;
79 
80  /// Set of assumptions that should be excluded from further queries.
81  /// This is because of the potential for mutual recursion to cause
82  /// computeKnownBits to repeatedly visit the same assume intrinsic. The
83  /// classic case of this is assume(x = y), which will attempt to determine
84  /// bits in x from bits in y, which will attempt to determine bits in y from
85  /// bits in x, etc. Regarding the mutual recursion, computeKnownBits can call
86  /// isKnownNonZero, which calls computeKnownBits and ComputeSignBit and
87  /// isKnownToBeAPowerOfTwo (all of which can call computeKnownBits), and so
88  /// on.
89  std::array<const Value *, MaxDepth> Excluded;
90  unsigned NumExcluded;
91 
92  Query(const DataLayout &DL, AssumptionCache *AC, const Instruction *CxtI,
93  const DominatorTree *DT)
94  : DL(DL), AC(AC), CxtI(CxtI), DT(DT), NumExcluded(0) {}
95 
96  Query(const Query &Q, const Value *NewExcl)
97  : DL(Q.DL), AC(Q.AC), CxtI(Q.CxtI), DT(Q.DT), NumExcluded(Q.NumExcluded) {
98  Excluded = Q.Excluded;
99  Excluded[NumExcluded++] = NewExcl;
100  assert(NumExcluded <= Excluded.size());
101  }
102 
103  bool isExcluded(const Value *Value) const {
104  if (NumExcluded == 0)
105  return false;
106  auto End = Excluded.begin() + NumExcluded;
107  return std::find(Excluded.begin(), End, Value) != End;
108  }
109 };
110 } // end anonymous namespace
111 
112 // Given the provided Value and, potentially, a context instruction, return
113 // the preferred context instruction (if any).
114 static const Instruction *safeCxtI(const Value *V, const Instruction *CxtI) {
115  // If we've been provided with a context instruction, then use that (provided
116  // it has been inserted).
117  if (CxtI && CxtI->getParent())
118  return CxtI;
119 
120  // If the value is really an already-inserted instruction, then use that.
121  CxtI = dyn_cast<Instruction>(V);
122  if (CxtI && CxtI->getParent())
123  return CxtI;
124 
125  return nullptr;
126 }
127 
128 static void computeKnownBits(const Value *V, APInt &KnownZero, APInt &KnownOne,
129  unsigned Depth, const Query &Q);
130 
131 void llvm::computeKnownBits(const Value *V, APInt &KnownZero, APInt &KnownOne,
132  const DataLayout &DL, unsigned Depth,
133  AssumptionCache *AC, const Instruction *CxtI,
134  const DominatorTree *DT) {
135  ::computeKnownBits(V, KnownZero, KnownOne, Depth,
136  Query(DL, AC, safeCxtI(V, CxtI), DT));
137 }
138 
139 bool llvm::haveNoCommonBitsSet(const Value *LHS, const Value *RHS,
140  const DataLayout &DL,
141  AssumptionCache *AC, const Instruction *CxtI,
142  const DominatorTree *DT) {
143  assert(LHS->getType() == RHS->getType() &&
144  "LHS and RHS should have the same type");
145  assert(LHS->getType()->isIntOrIntVectorTy() &&
146  "LHS and RHS should be integers");
147  IntegerType *IT = cast<IntegerType>(LHS->getType()->getScalarType());
148  APInt LHSKnownZero(IT->getBitWidth(), 0), LHSKnownOne(IT->getBitWidth(), 0);
149  APInt RHSKnownZero(IT->getBitWidth(), 0), RHSKnownOne(IT->getBitWidth(), 0);
150  computeKnownBits(LHS, LHSKnownZero, LHSKnownOne, DL, 0, AC, CxtI, DT);
151  computeKnownBits(RHS, RHSKnownZero, RHSKnownOne, DL, 0, AC, CxtI, DT);
152  return (LHSKnownZero | RHSKnownZero).isAllOnesValue();
153 }
154 
155 static void ComputeSignBit(const Value *V, bool &KnownZero, bool &KnownOne,
156  unsigned Depth, const Query &Q);
157 
158 void llvm::ComputeSignBit(const Value *V, bool &KnownZero, bool &KnownOne,
159  const DataLayout &DL, unsigned Depth,
160  AssumptionCache *AC, const Instruction *CxtI,
161  const DominatorTree *DT) {
162  ::ComputeSignBit(V, KnownZero, KnownOne, Depth,
163  Query(DL, AC, safeCxtI(V, CxtI), DT));
164 }
165 
166 static bool isKnownToBeAPowerOfTwo(const Value *V, bool OrZero, unsigned Depth,
167  const Query &Q);
168 
169 bool llvm::isKnownToBeAPowerOfTwo(const Value *V, const DataLayout &DL,
170  bool OrZero,
171  unsigned Depth, AssumptionCache *AC,
172  const Instruction *CxtI,
173  const DominatorTree *DT) {
174  return ::isKnownToBeAPowerOfTwo(V, OrZero, Depth,
175  Query(DL, AC, safeCxtI(V, CxtI), DT));
176 }
177 
178 static bool isKnownNonZero(const Value *V, unsigned Depth, const Query &Q);
179 
180 bool llvm::isKnownNonZero(const Value *V, const DataLayout &DL, unsigned Depth,
181  AssumptionCache *AC, const Instruction *CxtI,
182  const DominatorTree *DT) {
183  return ::isKnownNonZero(V, Depth, Query(DL, AC, safeCxtI(V, CxtI), DT));
184 }
185 
186 bool llvm::isKnownNonNegative(const Value *V, const DataLayout &DL,
187  unsigned Depth,
188  AssumptionCache *AC, const Instruction *CxtI,
189  const DominatorTree *DT) {
190  bool NonNegative, Negative;
191  ComputeSignBit(V, NonNegative, Negative, DL, Depth, AC, CxtI, DT);
192  return NonNegative;
193 }
194 
195 bool llvm::isKnownPositive(const Value *V, const DataLayout &DL, unsigned Depth,
196  AssumptionCache *AC, const Instruction *CxtI,
197  const DominatorTree *DT) {
198  if (auto *CI = dyn_cast<ConstantInt>(V))
199  return CI->getValue().isStrictlyPositive();
200 
201  // TODO: We'd doing two recursive queries here. We should factor this such
202  // that only a single query is needed.
203  return isKnownNonNegative(V, DL, Depth, AC, CxtI, DT) &&
204  isKnownNonZero(V, DL, Depth, AC, CxtI, DT);
205 }
206 
207 bool llvm::isKnownNegative(const Value *V, const DataLayout &DL, unsigned Depth,
208  AssumptionCache *AC, const Instruction *CxtI,
209  const DominatorTree *DT) {
210  bool NonNegative, Negative;
211  ComputeSignBit(V, NonNegative, Negative, DL, Depth, AC, CxtI, DT);
212  return Negative;
213 }
214 
215 static bool isKnownNonEqual(const Value *V1, const Value *V2, const Query &Q);
216 
217 bool llvm::isKnownNonEqual(const Value *V1, const Value *V2,
218  const DataLayout &DL,
219  AssumptionCache *AC, const Instruction *CxtI,
220  const DominatorTree *DT) {
221  return ::isKnownNonEqual(V1, V2, Query(DL, AC,
222  safeCxtI(V1, safeCxtI(V2, CxtI)),
223  DT));
224 }
225 
226 static bool MaskedValueIsZero(const Value *V, const APInt &Mask, unsigned Depth,
227  const Query &Q);
228 
229 bool llvm::MaskedValueIsZero(const Value *V, const APInt &Mask,
230  const DataLayout &DL,
231  unsigned Depth, AssumptionCache *AC,
232  const Instruction *CxtI, const DominatorTree *DT) {
233  return ::MaskedValueIsZero(V, Mask, Depth,
234  Query(DL, AC, safeCxtI(V, CxtI), DT));
235 }
236 
237 static unsigned ComputeNumSignBits(const Value *V, unsigned Depth,
238  const Query &Q);
239 
240 unsigned llvm::ComputeNumSignBits(const Value *V, const DataLayout &DL,
241  unsigned Depth, AssumptionCache *AC,
242  const Instruction *CxtI,
243  const DominatorTree *DT) {
244  return ::ComputeNumSignBits(V, Depth, Query(DL, AC, safeCxtI(V, CxtI), DT));
245 }
246 
247 static void computeKnownBitsAddSub(bool Add, const Value *Op0, const Value *Op1,
248  bool NSW,
249  APInt &KnownZero, APInt &KnownOne,
250  APInt &KnownZero2, APInt &KnownOne2,
251  unsigned Depth, const Query &Q) {
252  if (!Add) {
253  if (const ConstantInt *CLHS = dyn_cast<ConstantInt>(Op0)) {
254  // We know that the top bits of C-X are clear if X contains less bits
255  // than C (i.e. no wrap-around can happen). For example, 20-X is
256  // positive if we can prove that X is >= 0 and < 16.
257  if (!CLHS->getValue().isNegative()) {
258  unsigned BitWidth = KnownZero.getBitWidth();
259  unsigned NLZ = (CLHS->getValue()+1).countLeadingZeros();
260  // NLZ can't be BitWidth with no sign bit
261  APInt MaskV = APInt::getHighBitsSet(BitWidth, NLZ+1);
262  computeKnownBits(Op1, KnownZero2, KnownOne2, Depth + 1, Q);
263 
264  // If all of the MaskV bits are known to be zero, then we know the
265  // output top bits are zero, because we now know that the output is
266  // from [0-C].
267  if ((KnownZero2 & MaskV) == MaskV) {
268  unsigned NLZ2 = CLHS->getValue().countLeadingZeros();
269  // Top bits known zero.
270  KnownZero = APInt::getHighBitsSet(BitWidth, NLZ2);
271  }
272  }
273  }
274  }
275 
276  unsigned BitWidth = KnownZero.getBitWidth();
277 
278  // If an initial sequence of bits in the result is not needed, the
279  // corresponding bits in the operands are not needed.
280  APInt LHSKnownZero(BitWidth, 0), LHSKnownOne(BitWidth, 0);
281  computeKnownBits(Op0, LHSKnownZero, LHSKnownOne, Depth + 1, Q);
282  computeKnownBits(Op1, KnownZero2, KnownOne2, Depth + 1, Q);
283 
284  // Carry in a 1 for a subtract, rather than a 0.
285  APInt CarryIn(BitWidth, 0);
286  if (!Add) {
287  // Sum = LHS + ~RHS + 1
288  std::swap(KnownZero2, KnownOne2);
289  CarryIn.setBit(0);
290  }
291 
292  APInt PossibleSumZero = ~LHSKnownZero + ~KnownZero2 + CarryIn;
293  APInt PossibleSumOne = LHSKnownOne + KnownOne2 + CarryIn;
294 
295  // Compute known bits of the carry.
296  APInt CarryKnownZero = ~(PossibleSumZero ^ LHSKnownZero ^ KnownZero2);
297  APInt CarryKnownOne = PossibleSumOne ^ LHSKnownOne ^ KnownOne2;
298 
299  // Compute set of known bits (where all three relevant bits are known).
300  APInt LHSKnown = LHSKnownZero | LHSKnownOne;
301  APInt RHSKnown = KnownZero2 | KnownOne2;
302  APInt CarryKnown = CarryKnownZero | CarryKnownOne;
303  APInt Known = LHSKnown & RHSKnown & CarryKnown;
304 
305  assert((PossibleSumZero & Known) == (PossibleSumOne & Known) &&
306  "known bits of sum differ");
307 
308  // Compute known bits of the result.
309  KnownZero = ~PossibleSumOne & Known;
310  KnownOne = PossibleSumOne & Known;
311 
312  // Are we still trying to solve for the sign bit?
313  if (!Known.isNegative()) {
314  if (NSW) {
315  // Adding two non-negative numbers, or subtracting a negative number from
316  // a non-negative one, can't wrap into negative.
317  if (LHSKnownZero.isNegative() && KnownZero2.isNegative())
318  KnownZero |= APInt::getSignBit(BitWidth);
319  // Adding two negative numbers, or subtracting a non-negative number from
320  // a negative one, can't wrap into non-negative.
321  else if (LHSKnownOne.isNegative() && KnownOne2.isNegative())
322  KnownOne |= APInt::getSignBit(BitWidth);
323  }
324  }
325 }
326 
327 static void computeKnownBitsMul(const Value *Op0, const Value *Op1, bool NSW,
328  APInt &KnownZero, APInt &KnownOne,
329  APInt &KnownZero2, APInt &KnownOne2,
330  unsigned Depth, const Query &Q) {
331  unsigned BitWidth = KnownZero.getBitWidth();
332  computeKnownBits(Op1, KnownZero, KnownOne, Depth + 1, Q);
333  computeKnownBits(Op0, KnownZero2, KnownOne2, Depth + 1, Q);
334 
335  bool isKnownNegative = false;
336  bool isKnownNonNegative = false;
337  // If the multiplication is known not to overflow, compute the sign bit.
338  if (NSW) {
339  if (Op0 == Op1) {
340  // The product of a number with itself is non-negative.
341  isKnownNonNegative = true;
342  } else {
343  bool isKnownNonNegativeOp1 = KnownZero.isNegative();
344  bool isKnownNonNegativeOp0 = KnownZero2.isNegative();
345  bool isKnownNegativeOp1 = KnownOne.isNegative();
346  bool isKnownNegativeOp0 = KnownOne2.isNegative();
347  // The product of two numbers with the same sign is non-negative.
348  isKnownNonNegative = (isKnownNegativeOp1 && isKnownNegativeOp0) ||
349  (isKnownNonNegativeOp1 && isKnownNonNegativeOp0);
350  // The product of a negative number and a non-negative number is either
351  // negative or zero.
352  if (!isKnownNonNegative)
353  isKnownNegative = (isKnownNegativeOp1 && isKnownNonNegativeOp0 &&
354  isKnownNonZero(Op0, Depth, Q)) ||
355  (isKnownNegativeOp0 && isKnownNonNegativeOp1 &&
356  isKnownNonZero(Op1, Depth, Q));
357  }
358  }
359 
360  // If low bits are zero in either operand, output low known-0 bits.
361  // Also compute a conservative estimate for high known-0 bits.
362  // More trickiness is possible, but this is sufficient for the
363  // interesting case of alignment computation.
364  KnownOne.clearAllBits();
365  unsigned TrailZ = KnownZero.countTrailingOnes() +
366  KnownZero2.countTrailingOnes();
367  unsigned LeadZ = std::max(KnownZero.countLeadingOnes() +
368  KnownZero2.countLeadingOnes(),
369  BitWidth) - BitWidth;
370 
371  TrailZ = std::min(TrailZ, BitWidth);
372  LeadZ = std::min(LeadZ, BitWidth);
373  KnownZero = APInt::getLowBitsSet(BitWidth, TrailZ) |
374  APInt::getHighBitsSet(BitWidth, LeadZ);
375 
376  // Only make use of no-wrap flags if we failed to compute the sign bit
377  // directly. This matters if the multiplication always overflows, in
378  // which case we prefer to follow the result of the direct computation,
379  // though as the program is invoking undefined behaviour we can choose
380  // whatever we like here.
381  if (isKnownNonNegative && !KnownOne.isNegative())
382  KnownZero.setBit(BitWidth - 1);
383  else if (isKnownNegative && !KnownZero.isNegative())
384  KnownOne.setBit(BitWidth - 1);
385 }
386 
388  APInt &KnownZero,
389  APInt &KnownOne) {
390  unsigned BitWidth = KnownZero.getBitWidth();
391  unsigned NumRanges = Ranges.getNumOperands() / 2;
392  assert(NumRanges >= 1);
393 
394  KnownZero.setAllBits();
395  KnownOne.setAllBits();
396 
397  for (unsigned i = 0; i < NumRanges; ++i) {
398  ConstantInt *Lower =
399  mdconst::extract<ConstantInt>(Ranges.getOperand(2 * i + 0));
400  ConstantInt *Upper =
401  mdconst::extract<ConstantInt>(Ranges.getOperand(2 * i + 1));
402  ConstantRange Range(Lower->getValue(), Upper->getValue());
403 
404  // The first CommonPrefixBits of all values in Range are equal.
405  unsigned CommonPrefixBits =
406  (Range.getUnsignedMax() ^ Range.getUnsignedMin()).countLeadingZeros();
407 
408  APInt Mask = APInt::getHighBitsSet(BitWidth, CommonPrefixBits);
409  KnownOne &= Range.getUnsignedMax() & Mask;
410  KnownZero &= ~Range.getUnsignedMax() & Mask;
411  }
412 }
413 
414 static bool isEphemeralValueOf(const Instruction *I, const Value *E) {
415  SmallVector<const Value *, 16> WorkSet(1, I);
418 
419  // The instruction defining an assumption's condition itself is always
420  // considered ephemeral to that assumption (even if it has other
421  // non-ephemeral users). See r246696's test case for an example.
422  if (is_contained(I->operands(), E))
423  return true;
424 
425  while (!WorkSet.empty()) {
426  const Value *V = WorkSet.pop_back_val();
427  if (!Visited.insert(V).second)
428  continue;
429 
430  // If all uses of this value are ephemeral, then so is this value.
431  if (all_of(V->users(), [&](const User *U) { return EphValues.count(U); })) {
432  if (V == E)
433  return true;
434 
435  EphValues.insert(V);
436  if (const User *U = dyn_cast<User>(V))
437  for (User::const_op_iterator J = U->op_begin(), JE = U->op_end();
438  J != JE; ++J) {
440  WorkSet.push_back(*J);
441  }
442  }
443  }
444 
445  return false;
446 }
447 
448 // Is this an intrinsic that cannot be speculated but also cannot trap?
449 static bool isAssumeLikeIntrinsic(const Instruction *I) {
450  if (const CallInst *CI = dyn_cast<CallInst>(I))
451  if (Function *F = CI->getCalledFunction())
452  switch (F->getIntrinsicID()) {
453  default: break;
454  // FIXME: This list is repeated from NoTTI::getIntrinsicCost.
455  case Intrinsic::assume:
456  case Intrinsic::dbg_declare:
457  case Intrinsic::dbg_value:
458  case Intrinsic::invariant_start:
459  case Intrinsic::invariant_end:
460  case Intrinsic::lifetime_start:
461  case Intrinsic::lifetime_end:
462  case Intrinsic::objectsize:
463  case Intrinsic::ptr_annotation:
464  case Intrinsic::var_annotation:
465  return true;
466  }
467 
468  return false;
469 }
470 
472  const Instruction *CxtI,
473  const DominatorTree *DT) {
474 
475  // There are two restrictions on the use of an assume:
476  // 1. The assume must dominate the context (or the control flow must
477  // reach the assume whenever it reaches the context).
478  // 2. The context must not be in the assume's set of ephemeral values
479  // (otherwise we will use the assume to prove that the condition
480  // feeding the assume is trivially true, thus causing the removal of
481  // the assume).
482 
483  if (DT) {
484  if (DT->dominates(Inv, CxtI))
485  return true;
486  } else if (Inv->getParent() == CxtI->getParent()->getSinglePredecessor()) {
487  // We don't have a DT, but this trivially dominates.
488  return true;
489  }
490 
491  // With or without a DT, the only remaining case we will check is if the
492  // instructions are in the same BB. Give up if that is not the case.
493  if (Inv->getParent() != CxtI->getParent())
494  return false;
495 
496  // If we have a dom tree, then we now know that the assume doens't dominate
497  // the other instruction. If we don't have a dom tree then we can check if
498  // the assume is first in the BB.
499  if (!DT) {
500  // Search forward from the assume until we reach the context (or the end
501  // of the block); the common case is that the assume will come first.
502  for (auto I = std::next(BasicBlock::const_iterator(Inv)),
503  IE = Inv->getParent()->end(); I != IE; ++I)
504  if (&*I == CxtI)
505  return true;
506  }
507 
508  // The context comes first, but they're both in the same block. Make sure
509  // there is nothing in between that might interrupt the control flow.
511  std::next(BasicBlock::const_iterator(CxtI)), IE(Inv);
512  I != IE; ++I)
514  return false;
515 
516  return !isEphemeralValueOf(Inv, CxtI);
517 }
518 
519 static void computeKnownBitsFromAssume(const Value *V, APInt &KnownZero,
520  APInt &KnownOne, unsigned Depth,
521  const Query &Q) {
522  // Use of assumptions is context-sensitive. If we don't have a context, we
523  // cannot use them!
524  if (!Q.AC || !Q.CxtI)
525  return;
526 
527  unsigned BitWidth = KnownZero.getBitWidth();
528 
529  // Note that the patterns below need to be kept in sync with the code
530  // in AssumptionCache::updateAffectedValues.
531 
532  for (auto &AssumeVH : Q.AC->assumptionsFor(V)) {
533  if (!AssumeVH)
534  continue;
535  CallInst *I = cast<CallInst>(AssumeVH);
536  assert(I->getParent()->getParent() == Q.CxtI->getParent()->getParent() &&
537  "Got assumption for the wrong function!");
538  if (Q.isExcluded(I))
539  continue;
540 
541  // Warning: This loop can end up being somewhat performance sensetive.
542  // We're running this loop for once for each value queried resulting in a
543  // runtime of ~O(#assumes * #values).
544 
545  assert(I->getCalledFunction()->getIntrinsicID() == Intrinsic::assume &&
546  "must be an assume intrinsic");
547 
548  Value *Arg = I->getArgOperand(0);
549 
550  if (Arg == V && isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
551  assert(BitWidth == 1 && "assume operand is not i1?");
552  KnownZero.clearAllBits();
553  KnownOne.setAllBits();
554  return;
555  }
556 
557  // The remaining tests are all recursive, so bail out if we hit the limit.
558  if (Depth == MaxDepth)
559  continue;
560 
561  Value *A, *B;
562  auto m_V = m_CombineOr(m_Specific(V),
564  m_BitCast(m_Specific(V))));
565 
566  CmpInst::Predicate Pred;
567  ConstantInt *C;
568  // assume(v = a)
569  if (match(Arg, m_c_ICmp(Pred, m_V, m_Value(A))) &&
570  Pred == ICmpInst::ICMP_EQ && isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
571  APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
572  computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
573  KnownZero |= RHSKnownZero;
574  KnownOne |= RHSKnownOne;
575  // assume(v & b = a)
576  } else if (match(Arg,
577  m_c_ICmp(Pred, m_c_And(m_V, m_Value(B)), m_Value(A))) &&
578  Pred == ICmpInst::ICMP_EQ &&
579  isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
580  APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
581  computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
582  APInt MaskKnownZero(BitWidth, 0), MaskKnownOne(BitWidth, 0);
583  computeKnownBits(B, MaskKnownZero, MaskKnownOne, Depth+1, Query(Q, I));
584 
585  // For those bits in the mask that are known to be one, we can propagate
586  // known bits from the RHS to V.
587  KnownZero |= RHSKnownZero & MaskKnownOne;
588  KnownOne |= RHSKnownOne & MaskKnownOne;
589  // assume(~(v & b) = a)
590  } else if (match(Arg, m_c_ICmp(Pred, m_Not(m_c_And(m_V, m_Value(B))),
591  m_Value(A))) &&
592  Pred == ICmpInst::ICMP_EQ &&
593  isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
594  APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
595  computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
596  APInt MaskKnownZero(BitWidth, 0), MaskKnownOne(BitWidth, 0);
597  computeKnownBits(B, MaskKnownZero, MaskKnownOne, Depth+1, Query(Q, I));
598 
599  // For those bits in the mask that are known to be one, we can propagate
600  // inverted known bits from the RHS to V.
601  KnownZero |= RHSKnownOne & MaskKnownOne;
602  KnownOne |= RHSKnownZero & MaskKnownOne;
603  // assume(v | b = a)
604  } else if (match(Arg,
605  m_c_ICmp(Pred, m_c_Or(m_V, m_Value(B)), m_Value(A))) &&
606  Pred == ICmpInst::ICMP_EQ &&
607  isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
608  APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
609  computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
610  APInt BKnownZero(BitWidth, 0), BKnownOne(BitWidth, 0);
611  computeKnownBits(B, BKnownZero, BKnownOne, Depth+1, Query(Q, I));
612 
613  // For those bits in B that are known to be zero, we can propagate known
614  // bits from the RHS to V.
615  KnownZero |= RHSKnownZero & BKnownZero;
616  KnownOne |= RHSKnownOne & BKnownZero;
617  // assume(~(v | b) = a)
618  } else if (match(Arg, m_c_ICmp(Pred, m_Not(m_c_Or(m_V, m_Value(B))),
619  m_Value(A))) &&
620  Pred == ICmpInst::ICMP_EQ &&
621  isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
622  APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
623  computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
624  APInt BKnownZero(BitWidth, 0), BKnownOne(BitWidth, 0);
625  computeKnownBits(B, BKnownZero, BKnownOne, Depth+1, Query(Q, I));
626 
627  // For those bits in B that are known to be zero, we can propagate
628  // inverted known bits from the RHS to V.
629  KnownZero |= RHSKnownOne & BKnownZero;
630  KnownOne |= RHSKnownZero & BKnownZero;
631  // assume(v ^ b = a)
632  } else if (match(Arg,
633  m_c_ICmp(Pred, m_c_Xor(m_V, m_Value(B)), m_Value(A))) &&
634  Pred == ICmpInst::ICMP_EQ &&
635  isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
636  APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
637  computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
638  APInt BKnownZero(BitWidth, 0), BKnownOne(BitWidth, 0);
639  computeKnownBits(B, BKnownZero, BKnownOne, Depth+1, Query(Q, I));
640 
641  // For those bits in B that are known to be zero, we can propagate known
642  // bits from the RHS to V. For those bits in B that are known to be one,
643  // we can propagate inverted known bits from the RHS to V.
644  KnownZero |= RHSKnownZero & BKnownZero;
645  KnownOne |= RHSKnownOne & BKnownZero;
646  KnownZero |= RHSKnownOne & BKnownOne;
647  KnownOne |= RHSKnownZero & BKnownOne;
648  // assume(~(v ^ b) = a)
649  } else if (match(Arg, m_c_ICmp(Pred, m_Not(m_c_Xor(m_V, m_Value(B))),
650  m_Value(A))) &&
651  Pred == ICmpInst::ICMP_EQ &&
652  isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
653  APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
654  computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
655  APInt BKnownZero(BitWidth, 0), BKnownOne(BitWidth, 0);
656  computeKnownBits(B, BKnownZero, BKnownOne, Depth+1, Query(Q, I));
657 
658  // For those bits in B that are known to be zero, we can propagate
659  // inverted known bits from the RHS to V. For those bits in B that are
660  // known to be one, we can propagate known bits from the RHS to V.
661  KnownZero |= RHSKnownOne & BKnownZero;
662  KnownOne |= RHSKnownZero & BKnownZero;
663  KnownZero |= RHSKnownZero & BKnownOne;
664  KnownOne |= RHSKnownOne & BKnownOne;
665  // assume(v << c = a)
666  } else if (match(Arg, m_c_ICmp(Pred, m_Shl(m_V, m_ConstantInt(C)),
667  m_Value(A))) &&
668  Pred == ICmpInst::ICMP_EQ &&
669  isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
670  APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
671  computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
672  // For those bits in RHS that are known, we can propagate them to known
673  // bits in V shifted to the right by C.
674  KnownZero |= RHSKnownZero.lshr(C->getZExtValue());
675  KnownOne |= RHSKnownOne.lshr(C->getZExtValue());
676  // assume(~(v << c) = a)
677  } else if (match(Arg, m_c_ICmp(Pred, m_Not(m_Shl(m_V, m_ConstantInt(C))),
678  m_Value(A))) &&
679  Pred == ICmpInst::ICMP_EQ &&
680  isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
681  APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
682  computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
683  // For those bits in RHS that are known, we can propagate them inverted
684  // to known bits in V shifted to the right by C.
685  KnownZero |= RHSKnownOne.lshr(C->getZExtValue());
686  KnownOne |= RHSKnownZero.lshr(C->getZExtValue());
687  // assume(v >> c = a)
688  } else if (match(Arg,
689  m_c_ICmp(Pred, m_CombineOr(m_LShr(m_V, m_ConstantInt(C)),
690  m_AShr(m_V, m_ConstantInt(C))),
691  m_Value(A))) &&
692  Pred == ICmpInst::ICMP_EQ &&
693  isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
694  APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
695  computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
696  // For those bits in RHS that are known, we can propagate them to known
697  // bits in V shifted to the right by C.
698  KnownZero |= RHSKnownZero << C->getZExtValue();
699  KnownOne |= RHSKnownOne << C->getZExtValue();
700  // assume(~(v >> c) = a)
701  } else if (match(Arg, m_c_ICmp(Pred, m_Not(m_CombineOr(
702  m_LShr(m_V, m_ConstantInt(C)),
703  m_AShr(m_V, m_ConstantInt(C)))),
704  m_Value(A))) &&
705  Pred == ICmpInst::ICMP_EQ &&
706  isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
707  APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
708  computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
709  // For those bits in RHS that are known, we can propagate them inverted
710  // to known bits in V shifted to the right by C.
711  KnownZero |= RHSKnownOne << C->getZExtValue();
712  KnownOne |= RHSKnownZero << C->getZExtValue();
713  // assume(v >=_s c) where c is non-negative
714  } else if (match(Arg, m_ICmp(Pred, m_V, m_Value(A))) &&
715  Pred == ICmpInst::ICMP_SGE &&
716  isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
717  APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
718  computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
719 
720  if (RHSKnownZero.isNegative()) {
721  // We know that the sign bit is zero.
722  KnownZero |= APInt::getSignBit(BitWidth);
723  }
724  // assume(v >_s c) where c is at least -1.
725  } else if (match(Arg, m_ICmp(Pred, m_V, m_Value(A))) &&
726  Pred == ICmpInst::ICMP_SGT &&
727  isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
728  APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
729  computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
730 
731  if (RHSKnownOne.isAllOnesValue() || RHSKnownZero.isNegative()) {
732  // We know that the sign bit is zero.
733  KnownZero |= APInt::getSignBit(BitWidth);
734  }
735  // assume(v <=_s c) where c is negative
736  } else if (match(Arg, m_ICmp(Pred, m_V, m_Value(A))) &&
737  Pred == ICmpInst::ICMP_SLE &&
738  isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
739  APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
740  computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
741 
742  if (RHSKnownOne.isNegative()) {
743  // We know that the sign bit is one.
744  KnownOne |= APInt::getSignBit(BitWidth);
745  }
746  // assume(v <_s c) where c is non-positive
747  } else if (match(Arg, m_ICmp(Pred, m_V, m_Value(A))) &&
748  Pred == ICmpInst::ICMP_SLT &&
749  isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
750  APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
751  computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
752 
753  if (RHSKnownZero.isAllOnesValue() || RHSKnownOne.isNegative()) {
754  // We know that the sign bit is one.
755  KnownOne |= APInt::getSignBit(BitWidth);
756  }
757  // assume(v <=_u c)
758  } else if (match(Arg, m_ICmp(Pred, m_V, m_Value(A))) &&
759  Pred == ICmpInst::ICMP_ULE &&
760  isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
761  APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
762  computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
763 
764  // Whatever high bits in c are zero are known to be zero.
765  KnownZero |=
766  APInt::getHighBitsSet(BitWidth, RHSKnownZero.countLeadingOnes());
767  // assume(v <_u c)
768  } else if (match(Arg, m_ICmp(Pred, m_V, m_Value(A))) &&
769  Pred == ICmpInst::ICMP_ULT &&
770  isValidAssumeForContext(I, Q.CxtI, Q.DT)) {
771  APInt RHSKnownZero(BitWidth, 0), RHSKnownOne(BitWidth, 0);
772  computeKnownBits(A, RHSKnownZero, RHSKnownOne, Depth+1, Query(Q, I));
773 
774  // Whatever high bits in c are zero are known to be zero (if c is a power
775  // of 2, then one more).
776  if (isKnownToBeAPowerOfTwo(A, false, Depth + 1, Query(Q, I)))
777  KnownZero |=
778  APInt::getHighBitsSet(BitWidth, RHSKnownZero.countLeadingOnes()+1);
779  else
780  KnownZero |=
781  APInt::getHighBitsSet(BitWidth, RHSKnownZero.countLeadingOnes());
782  }
783  }
784 }
785 
786 // Compute known bits from a shift operator, including those with a
787 // non-constant shift amount. KnownZero and KnownOne are the outputs of this
788 // function. KnownZero2 and KnownOne2 are pre-allocated temporaries with the
789 // same bit width as KnownZero and KnownOne. KZF and KOF are operator-specific
790 // functors that, given the known-zero or known-one bits respectively, and a
791 // shift amount, compute the implied known-zero or known-one bits of the shift
792 // operator's result respectively for that shift amount. The results from calling
793 // KZF and KOF are conservatively combined for all permitted shift amounts.
795  const Operator *I, APInt &KnownZero, APInt &KnownOne, APInt &KnownZero2,
796  APInt &KnownOne2, unsigned Depth, const Query &Q,
797  function_ref<APInt(const APInt &, unsigned)> KZF,
798  function_ref<APInt(const APInt &, unsigned)> KOF) {
799  unsigned BitWidth = KnownZero.getBitWidth();
800 
801  if (auto *SA = dyn_cast<ConstantInt>(I->getOperand(1))) {
802  unsigned ShiftAmt = SA->getLimitedValue(BitWidth-1);
803 
804  computeKnownBits(I->getOperand(0), KnownZero, KnownOne, Depth + 1, Q);
805  KnownZero = KZF(KnownZero, ShiftAmt);
806  KnownOne = KOF(KnownOne, ShiftAmt);
807  // If there is conflict between KnownZero and KnownOne, this must be an
808  // overflowing left shift, so the shift result is undefined. Clear KnownZero
809  // and KnownOne bits so that other code could propagate this undef.
810  if ((KnownZero & KnownOne) != 0) {
811  KnownZero.clearAllBits();
812  KnownOne.clearAllBits();
813  }
814 
815  return;
816  }
817 
818  computeKnownBits(I->getOperand(1), KnownZero, KnownOne, Depth + 1, Q);
819 
820  // Note: We cannot use KnownZero.getLimitedValue() here, because if
821  // BitWidth > 64 and any upper bits are known, we'll end up returning the
822  // limit value (which implies all bits are known).
823  uint64_t ShiftAmtKZ = KnownZero.zextOrTrunc(64).getZExtValue();
824  uint64_t ShiftAmtKO = KnownOne.zextOrTrunc(64).getZExtValue();
825 
826  // It would be more-clearly correct to use the two temporaries for this
827  // calculation. Reusing the APInts here to prevent unnecessary allocations.
828  KnownZero.clearAllBits();
829  KnownOne.clearAllBits();
830 
831  // If we know the shifter operand is nonzero, we can sometimes infer more
832  // known bits. However this is expensive to compute, so be lazy about it and
833  // only compute it when absolutely necessary.
834  Optional<bool> ShifterOperandIsNonZero;
835 
836  // Early exit if we can't constrain any well-defined shift amount.
837  if (!(ShiftAmtKZ & (BitWidth - 1)) && !(ShiftAmtKO & (BitWidth - 1))) {
838  ShifterOperandIsNonZero =
839  isKnownNonZero(I->getOperand(1), Depth + 1, Q);
840  if (!*ShifterOperandIsNonZero)
841  return;
842  }
843 
844  computeKnownBits(I->getOperand(0), KnownZero2, KnownOne2, Depth + 1, Q);
845 
846  KnownZero = KnownOne = APInt::getAllOnesValue(BitWidth);
847  for (unsigned ShiftAmt = 0; ShiftAmt < BitWidth; ++ShiftAmt) {
848  // Combine the shifted known input bits only for those shift amounts
849  // compatible with its known constraints.
850  if ((ShiftAmt & ~ShiftAmtKZ) != ShiftAmt)
851  continue;
852  if ((ShiftAmt | ShiftAmtKO) != ShiftAmt)
853  continue;
854  // If we know the shifter is nonzero, we may be able to infer more known
855  // bits. This check is sunk down as far as possible to avoid the expensive
856  // call to isKnownNonZero if the cheaper checks above fail.
857  if (ShiftAmt == 0) {
858  if (!ShifterOperandIsNonZero.hasValue())
859  ShifterOperandIsNonZero =
860  isKnownNonZero(I->getOperand(1), Depth + 1, Q);
861  if (*ShifterOperandIsNonZero)
862  continue;
863  }
864 
865  KnownZero &= KZF(KnownZero2, ShiftAmt);
866  KnownOne &= KOF(KnownOne2, ShiftAmt);
867  }
868 
869  // If there are no compatible shift amounts, then we've proven that the shift
870  // amount must be >= the BitWidth, and the result is undefined. We could
871  // return anything we'd like, but we need to make sure the sets of known bits
872  // stay disjoint (it should be better for some other code to actually
873  // propagate the undef than to pick a value here using known bits).
874  if ((KnownZero & KnownOne) != 0) {
875  KnownZero.clearAllBits();
876  KnownOne.clearAllBits();
877  }
878 }
879 
880 static void computeKnownBitsFromOperator(const Operator *I, APInt &KnownZero,
881  APInt &KnownOne, unsigned Depth,
882  const Query &Q) {
883  unsigned BitWidth = KnownZero.getBitWidth();
884 
885  APInt KnownZero2(KnownZero), KnownOne2(KnownOne);
886  switch (I->getOpcode()) {
887  default: break;
888  case Instruction::Load:
889  if (MDNode *MD = cast<LoadInst>(I)->getMetadata(LLVMContext::MD_range))
890  computeKnownBitsFromRangeMetadata(*MD, KnownZero, KnownOne);
891  break;
892  case Instruction::And: {
893  // If either the LHS or the RHS are Zero, the result is zero.
894  computeKnownBits(I->getOperand(1), KnownZero, KnownOne, Depth + 1, Q);
895  computeKnownBits(I->getOperand(0), KnownZero2, KnownOne2, Depth + 1, Q);
896 
897  // Output known-1 bits are only known if set in both the LHS & RHS.
898  KnownOne &= KnownOne2;
899  // Output known-0 are known to be clear if zero in either the LHS | RHS.
900  KnownZero |= KnownZero2;
901 
902  // and(x, add (x, -1)) is a common idiom that always clears the low bit;
903  // here we handle the more general case of adding any odd number by
904  // matching the form add(x, add(x, y)) where y is odd.
905  // TODO: This could be generalized to clearing any bit set in y where the
906  // following bit is known to be unset in y.
907  Value *Y = nullptr;
908  if (match(I->getOperand(0), m_Add(m_Specific(I->getOperand(1)),
909  m_Value(Y))) ||
911  m_Value(Y)))) {
912  APInt KnownZero3(BitWidth, 0), KnownOne3(BitWidth, 0);
913  computeKnownBits(Y, KnownZero3, KnownOne3, Depth + 1, Q);
914  if (KnownOne3.countTrailingOnes() > 0)
915  KnownZero |= APInt::getLowBitsSet(BitWidth, 1);
916  }
917  break;
918  }
919  case Instruction::Or: {
920  computeKnownBits(I->getOperand(1), KnownZero, KnownOne, Depth + 1, Q);
921  computeKnownBits(I->getOperand(0), KnownZero2, KnownOne2, Depth + 1, Q);
922 
923  // Output known-0 bits are only known if clear in both the LHS & RHS.
924  KnownZero &= KnownZero2;
925  // Output known-1 are known to be set if set in either the LHS | RHS.
926  KnownOne |= KnownOne2;
927  break;
928  }
929  case Instruction::Xor: {
930  computeKnownBits(I->getOperand(1), KnownZero, KnownOne, Depth + 1, Q);
931  computeKnownBits(I->getOperand(0), KnownZero2, KnownOne2, Depth + 1, Q);
932 
933  // Output known-0 bits are known if clear or set in both the LHS & RHS.
934  APInt KnownZeroOut = (KnownZero & KnownZero2) | (KnownOne & KnownOne2);
935  // Output known-1 are known to be set if set in only one of the LHS, RHS.
936  KnownOne = (KnownZero & KnownOne2) | (KnownOne & KnownZero2);
937  KnownZero = KnownZeroOut;
938  break;
939  }
940  case Instruction::Mul: {
941  bool NSW = cast<OverflowingBinaryOperator>(I)->hasNoSignedWrap();
942  computeKnownBitsMul(I->getOperand(0), I->getOperand(1), NSW, KnownZero,
943  KnownOne, KnownZero2, KnownOne2, Depth, Q);
944  break;
945  }
946  case Instruction::UDiv: {
947  // For the purposes of computing leading zeros we can conservatively
948  // treat a udiv as a logical right shift by the power of 2 known to
949  // be less than the denominator.
950  computeKnownBits(I->getOperand(0), KnownZero2, KnownOne2, Depth + 1, Q);
951  unsigned LeadZ = KnownZero2.countLeadingOnes();
952 
953  KnownOne2.clearAllBits();
954  KnownZero2.clearAllBits();
955  computeKnownBits(I->getOperand(1), KnownZero2, KnownOne2, Depth + 1, Q);
956  unsigned RHSUnknownLeadingOnes = KnownOne2.countLeadingZeros();
957  if (RHSUnknownLeadingOnes != BitWidth)
958  LeadZ = std::min(BitWidth,
959  LeadZ + BitWidth - RHSUnknownLeadingOnes - 1);
960 
961  KnownZero = APInt::getHighBitsSet(BitWidth, LeadZ);
962  break;
963  }
964  case Instruction::Select: {
965  computeKnownBits(I->getOperand(2), KnownZero, KnownOne, Depth + 1, Q);
966  computeKnownBits(I->getOperand(1), KnownZero2, KnownOne2, Depth + 1, Q);
967 
968  const Value *LHS;
969  const Value *RHS;
970  SelectPatternFlavor SPF = matchSelectPattern(I, LHS, RHS).Flavor;
972  computeKnownBits(RHS, KnownZero, KnownOne, Depth + 1, Q);
973  computeKnownBits(LHS, KnownZero2, KnownOne2, Depth + 1, Q);
974  } else {
975  computeKnownBits(I->getOperand(2), KnownZero, KnownOne, Depth + 1, Q);
976  computeKnownBits(I->getOperand(1), KnownZero2, KnownOne2, Depth + 1, Q);
977  }
978 
979  unsigned MaxHighOnes = 0;
980  unsigned MaxHighZeros = 0;
981  if (SPF == SPF_SMAX) {
982  // If both sides are negative, the result is negative.
983  if (KnownOne[BitWidth - 1] && KnownOne2[BitWidth - 1])
984  // We can derive a lower bound on the result by taking the max of the
985  // leading one bits.
986  MaxHighOnes =
987  std::max(KnownOne.countLeadingOnes(), KnownOne2.countLeadingOnes());
988  // If either side is non-negative, the result is non-negative.
989  else if (KnownZero[BitWidth - 1] || KnownZero2[BitWidth - 1])
990  MaxHighZeros = 1;
991  } else if (SPF == SPF_SMIN) {
992  // If both sides are non-negative, the result is non-negative.
993  if (KnownZero[BitWidth - 1] && KnownZero2[BitWidth - 1])
994  // We can derive an upper bound on the result by taking the max of the
995  // leading zero bits.
996  MaxHighZeros = std::max(KnownZero.countLeadingOnes(),
997  KnownZero2.countLeadingOnes());
998  // If either side is negative, the result is negative.
999  else if (KnownOne[BitWidth - 1] || KnownOne2[BitWidth - 1])
1000  MaxHighOnes = 1;
1001  } else if (SPF == SPF_UMAX) {
1002  // We can derive a lower bound on the result by taking the max of the
1003  // leading one bits.
1004  MaxHighOnes =
1005  std::max(KnownOne.countLeadingOnes(), KnownOne2.countLeadingOnes());
1006  } else if (SPF == SPF_UMIN) {
1007  // We can derive an upper bound on the result by taking the max of the
1008  // leading zero bits.
1009  MaxHighZeros =
1010  std::max(KnownZero.countLeadingOnes(), KnownZero2.countLeadingOnes());
1011  }
1012 
1013  // Only known if known in both the LHS and RHS.
1014  KnownOne &= KnownOne2;
1015  KnownZero &= KnownZero2;
1016  if (MaxHighOnes > 0)
1017  KnownOne |= APInt::getHighBitsSet(BitWidth, MaxHighOnes);
1018  if (MaxHighZeros > 0)
1019  KnownZero |= APInt::getHighBitsSet(BitWidth, MaxHighZeros);
1020  break;
1021  }
1022  case Instruction::FPTrunc:
1023  case Instruction::FPExt:
1024  case Instruction::FPToUI:
1025  case Instruction::FPToSI:
1026  case Instruction::SIToFP:
1027  case Instruction::UIToFP:
1028  break; // Can't work with floating point.
1029  case Instruction::PtrToInt:
1030  case Instruction::IntToPtr:
1031  // Fall through and handle them the same as zext/trunc.
1033  case Instruction::ZExt:
1034  case Instruction::Trunc: {
1035  Type *SrcTy = I->getOperand(0)->getType();
1036 
1037  unsigned SrcBitWidth;
1038  // Note that we handle pointer operands here because of inttoptr/ptrtoint
1039  // which fall through here.
1040  SrcBitWidth = Q.DL.getTypeSizeInBits(SrcTy->getScalarType());
1041 
1042  assert(SrcBitWidth && "SrcBitWidth can't be zero");
1043  KnownZero = KnownZero.zextOrTrunc(SrcBitWidth);
1044  KnownOne = KnownOne.zextOrTrunc(SrcBitWidth);
1045  computeKnownBits(I->getOperand(0), KnownZero, KnownOne, Depth + 1, Q);
1046  KnownZero = KnownZero.zextOrTrunc(BitWidth);
1047  KnownOne = KnownOne.zextOrTrunc(BitWidth);
1048  // Any top bits are known to be zero.
1049  if (BitWidth > SrcBitWidth)
1050  KnownZero |= APInt::getHighBitsSet(BitWidth, BitWidth - SrcBitWidth);
1051  break;
1052  }
1053  case Instruction::BitCast: {
1054  Type *SrcTy = I->getOperand(0)->getType();
1055  if ((SrcTy->isIntegerTy() || SrcTy->isPointerTy()) &&
1056  // TODO: For now, not handling conversions like:
1057  // (bitcast i64 %x to <2 x i32>)
1058  !I->getType()->isVectorTy()) {
1059  computeKnownBits(I->getOperand(0), KnownZero, KnownOne, Depth + 1, Q);
1060  break;
1061  }
1062  break;
1063  }
1064  case Instruction::SExt: {
1065  // Compute the bits in the result that are not present in the input.
1066  unsigned SrcBitWidth = I->getOperand(0)->getType()->getScalarSizeInBits();
1067 
1068  KnownZero = KnownZero.trunc(SrcBitWidth);
1069  KnownOne = KnownOne.trunc(SrcBitWidth);
1070  computeKnownBits(I->getOperand(0), KnownZero, KnownOne, Depth + 1, Q);
1071  KnownZero = KnownZero.zext(BitWidth);
1072  KnownOne = KnownOne.zext(BitWidth);
1073 
1074  // If the sign bit of the input is known set or clear, then we know the
1075  // top bits of the result.
1076  if (KnownZero[SrcBitWidth-1]) // Input sign bit known zero
1077  KnownZero |= APInt::getHighBitsSet(BitWidth, BitWidth - SrcBitWidth);
1078  else if (KnownOne[SrcBitWidth-1]) // Input sign bit known set
1079  KnownOne |= APInt::getHighBitsSet(BitWidth, BitWidth - SrcBitWidth);
1080  break;
1081  }
1082  case Instruction::Shl: {
1083  // (shl X, C1) & C2 == 0 iff (X & C2 >>u C1) == 0
1084  bool NSW = cast<OverflowingBinaryOperator>(I)->hasNoSignedWrap();
1085  auto KZF = [BitWidth, NSW](const APInt &KnownZero, unsigned ShiftAmt) {
1086  APInt KZResult =
1087  (KnownZero << ShiftAmt) |
1088  APInt::getLowBitsSet(BitWidth, ShiftAmt); // Low bits known 0.
1089  // If this shift has "nsw" keyword, then the result is either a poison
1090  // value or has the same sign bit as the first operand.
1091  if (NSW && KnownZero.isNegative())
1092  KZResult.setBit(BitWidth - 1);
1093  return KZResult;
1094  };
1095 
1096  auto KOF = [BitWidth, NSW](const APInt &KnownOne, unsigned ShiftAmt) {
1097  APInt KOResult = KnownOne << ShiftAmt;
1098  if (NSW && KnownOne.isNegative())
1099  KOResult.setBit(BitWidth - 1);
1100  return KOResult;
1101  };
1102 
1103  computeKnownBitsFromShiftOperator(I, KnownZero, KnownOne,
1104  KnownZero2, KnownOne2, Depth, Q, KZF,
1105  KOF);
1106  break;
1107  }
1108  case Instruction::LShr: {
1109  // (ushr X, C1) & C2 == 0 iff (-1 >> C1) & C2 == 0
1110  auto KZF = [BitWidth](const APInt &KnownZero, unsigned ShiftAmt) {
1111  return APIntOps::lshr(KnownZero, ShiftAmt) |
1112  // High bits known zero.
1113  APInt::getHighBitsSet(BitWidth, ShiftAmt);
1114  };
1115 
1116  auto KOF = [BitWidth](const APInt &KnownOne, unsigned ShiftAmt) {
1117  return APIntOps::lshr(KnownOne, ShiftAmt);
1118  };
1119 
1120  computeKnownBitsFromShiftOperator(I, KnownZero, KnownOne,
1121  KnownZero2, KnownOne2, Depth, Q, KZF,
1122  KOF);
1123  break;
1124  }
1125  case Instruction::AShr: {
1126  // (ashr X, C1) & C2 == 0 iff (-1 >> C1) & C2 == 0
1127  auto KZF = [BitWidth](const APInt &KnownZero, unsigned ShiftAmt) {
1128  return APIntOps::ashr(KnownZero, ShiftAmt);
1129  };
1130 
1131  auto KOF = [BitWidth](const APInt &KnownOne, unsigned ShiftAmt) {
1132  return APIntOps::ashr(KnownOne, ShiftAmt);
1133  };
1134 
1135  computeKnownBitsFromShiftOperator(I, KnownZero, KnownOne,
1136  KnownZero2, KnownOne2, Depth, Q, KZF,
1137  KOF);
1138  break;
1139  }
1140  case Instruction::Sub: {
1141  bool NSW = cast<OverflowingBinaryOperator>(I)->hasNoSignedWrap();
1142  computeKnownBitsAddSub(false, I->getOperand(0), I->getOperand(1), NSW,
1143  KnownZero, KnownOne, KnownZero2, KnownOne2, Depth,
1144  Q);
1145  break;
1146  }
1147  case Instruction::Add: {
1148  bool NSW = cast<OverflowingBinaryOperator>(I)->hasNoSignedWrap();
1149  computeKnownBitsAddSub(true, I->getOperand(0), I->getOperand(1), NSW,
1150  KnownZero, KnownOne, KnownZero2, KnownOne2, Depth,
1151  Q);
1152  break;
1153  }
1154  case Instruction::SRem:
1155  if (ConstantInt *Rem = dyn_cast<ConstantInt>(I->getOperand(1))) {
1156  APInt RA = Rem->getValue().abs();
1157  if (RA.isPowerOf2()) {
1158  APInt LowBits = RA - 1;
1159  computeKnownBits(I->getOperand(0), KnownZero2, KnownOne2, Depth + 1,
1160  Q);
1161 
1162  // The low bits of the first operand are unchanged by the srem.
1163  KnownZero = KnownZero2 & LowBits;
1164  KnownOne = KnownOne2 & LowBits;
1165 
1166  // If the first operand is non-negative or has all low bits zero, then
1167  // the upper bits are all zero.
1168  if (KnownZero2[BitWidth-1] || ((KnownZero2 & LowBits) == LowBits))
1169  KnownZero |= ~LowBits;
1170 
1171  // If the first operand is negative and not all low bits are zero, then
1172  // the upper bits are all one.
1173  if (KnownOne2[BitWidth-1] && ((KnownOne2 & LowBits) != 0))
1174  KnownOne |= ~LowBits;
1175 
1176  assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?");
1177  }
1178  }
1179 
1180  // The sign bit is the LHS's sign bit, except when the result of the
1181  // remainder is zero.
1182  if (KnownZero.isNonNegative()) {
1183  APInt LHSKnownZero(BitWidth, 0), LHSKnownOne(BitWidth, 0);
1184  computeKnownBits(I->getOperand(0), LHSKnownZero, LHSKnownOne, Depth + 1,
1185  Q);
1186  // If it's known zero, our sign bit is also zero.
1187  if (LHSKnownZero.isNegative())
1188  KnownZero.setBit(BitWidth - 1);
1189  }
1190 
1191  break;
1192  case Instruction::URem: {
1193  if (ConstantInt *Rem = dyn_cast<ConstantInt>(I->getOperand(1))) {
1194  const APInt &RA = Rem->getValue();
1195  if (RA.isPowerOf2()) {
1196  APInt LowBits = (RA - 1);
1197  computeKnownBits(I->getOperand(0), KnownZero, KnownOne, Depth + 1, Q);
1198  KnownZero |= ~LowBits;
1199  KnownOne &= LowBits;
1200  break;
1201  }
1202  }
1203 
1204  // Since the result is less than or equal to either operand, any leading
1205  // zero bits in either operand must also exist in the result.
1206  computeKnownBits(I->getOperand(0), KnownZero, KnownOne, Depth + 1, Q);
1207  computeKnownBits(I->getOperand(1), KnownZero2, KnownOne2, Depth + 1, Q);
1208 
1209  unsigned Leaders = std::max(KnownZero.countLeadingOnes(),
1210  KnownZero2.countLeadingOnes());
1211  KnownOne.clearAllBits();
1212  KnownZero = APInt::getHighBitsSet(BitWidth, Leaders);
1213  break;
1214  }
1215 
1216  case Instruction::Alloca: {
1217  const AllocaInst *AI = cast<AllocaInst>(I);
1218  unsigned Align = AI->getAlignment();
1219  if (Align == 0)
1220  Align = Q.DL.getABITypeAlignment(AI->getAllocatedType());
1221 
1222  if (Align > 0)
1223  KnownZero = APInt::getLowBitsSet(BitWidth, countTrailingZeros(Align));
1224  break;
1225  }
1226  case Instruction::GetElementPtr: {
1227  // Analyze all of the subscripts of this getelementptr instruction
1228  // to determine if we can prove known low zero bits.
1229  APInt LocalKnownZero(BitWidth, 0), LocalKnownOne(BitWidth, 0);
1230  computeKnownBits(I->getOperand(0), LocalKnownZero, LocalKnownOne, Depth + 1,
1231  Q);
1232  unsigned TrailZ = LocalKnownZero.countTrailingOnes();
1233 
1235  for (unsigned i = 1, e = I->getNumOperands(); i != e; ++i, ++GTI) {
1236  Value *Index = I->getOperand(i);
1237  if (StructType *STy = GTI.getStructTypeOrNull()) {
1238  // Handle struct member offset arithmetic.
1239 
1240  // Handle case when index is vector zeroinitializer
1241  Constant *CIndex = cast<Constant>(Index);
1242  if (CIndex->isZeroValue())
1243  continue;
1244 
1245  if (CIndex->getType()->isVectorTy())
1246  Index = CIndex->getSplatValue();
1247 
1248  unsigned Idx = cast<ConstantInt>(Index)->getZExtValue();
1249  const StructLayout *SL = Q.DL.getStructLayout(STy);
1250  uint64_t Offset = SL->getElementOffset(Idx);
1251  TrailZ = std::min<unsigned>(TrailZ,
1252  countTrailingZeros(Offset));
1253  } else {
1254  // Handle array index arithmetic.
1255  Type *IndexedTy = GTI.getIndexedType();
1256  if (!IndexedTy->isSized()) {
1257  TrailZ = 0;
1258  break;
1259  }
1260  unsigned GEPOpiBits = Index->getType()->getScalarSizeInBits();
1261  uint64_t TypeSize = Q.DL.getTypeAllocSize(IndexedTy);
1262  LocalKnownZero = LocalKnownOne = APInt(GEPOpiBits, 0);
1263  computeKnownBits(Index, LocalKnownZero, LocalKnownOne, Depth + 1, Q);
1264  TrailZ = std::min(TrailZ,
1265  unsigned(countTrailingZeros(TypeSize) +
1266  LocalKnownZero.countTrailingOnes()));
1267  }
1268  }
1269 
1270  KnownZero = APInt::getLowBitsSet(BitWidth, TrailZ);
1271  break;
1272  }
1273  case Instruction::PHI: {
1274  const PHINode *P = cast<PHINode>(I);
1275  // Handle the case of a simple two-predecessor recurrence PHI.
1276  // There's a lot more that could theoretically be done here, but
1277  // this is sufficient to catch some interesting cases.
1278  if (P->getNumIncomingValues() == 2) {
1279  for (unsigned i = 0; i != 2; ++i) {
1280  Value *L = P->getIncomingValue(i);
1281  Value *R = P->getIncomingValue(!i);
1282  Operator *LU = dyn_cast<Operator>(L);
1283  if (!LU)
1284  continue;
1285  unsigned Opcode = LU->getOpcode();
1286  // Check for operations that have the property that if
1287  // both their operands have low zero bits, the result
1288  // will have low zero bits.
1289  if (Opcode == Instruction::Add ||
1290  Opcode == Instruction::Sub ||
1291  Opcode == Instruction::And ||
1292  Opcode == Instruction::Or ||
1293  Opcode == Instruction::Mul) {
1294  Value *LL = LU->getOperand(0);
1295  Value *LR = LU->getOperand(1);
1296  // Find a recurrence.
1297  if (LL == I)
1298  L = LR;
1299  else if (LR == I)
1300  L = LL;
1301  else
1302  break;
1303  // Ok, we have a PHI of the form L op= R. Check for low
1304  // zero bits.
1305  computeKnownBits(R, KnownZero2, KnownOne2, Depth + 1, Q);
1306 
1307  // We need to take the minimum number of known bits
1308  APInt KnownZero3(KnownZero), KnownOne3(KnownOne);
1309  computeKnownBits(L, KnownZero3, KnownOne3, Depth + 1, Q);
1310 
1311  KnownZero = APInt::getLowBitsSet(
1312  BitWidth, std::min(KnownZero2.countTrailingOnes(),
1313  KnownZero3.countTrailingOnes()));
1314 
1316  break;
1317 
1318  auto *OverflowOp = dyn_cast<OverflowingBinaryOperator>(LU);
1319  if (OverflowOp && OverflowOp->hasNoSignedWrap()) {
1320  // If initial value of recurrence is nonnegative, and we are adding
1321  // a nonnegative number with nsw, the result can only be nonnegative
1322  // or poison value regardless of the number of times we execute the
1323  // add in phi recurrence. If initial value is negative and we are
1324  // adding a negative number with nsw, the result can only be
1325  // negative or poison value. Similar arguments apply to sub and mul.
1326  //
1327  // (add non-negative, non-negative) --> non-negative
1328  // (add negative, negative) --> negative
1329  if (Opcode == Instruction::Add) {
1330  if (KnownZero2.isNegative() && KnownZero3.isNegative())
1331  KnownZero.setBit(BitWidth - 1);
1332  else if (KnownOne2.isNegative() && KnownOne3.isNegative())
1333  KnownOne.setBit(BitWidth - 1);
1334  }
1335 
1336  // (sub nsw non-negative, negative) --> non-negative
1337  // (sub nsw negative, non-negative) --> negative
1338  else if (Opcode == Instruction::Sub && LL == I) {
1339  if (KnownZero2.isNegative() && KnownOne3.isNegative())
1340  KnownZero.setBit(BitWidth - 1);
1341  else if (KnownOne2.isNegative() && KnownZero3.isNegative())
1342  KnownOne.setBit(BitWidth - 1);
1343  }
1344 
1345  // (mul nsw non-negative, non-negative) --> non-negative
1346  else if (Opcode == Instruction::Mul && KnownZero2.isNegative() &&
1347  KnownZero3.isNegative())
1348  KnownZero.setBit(BitWidth - 1);
1349  }
1350 
1351  break;
1352  }
1353  }
1354  }
1355 
1356  // Unreachable blocks may have zero-operand PHI nodes.
1357  if (P->getNumIncomingValues() == 0)
1358  break;
1359 
1360  // Otherwise take the unions of the known bit sets of the operands,
1361  // taking conservative care to avoid excessive recursion.
1362  if (Depth < MaxDepth - 1 && !KnownZero && !KnownOne) {
1363  // Skip if every incoming value references to ourself.
1364  if (dyn_cast_or_null<UndefValue>(P->hasConstantValue()))
1365  break;
1366 
1367  KnownZero = APInt::getAllOnesValue(BitWidth);
1368  KnownOne = APInt::getAllOnesValue(BitWidth);
1369  for (Value *IncValue : P->incoming_values()) {
1370  // Skip direct self references.
1371  if (IncValue == P) continue;
1372 
1373  KnownZero2 = APInt(BitWidth, 0);
1374  KnownOne2 = APInt(BitWidth, 0);
1375  // Recurse, but cap the recursion to one level, because we don't
1376  // want to waste time spinning around in loops.
1377  computeKnownBits(IncValue, KnownZero2, KnownOne2, MaxDepth - 1, Q);
1378  KnownZero &= KnownZero2;
1379  KnownOne &= KnownOne2;
1380  // If all bits have been ruled out, there's no need to check
1381  // more operands.
1382  if (!KnownZero && !KnownOne)
1383  break;
1384  }
1385  }
1386  break;
1387  }
1388  case Instruction::Call:
1389  case Instruction::Invoke:
1390  // If range metadata is attached to this call, set known bits from that,
1391  // and then intersect with known bits based on other properties of the
1392  // function.
1393  if (MDNode *MD = cast<Instruction>(I)->getMetadata(LLVMContext::MD_range))
1394  computeKnownBitsFromRangeMetadata(*MD, KnownZero, KnownOne);
1395  if (const Value *RV = ImmutableCallSite(I).getReturnedArgOperand()) {
1396  computeKnownBits(RV, KnownZero2, KnownOne2, Depth + 1, Q);
1397  KnownZero |= KnownZero2;
1398  KnownOne |= KnownOne2;
1399  }
1400  if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(I)) {
1401  switch (II->getIntrinsicID()) {
1402  default: break;
1403  case Intrinsic::bswap:
1404  computeKnownBits(I->getOperand(0), KnownZero2, KnownOne2, Depth + 1, Q);
1405  KnownZero |= KnownZero2.byteSwap();
1406  KnownOne |= KnownOne2.byteSwap();
1407  break;
1408  case Intrinsic::ctlz:
1409  case Intrinsic::cttz: {
1410  unsigned LowBits = Log2_32(BitWidth)+1;
1411  // If this call is undefined for 0, the result will be less than 2^n.
1412  if (II->getArgOperand(1) == ConstantInt::getTrue(II->getContext()))
1413  LowBits -= 1;
1414  KnownZero |= APInt::getHighBitsSet(BitWidth, BitWidth - LowBits);
1415  break;
1416  }
1417  case Intrinsic::ctpop: {
1418  computeKnownBits(I->getOperand(0), KnownZero2, KnownOne2, Depth + 1, Q);
1419  // We can bound the space the count needs. Also, bits known to be zero
1420  // can't contribute to the population.
1421  unsigned BitsPossiblySet = BitWidth - KnownZero2.countPopulation();
1422  unsigned LeadingZeros =
1423  APInt(BitWidth, BitsPossiblySet).countLeadingZeros();
1424  assert(LeadingZeros <= BitWidth);
1425  KnownZero |= APInt::getHighBitsSet(BitWidth, LeadingZeros);
1426  KnownOne &= ~KnownZero;
1427  // TODO: we could bound KnownOne using the lower bound on the number
1428  // of bits which might be set provided by popcnt KnownOne2.
1429  break;
1430  }
1431  case Intrinsic::x86_sse42_crc32_64_64:
1432  KnownZero |= APInt::getHighBitsSet(64, 32);
1433  break;
1434  }
1435  }
1436  break;
1437  case Instruction::ExtractElement:
1438  // Look through extract element. At the moment we keep this simple and skip
1439  // tracking the specific element. But at least we might find information
1440  // valid for all elements of the vector (for example if vector is sign
1441  // extended, shifted, etc).
1442  computeKnownBits(I->getOperand(0), KnownZero, KnownOne, Depth + 1, Q);
1443  break;
1444  case Instruction::ExtractValue:
1445  if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(I->getOperand(0))) {
1446  const ExtractValueInst *EVI = cast<ExtractValueInst>(I);
1447  if (EVI->getNumIndices() != 1) break;
1448  if (EVI->getIndices()[0] == 0) {
1449  switch (II->getIntrinsicID()) {
1450  default: break;
1451  case Intrinsic::uadd_with_overflow:
1452  case Intrinsic::sadd_with_overflow:
1453  computeKnownBitsAddSub(true, II->getArgOperand(0),
1454  II->getArgOperand(1), false, KnownZero,
1455  KnownOne, KnownZero2, KnownOne2, Depth, Q);
1456  break;
1457  case Intrinsic::usub_with_overflow:
1458  case Intrinsic::ssub_with_overflow:
1459  computeKnownBitsAddSub(false, II->getArgOperand(0),
1460  II->getArgOperand(1), false, KnownZero,
1461  KnownOne, KnownZero2, KnownOne2, Depth, Q);
1462  break;
1463  case Intrinsic::umul_with_overflow:
1464  case Intrinsic::smul_with_overflow:
1465  computeKnownBitsMul(II->getArgOperand(0), II->getArgOperand(1), false,
1466  KnownZero, KnownOne, KnownZero2, KnownOne2, Depth,
1467  Q);
1468  break;
1469  }
1470  }
1471  }
1472  }
1473 }
1474 
1475 /// Determine which bits of V are known to be either zero or one and return
1476 /// them in the KnownZero/KnownOne bit sets.
1477 ///
1478 /// NOTE: we cannot consider 'undef' to be "IsZero" here. The problem is that
1479 /// we cannot optimize based on the assumption that it is zero without changing
1480 /// it to be an explicit zero. If we don't change it to zero, other code could
1481 /// optimized based on the contradictory assumption that it is non-zero.
1482 /// Because instcombine aggressively folds operations with undef args anyway,
1483 /// this won't lose us code quality.
1484 ///
1485 /// This function is defined on values with integer type, values with pointer
1486 /// type, and vectors of integers. In the case
1487 /// where V is a vector, known zero, and known one values are the
1488 /// same width as the vector element, and the bit is set only if it is true
1489 /// for all of the elements in the vector.
1490 void computeKnownBits(const Value *V, APInt &KnownZero, APInt &KnownOne,
1491  unsigned Depth, const Query &Q) {
1492  assert(V && "No Value?");
1493  assert(Depth <= MaxDepth && "Limit Search Depth");
1494  unsigned BitWidth = KnownZero.getBitWidth();
1495 
1496  assert((V->getType()->isIntOrIntVectorTy() ||
1497  V->getType()->getScalarType()->isPointerTy()) &&
1498  "Not integer or pointer type!");
1499  assert((Q.DL.getTypeSizeInBits(V->getType()->getScalarType()) == BitWidth) &&
1500  (!V->getType()->isIntOrIntVectorTy() ||
1501  V->getType()->getScalarSizeInBits() == BitWidth) &&
1502  KnownZero.getBitWidth() == BitWidth &&
1503  KnownOne.getBitWidth() == BitWidth &&
1504  "V, KnownOne and KnownZero should have same BitWidth");
1505 
1506  const APInt *C;
1507  if (match(V, m_APInt(C))) {
1508  // We know all of the bits for a scalar constant or a splat vector constant!
1509  KnownOne = *C;
1510  KnownZero = ~KnownOne;
1511  return;
1512  }
1513  // Null and aggregate-zero are all-zeros.
1514  if (isa<ConstantPointerNull>(V) || isa<ConstantAggregateZero>(V)) {
1515  KnownOne.clearAllBits();
1516  KnownZero = APInt::getAllOnesValue(BitWidth);
1517  return;
1518  }
1519  // Handle a constant vector by taking the intersection of the known bits of
1520  // each element.
1521  if (const ConstantDataSequential *CDS = dyn_cast<ConstantDataSequential>(V)) {
1522  // We know that CDS must be a vector of integers. Take the intersection of
1523  // each element.
1524  KnownZero.setAllBits(); KnownOne.setAllBits();
1525  APInt Elt(KnownZero.getBitWidth(), 0);
1526  for (unsigned i = 0, e = CDS->getNumElements(); i != e; ++i) {
1527  Elt = CDS->getElementAsInteger(i);
1528  KnownZero &= ~Elt;
1529  KnownOne &= Elt;
1530  }
1531  return;
1532  }
1533 
1534  if (const auto *CV = dyn_cast<ConstantVector>(V)) {
1535  // We know that CV must be a vector of integers. Take the intersection of
1536  // each element.
1537  KnownZero.setAllBits(); KnownOne.setAllBits();
1538  APInt Elt(KnownZero.getBitWidth(), 0);
1539  for (unsigned i = 0, e = CV->getNumOperands(); i != e; ++i) {
1540  Constant *Element = CV->getAggregateElement(i);
1541  auto *ElementCI = dyn_cast_or_null<ConstantInt>(Element);
1542  if (!ElementCI) {
1543  KnownZero.clearAllBits();
1544  KnownOne.clearAllBits();
1545  return;
1546  }
1547  Elt = ElementCI->getValue();
1548  KnownZero &= ~Elt;
1549  KnownOne &= Elt;
1550  }
1551  return;
1552  }
1553 
1554  // Start out not knowing anything.
1555  KnownZero.clearAllBits(); KnownOne.clearAllBits();
1556 
1557  // We can't imply anything about undefs.
1558  if (isa<UndefValue>(V))
1559  return;
1560 
1561  // There's no point in looking through other users of ConstantData for
1562  // assumptions. Confirm that we've handled them all.
1563  assert(!isa<ConstantData>(V) && "Unhandled constant data!");
1564 
1565  // Limit search depth.
1566  // All recursive calls that increase depth must come after this.
1567  if (Depth == MaxDepth)
1568  return;
1569 
1570  // A weak GlobalAlias is totally unknown. A non-weak GlobalAlias has
1571  // the bits of its aliasee.
1572  if (const GlobalAlias *GA = dyn_cast<GlobalAlias>(V)) {
1573  if (!GA->isInterposable())
1574  computeKnownBits(GA->getAliasee(), KnownZero, KnownOne, Depth + 1, Q);
1575  return;
1576  }
1577 
1578  if (const Operator *I = dyn_cast<Operator>(V))
1579  computeKnownBitsFromOperator(I, KnownZero, KnownOne, Depth, Q);
1580 
1581  // Aligned pointers have trailing zeros - refine KnownZero set
1582  if (V->getType()->isPointerTy()) {
1583  unsigned Align = V->getPointerAlignment(Q.DL);
1584  if (Align)
1585  KnownZero |= APInt::getLowBitsSet(BitWidth, countTrailingZeros(Align));
1586  }
1587 
1588  // computeKnownBitsFromAssume strictly refines KnownZero and
1589  // KnownOne. Therefore, we run them after computeKnownBitsFromOperator.
1590 
1591  // Check whether a nearby assume intrinsic can determine some known bits.
1592  computeKnownBitsFromAssume(V, KnownZero, KnownOne, Depth, Q);
1593 
1594  assert((KnownZero & KnownOne) == 0 && "Bits known to be one AND zero?");
1595 }
1596 
1597 /// Determine whether the sign bit is known to be zero or one.
1598 /// Convenience wrapper around computeKnownBits.
1599 void ComputeSignBit(const Value *V, bool &KnownZero, bool &KnownOne,
1600  unsigned Depth, const Query &Q) {
1601  unsigned BitWidth = getBitWidth(V->getType(), Q.DL);
1602  if (!BitWidth) {
1603  KnownZero = false;
1604  KnownOne = false;
1605  return;
1606  }
1607  APInt ZeroBits(BitWidth, 0);
1608  APInt OneBits(BitWidth, 0);
1609  computeKnownBits(V, ZeroBits, OneBits, Depth, Q);
1610  KnownOne = OneBits[BitWidth - 1];
1611  KnownZero = ZeroBits[BitWidth - 1];
1612 }
1613 
1614 /// Return true if the given value is known to have exactly one
1615 /// bit set when defined. For vectors return true if every element is known to
1616 /// be a power of two when defined. Supports values with integer or pointer
1617 /// types and vectors of integers.
1618 bool isKnownToBeAPowerOfTwo(const Value *V, bool OrZero, unsigned Depth,
1619  const Query &Q) {
1620  if (const Constant *C = dyn_cast<Constant>(V)) {
1621  if (C->isNullValue())
1622  return OrZero;
1623 
1624  const APInt *ConstIntOrConstSplatInt;
1625  if (match(C, m_APInt(ConstIntOrConstSplatInt)))
1626  return ConstIntOrConstSplatInt->isPowerOf2();
1627  }
1628 
1629  // 1 << X is clearly a power of two if the one is not shifted off the end. If
1630  // it is shifted off the end then the result is undefined.
1631  if (match(V, m_Shl(m_One(), m_Value())))
1632  return true;
1633 
1634  // (signbit) >>l X is clearly a power of two if the one is not shifted off the
1635  // bottom. If it is shifted off the bottom then the result is undefined.
1636  if (match(V, m_LShr(m_SignBit(), m_Value())))
1637  return true;
1638 
1639  // The remaining tests are all recursive, so bail out if we hit the limit.
1640  if (Depth++ == MaxDepth)
1641  return false;
1642 
1643  Value *X = nullptr, *Y = nullptr;
1644  // A shift left or a logical shift right of a power of two is a power of two
1645  // or zero.
1646  if (OrZero && (match(V, m_Shl(m_Value(X), m_Value())) ||
1647  match(V, m_LShr(m_Value(X), m_Value()))))
1648  return isKnownToBeAPowerOfTwo(X, /*OrZero*/ true, Depth, Q);
1649 
1650  if (const ZExtInst *ZI = dyn_cast<ZExtInst>(V))
1651  return isKnownToBeAPowerOfTwo(ZI->getOperand(0), OrZero, Depth, Q);
1652 
1653  if (const SelectInst *SI = dyn_cast<SelectInst>(V))
1654  return isKnownToBeAPowerOfTwo(SI->getTrueValue(), OrZero, Depth, Q) &&
1655  isKnownToBeAPowerOfTwo(SI->getFalseValue(), OrZero, Depth, Q);
1656 
1657  if (OrZero && match(V, m_And(m_Value(X), m_Value(Y)))) {
1658  // A power of two and'd with anything is a power of two or zero.
1659  if (isKnownToBeAPowerOfTwo(X, /*OrZero*/ true, Depth, Q) ||
1660  isKnownToBeAPowerOfTwo(Y, /*OrZero*/ true, Depth, Q))
1661  return true;
1662  // X & (-X) is always a power of two or zero.
1663  if (match(X, m_Neg(m_Specific(Y))) || match(Y, m_Neg(m_Specific(X))))
1664  return true;
1665  return false;
1666  }
1667 
1668  // Adding a power-of-two or zero to the same power-of-two or zero yields
1669  // either the original power-of-two, a larger power-of-two or zero.
1670  if (match(V, m_Add(m_Value(X), m_Value(Y)))) {
1671  const OverflowingBinaryOperator *VOBO = cast<OverflowingBinaryOperator>(V);
1672  if (OrZero || VOBO->hasNoUnsignedWrap() || VOBO->hasNoSignedWrap()) {
1673  if (match(X, m_And(m_Specific(Y), m_Value())) ||
1674  match(X, m_And(m_Value(), m_Specific(Y))))
1675  if (isKnownToBeAPowerOfTwo(Y, OrZero, Depth, Q))
1676  return true;
1677  if (match(Y, m_And(m_Specific(X), m_Value())) ||
1678  match(Y, m_And(m_Value(), m_Specific(X))))
1679  if (isKnownToBeAPowerOfTwo(X, OrZero, Depth, Q))
1680  return true;
1681 
1682  unsigned BitWidth = V->getType()->getScalarSizeInBits();
1683  APInt LHSZeroBits(BitWidth, 0), LHSOneBits(BitWidth, 0);
1684  computeKnownBits(X, LHSZeroBits, LHSOneBits, Depth, Q);
1685 
1686  APInt RHSZeroBits(BitWidth, 0), RHSOneBits(BitWidth, 0);
1687  computeKnownBits(Y, RHSZeroBits, RHSOneBits, Depth, Q);
1688  // If i8 V is a power of two or zero:
1689  // ZeroBits: 1 1 1 0 1 1 1 1
1690  // ~ZeroBits: 0 0 0 1 0 0 0 0
1691  if ((~(LHSZeroBits & RHSZeroBits)).isPowerOf2())
1692  // If OrZero isn't set, we cannot give back a zero result.
1693  // Make sure either the LHS or RHS has a bit set.
1694  if (OrZero || RHSOneBits.getBoolValue() || LHSOneBits.getBoolValue())
1695  return true;
1696  }
1697  }
1698 
1699  // An exact divide or right shift can only shift off zero bits, so the result
1700  // is a power of two only if the first operand is a power of two and not
1701  // copying a sign bit (sdiv int_min, 2).
1702  if (match(V, m_Exact(m_LShr(m_Value(), m_Value()))) ||
1703  match(V, m_Exact(m_UDiv(m_Value(), m_Value())))) {
1704  return isKnownToBeAPowerOfTwo(cast<Operator>(V)->getOperand(0), OrZero,
1705  Depth, Q);
1706  }
1707 
1708  return false;
1709 }
1710 
1711 /// \brief Test whether a GEP's result is known to be non-null.
1712 ///
1713 /// Uses properties inherent in a GEP to try to determine whether it is known
1714 /// to be non-null.
1715 ///
1716 /// Currently this routine does not support vector GEPs.
1717 static bool isGEPKnownNonNull(const GEPOperator *GEP, unsigned Depth,
1718  const Query &Q) {
1719  if (!GEP->isInBounds() || GEP->getPointerAddressSpace() != 0)
1720  return false;
1721 
1722  // FIXME: Support vector-GEPs.
1723  assert(GEP->getType()->isPointerTy() && "We only support plain pointer GEP");
1724 
1725  // If the base pointer is non-null, we cannot walk to a null address with an
1726  // inbounds GEP in address space zero.
1727  if (isKnownNonZero(GEP->getPointerOperand(), Depth, Q))
1728  return true;
1729 
1730  // Walk the GEP operands and see if any operand introduces a non-zero offset.
1731  // If so, then the GEP cannot produce a null pointer, as doing so would
1732  // inherently violate the inbounds contract within address space zero.
1733  for (gep_type_iterator GTI = gep_type_begin(GEP), GTE = gep_type_end(GEP);
1734  GTI != GTE; ++GTI) {
1735  // Struct types are easy -- they must always be indexed by a constant.
1736  if (StructType *STy = GTI.getStructTypeOrNull()) {
1737  ConstantInt *OpC = cast<ConstantInt>(GTI.getOperand());
1738  unsigned ElementIdx = OpC->getZExtValue();
1739  const StructLayout *SL = Q.DL.getStructLayout(STy);
1740  uint64_t ElementOffset = SL->getElementOffset(ElementIdx);
1741  if (ElementOffset > 0)
1742  return true;
1743  continue;
1744  }
1745 
1746  // If we have a zero-sized type, the index doesn't matter. Keep looping.
1747  if (Q.DL.getTypeAllocSize(GTI.getIndexedType()) == 0)
1748  continue;
1749 
1750  // Fast path the constant operand case both for efficiency and so we don't
1751  // increment Depth when just zipping down an all-constant GEP.
1752  if (ConstantInt *OpC = dyn_cast<ConstantInt>(GTI.getOperand())) {
1753  if (!OpC->isZero())
1754  return true;
1755  continue;
1756  }
1757 
1758  // We post-increment Depth here because while isKnownNonZero increments it
1759  // as well, when we pop back up that increment won't persist. We don't want
1760  // to recurse 10k times just because we have 10k GEP operands. We don't
1761  // bail completely out because we want to handle constant GEPs regardless
1762  // of depth.
1763  if (Depth++ >= MaxDepth)
1764  continue;
1765 
1766  if (isKnownNonZero(GTI.getOperand(), Depth, Q))
1767  return true;
1768  }
1769 
1770  return false;
1771 }
1772 
1773 /// Does the 'Range' metadata (which must be a valid MD_range operand list)
1774 /// ensure that the value it's attached to is never Value? 'RangeType' is
1775 /// is the type of the value described by the range.
1776 static bool rangeMetadataExcludesValue(const MDNode* Ranges, const APInt& Value) {
1777  const unsigned NumRanges = Ranges->getNumOperands() / 2;
1778  assert(NumRanges >= 1);
1779  for (unsigned i = 0; i < NumRanges; ++i) {
1780  ConstantInt *Lower =
1781  mdconst::extract<ConstantInt>(Ranges->getOperand(2 * i + 0));
1782  ConstantInt *Upper =
1783  mdconst::extract<ConstantInt>(Ranges->getOperand(2 * i + 1));
1784  ConstantRange Range(Lower->getValue(), Upper->getValue());
1785  if (Range.contains(Value))
1786  return false;
1787  }
1788  return true;
1789 }
1790 
1791 /// Return true if the given value is known to be non-zero when defined.
1792 /// For vectors return true if every element is known to be non-zero when
1793 /// defined. Supports values with integer or pointer type and vectors of
1794 /// integers.
1795 bool isKnownNonZero(const Value *V, unsigned Depth, const Query &Q) {
1796  if (auto *C = dyn_cast<Constant>(V)) {
1797  if (C->isNullValue())
1798  return false;
1799  if (isa<ConstantInt>(C))
1800  // Must be non-zero due to null test above.
1801  return true;
1802 
1803  // For constant vectors, check that all elements are undefined or known
1804  // non-zero to determine that the whole vector is known non-zero.
1805  if (auto *VecTy = dyn_cast<VectorType>(C->getType())) {
1806  for (unsigned i = 0, e = VecTy->getNumElements(); i != e; ++i) {
1807  Constant *Elt = C->getAggregateElement(i);
1808  if (!Elt || Elt->isNullValue())
1809  return false;
1810  if (!isa<UndefValue>(Elt) && !isa<ConstantInt>(Elt))
1811  return false;
1812  }
1813  return true;
1814  }
1815 
1816  return false;
1817  }
1818 
1819  if (auto *I = dyn_cast<Instruction>(V)) {
1820  if (MDNode *Ranges = I->getMetadata(LLVMContext::MD_range)) {
1821  // If the possible ranges don't contain zero, then the value is
1822  // definitely non-zero.
1823  if (auto *Ty = dyn_cast<IntegerType>(V->getType())) {
1824  const APInt ZeroValue(Ty->getBitWidth(), 0);
1825  if (rangeMetadataExcludesValue(Ranges, ZeroValue))
1826  return true;
1827  }
1828  }
1829  }
1830 
1831  // The remaining tests are all recursive, so bail out if we hit the limit.
1832  if (Depth++ >= MaxDepth)
1833  return false;
1834 
1835  // Check for pointer simplifications.
1836  if (V->getType()->isPointerTy()) {
1837  if (isKnownNonNull(V))
1838  return true;
1839  if (const GEPOperator *GEP = dyn_cast<GEPOperator>(V))
1840  if (isGEPKnownNonNull(GEP, Depth, Q))
1841  return true;
1842  }
1843 
1844  unsigned BitWidth = getBitWidth(V->getType()->getScalarType(), Q.DL);
1845 
1846  // X | Y != 0 if X != 0 or Y != 0.
1847  Value *X = nullptr, *Y = nullptr;
1848  if (match(V, m_Or(m_Value(X), m_Value(Y))))
1849  return isKnownNonZero(X, Depth, Q) || isKnownNonZero(Y, Depth, Q);
1850 
1851  // ext X != 0 if X != 0.
1852  if (isa<SExtInst>(V) || isa<ZExtInst>(V))
1853  return isKnownNonZero(cast<Instruction>(V)->getOperand(0), Depth, Q);
1854 
1855  // shl X, Y != 0 if X is odd. Note that the value of the shift is undefined
1856  // if the lowest bit is shifted off the end.
1857  if (BitWidth && match(V, m_Shl(m_Value(X), m_Value(Y)))) {
1858  // shl nuw can't remove any non-zero bits.
1859  const OverflowingBinaryOperator *BO = cast<OverflowingBinaryOperator>(V);
1860  if (BO->hasNoUnsignedWrap())
1861  return isKnownNonZero(X, Depth, Q);
1862 
1863  APInt KnownZero(BitWidth, 0);
1864  APInt KnownOne(BitWidth, 0);
1865  computeKnownBits(X, KnownZero, KnownOne, Depth, Q);
1866  if (KnownOne[0])
1867  return true;
1868  }
1869  // shr X, Y != 0 if X is negative. Note that the value of the shift is not
1870  // defined if the sign bit is shifted off the end.
1871  else if (match(V, m_Shr(m_Value(X), m_Value(Y)))) {
1872  // shr exact can only shift out zero bits.
1873  const PossiblyExactOperator *BO = cast<PossiblyExactOperator>(V);
1874  if (BO->isExact())
1875  return isKnownNonZero(X, Depth, Q);
1876 
1877  bool XKnownNonNegative, XKnownNegative;
1878  ComputeSignBit(X, XKnownNonNegative, XKnownNegative, Depth, Q);
1879  if (XKnownNegative)
1880  return true;
1881 
1882  // If the shifter operand is a constant, and all of the bits shifted
1883  // out are known to be zero, and X is known non-zero then at least one
1884  // non-zero bit must remain.
1885  if (ConstantInt *Shift = dyn_cast<ConstantInt>(Y)) {
1886  APInt KnownZero(BitWidth, 0);
1887  APInt KnownOne(BitWidth, 0);
1888  computeKnownBits(X, KnownZero, KnownOne, Depth, Q);
1889 
1890  auto ShiftVal = Shift->getLimitedValue(BitWidth - 1);
1891  // Is there a known one in the portion not shifted out?
1892  if (KnownOne.countLeadingZeros() < BitWidth - ShiftVal)
1893  return true;
1894  // Are all the bits to be shifted out known zero?
1895  if (KnownZero.countTrailingOnes() >= ShiftVal)
1896  return isKnownNonZero(X, Depth, Q);
1897  }
1898  }
1899  // div exact can only produce a zero if the dividend is zero.
1900  else if (match(V, m_Exact(m_IDiv(m_Value(X), m_Value())))) {
1901  return isKnownNonZero(X, Depth, Q);
1902  }
1903  // X + Y.
1904  else if (match(V, m_Add(m_Value(X), m_Value(Y)))) {
1905  bool XKnownNonNegative, XKnownNegative;
1906  bool YKnownNonNegative, YKnownNegative;
1907  ComputeSignBit(X, XKnownNonNegative, XKnownNegative, Depth, Q);
1908  ComputeSignBit(Y, YKnownNonNegative, YKnownNegative, Depth, Q);
1909 
1910  // If X and Y are both non-negative (as signed values) then their sum is not
1911  // zero unless both X and Y are zero.
1912  if (XKnownNonNegative && YKnownNonNegative)
1913  if (isKnownNonZero(X, Depth, Q) || isKnownNonZero(Y, Depth, Q))
1914  return true;
1915 
1916  // If X and Y are both negative (as signed values) then their sum is not
1917  // zero unless both X and Y equal INT_MIN.
1918  if (BitWidth && XKnownNegative && YKnownNegative) {
1919  APInt KnownZero(BitWidth, 0);
1920  APInt KnownOne(BitWidth, 0);
1921  APInt Mask = APInt::getSignedMaxValue(BitWidth);
1922  // The sign bit of X is set. If some other bit is set then X is not equal
1923  // to INT_MIN.
1924  computeKnownBits(X, KnownZero, KnownOne, Depth, Q);
1925  if ((KnownOne & Mask) != 0)
1926  return true;
1927  // The sign bit of Y is set. If some other bit is set then Y is not equal
1928  // to INT_MIN.
1929  computeKnownBits(Y, KnownZero, KnownOne, Depth, Q);
1930  if ((KnownOne & Mask) != 0)
1931  return true;
1932  }
1933 
1934  // The sum of a non-negative number and a power of two is not zero.
1935  if (XKnownNonNegative &&
1936  isKnownToBeAPowerOfTwo(Y, /*OrZero*/ false, Depth, Q))
1937  return true;
1938  if (YKnownNonNegative &&
1939  isKnownToBeAPowerOfTwo(X, /*OrZero*/ false, Depth, Q))
1940  return true;
1941  }
1942  // X * Y.
1943  else if (match(V, m_Mul(m_Value(X), m_Value(Y)))) {
1944  const OverflowingBinaryOperator *BO = cast<OverflowingBinaryOperator>(V);
1945  // If X and Y are non-zero then so is X * Y as long as the multiplication
1946  // does not overflow.
1947  if ((BO->hasNoSignedWrap() || BO->hasNoUnsignedWrap()) &&
1948  isKnownNonZero(X, Depth, Q) && isKnownNonZero(Y, Depth, Q))
1949  return true;
1950  }
1951  // (C ? X : Y) != 0 if X != 0 and Y != 0.
1952  else if (const SelectInst *SI = dyn_cast<SelectInst>(V)) {
1953  if (isKnownNonZero(SI->getTrueValue(), Depth, Q) &&
1954  isKnownNonZero(SI->getFalseValue(), Depth, Q))
1955  return true;
1956  }
1957  // PHI
1958  else if (const PHINode *PN = dyn_cast<PHINode>(V)) {
1959  // Try and detect a recurrence that monotonically increases from a
1960  // starting value, as these are common as induction variables.
1961  if (PN->getNumIncomingValues() == 2) {
1962  Value *Start = PN->getIncomingValue(0);
1963  Value *Induction = PN->getIncomingValue(1);
1964  if (isa<ConstantInt>(Induction) && !isa<ConstantInt>(Start))
1965  std::swap(Start, Induction);
1966  if (ConstantInt *C = dyn_cast<ConstantInt>(Start)) {
1967  if (!C->isZero() && !C->isNegative()) {
1968  ConstantInt *X;
1969  if ((match(Induction, m_NSWAdd(m_Specific(PN), m_ConstantInt(X))) ||
1970  match(Induction, m_NUWAdd(m_Specific(PN), m_ConstantInt(X)))) &&
1971  !X->isNegative())
1972  return true;
1973  }
1974  }
1975  }
1976  // Check if all incoming values are non-zero constant.
1977  bool AllNonZeroConstants = all_of(PN->operands(), [](Value *V) {
1978  return isa<ConstantInt>(V) && !cast<ConstantInt>(V)->isZeroValue();
1979  });
1980  if (AllNonZeroConstants)
1981  return true;
1982  }
1983 
1984  if (!BitWidth) return false;
1985  APInt KnownZero(BitWidth, 0);
1986  APInt KnownOne(BitWidth, 0);
1987  computeKnownBits(V, KnownZero, KnownOne, Depth, Q);
1988  return KnownOne != 0;
1989 }
1990 
1991 /// Return true if V2 == V1 + X, where X is known non-zero.
1992 static bool isAddOfNonZero(const Value *V1, const Value *V2, const Query &Q) {
1993  const BinaryOperator *BO = dyn_cast<BinaryOperator>(V1);
1994  if (!BO || BO->getOpcode() != Instruction::Add)
1995  return false;
1996  Value *Op = nullptr;
1997  if (V2 == BO->getOperand(0))
1998  Op = BO->getOperand(1);
1999  else if (V2 == BO->getOperand(1))
2000  Op = BO->getOperand(0);
2001  else
2002  return false;
2003  return isKnownNonZero(Op, 0, Q);
2004 }
2005 
2006 /// Return true if it is known that V1 != V2.
2007 static bool isKnownNonEqual(const Value *V1, const Value *V2, const Query &Q) {
2008  if (V1->getType()->isVectorTy() || V1 == V2)
2009  return false;
2010  if (V1->getType() != V2->getType())
2011  // We can't look through casts yet.
2012  return false;
2013  if (isAddOfNonZero(V1, V2, Q) || isAddOfNonZero(V2, V1, Q))
2014  return true;
2015 
2016  if (IntegerType *Ty = dyn_cast<IntegerType>(V1->getType())) {
2017  // Are any known bits in V1 contradictory to known bits in V2? If V1
2018  // has a known zero where V2 has a known one, they must not be equal.
2019  auto BitWidth = Ty->getBitWidth();
2020  APInt KnownZero1(BitWidth, 0);
2021  APInt KnownOne1(BitWidth, 0);
2022  computeKnownBits(V1, KnownZero1, KnownOne1, 0, Q);
2023  APInt KnownZero2(BitWidth, 0);
2024  APInt KnownOne2(BitWidth, 0);
2025  computeKnownBits(V2, KnownZero2, KnownOne2, 0, Q);
2026 
2027  auto OppositeBits = (KnownZero1 & KnownOne2) | (KnownZero2 & KnownOne1);
2028  if (OppositeBits.getBoolValue())
2029  return true;
2030  }
2031  return false;
2032 }
2033 
2034 /// Return true if 'V & Mask' is known to be zero. We use this predicate to
2035 /// simplify operations downstream. Mask is known to be zero for bits that V
2036 /// cannot have.
2037 ///
2038 /// This function is defined on values with integer type, values with pointer
2039 /// type, and vectors of integers. In the case
2040 /// where V is a vector, the mask, known zero, and known one values are the
2041 /// same width as the vector element, and the bit is set only if it is true
2042 /// for all of the elements in the vector.
2043 bool MaskedValueIsZero(const Value *V, const APInt &Mask, unsigned Depth,
2044  const Query &Q) {
2045  APInt KnownZero(Mask.getBitWidth(), 0), KnownOne(Mask.getBitWidth(), 0);
2046  computeKnownBits(V, KnownZero, KnownOne, Depth, Q);
2047  return (KnownZero & Mask) == Mask;
2048 }
2049 
2050 /// For vector constants, loop over the elements and find the constant with the
2051 /// minimum number of sign bits. Return 0 if the value is not a vector constant
2052 /// or if any element was not analyzed; otherwise, return the count for the
2053 /// element with the minimum number of sign bits.
2054 static unsigned computeNumSignBitsVectorConstant(const Value *V,
2055  unsigned TyBits) {
2056  const auto *CV = dyn_cast<Constant>(V);
2057  if (!CV || !CV->getType()->isVectorTy())
2058  return 0;
2059 
2060  unsigned MinSignBits = TyBits;
2061  unsigned NumElts = CV->getType()->getVectorNumElements();
2062  for (unsigned i = 0; i != NumElts; ++i) {
2063  // If we find a non-ConstantInt, bail out.
2064  auto *Elt = dyn_cast_or_null<ConstantInt>(CV->getAggregateElement(i));
2065  if (!Elt)
2066  return 0;
2067 
2068  // If the sign bit is 1, flip the bits, so we always count leading zeros.
2069  APInt EltVal = Elt->getValue();
2070  if (EltVal.isNegative())
2071  EltVal = ~EltVal;
2072  MinSignBits = std::min(MinSignBits, EltVal.countLeadingZeros());
2073  }
2074 
2075  return MinSignBits;
2076 }
2077 
2078 /// Return the number of times the sign bit of the register is replicated into
2079 /// the other bits. We know that at least 1 bit is always equal to the sign bit
2080 /// (itself), but other cases can give us information. For example, immediately
2081 /// after an "ashr X, 2", we know that the top 3 bits are all equal to each
2082 /// other, so we return 3. For vectors, return the number of sign bits for the
2083 /// vector element with the mininum number of known sign bits.
2084 unsigned ComputeNumSignBits(const Value *V, unsigned Depth, const Query &Q) {
2085  unsigned TyBits = Q.DL.getTypeSizeInBits(V->getType()->getScalarType());
2086  unsigned Tmp, Tmp2;
2087  unsigned FirstAnswer = 1;
2088 
2089  // Note that ConstantInt is handled by the general computeKnownBits case
2090  // below.
2091 
2092  if (Depth == MaxDepth)
2093  return 1; // Limit search depth.
2094 
2095  const Operator *U = dyn_cast<Operator>(V);
2096  switch (Operator::getOpcode(V)) {
2097  default: break;
2098  case Instruction::SExt:
2099  Tmp = TyBits - U->getOperand(0)->getType()->getScalarSizeInBits();
2100  return ComputeNumSignBits(U->getOperand(0), Depth + 1, Q) + Tmp;
2101 
2102  case Instruction::SDiv: {
2103  const APInt *Denominator;
2104  // sdiv X, C -> adds log(C) sign bits.
2105  if (match(U->getOperand(1), m_APInt(Denominator))) {
2106 
2107  // Ignore non-positive denominator.
2108  if (!Denominator->isStrictlyPositive())
2109  break;
2110 
2111  // Calculate the incoming numerator bits.
2112  unsigned NumBits = ComputeNumSignBits(U->getOperand(0), Depth + 1, Q);
2113 
2114  // Add floor(log(C)) bits to the numerator bits.
2115  return std::min(TyBits, NumBits + Denominator->logBase2());
2116  }
2117  break;
2118  }
2119 
2120  case Instruction::SRem: {
2121  const APInt *Denominator;
2122  // srem X, C -> we know that the result is within [-C+1,C) when C is a
2123  // positive constant. This let us put a lower bound on the number of sign
2124  // bits.
2125  if (match(U->getOperand(1), m_APInt(Denominator))) {
2126 
2127  // Ignore non-positive denominator.
2128  if (!Denominator->isStrictlyPositive())
2129  break;
2130 
2131  // Calculate the incoming numerator bits. SRem by a positive constant
2132  // can't lower the number of sign bits.
2133  unsigned NumrBits =
2134  ComputeNumSignBits(U->getOperand(0), Depth + 1, Q);
2135 
2136  // Calculate the leading sign bit constraints by examining the
2137  // denominator. Given that the denominator is positive, there are two
2138  // cases:
2139  //
2140  // 1. the numerator is positive. The result range is [0,C) and [0,C) u<
2141  // (1 << ceilLogBase2(C)).
2142  //
2143  // 2. the numerator is negative. Then the result range is (-C,0] and
2144  // integers in (-C,0] are either 0 or >u (-1 << ceilLogBase2(C)).
2145  //
2146  // Thus a lower bound on the number of sign bits is `TyBits -
2147  // ceilLogBase2(C)`.
2148 
2149  unsigned ResBits = TyBits - Denominator->ceilLogBase2();
2150  return std::max(NumrBits, ResBits);
2151  }
2152  break;
2153  }
2154 
2155  case Instruction::AShr: {
2156  Tmp = ComputeNumSignBits(U->getOperand(0), Depth + 1, Q);
2157  // ashr X, C -> adds C sign bits. Vectors too.
2158  const APInt *ShAmt;
2159  if (match(U->getOperand(1), m_APInt(ShAmt))) {
2160  Tmp += ShAmt->getZExtValue();
2161  if (Tmp > TyBits) Tmp = TyBits;
2162  }
2163  return Tmp;
2164  }
2165  case Instruction::Shl: {
2166  const APInt *ShAmt;
2167  if (match(U->getOperand(1), m_APInt(ShAmt))) {
2168  // shl destroys sign bits.
2169  Tmp = ComputeNumSignBits(U->getOperand(0), Depth + 1, Q);
2170  Tmp2 = ShAmt->getZExtValue();
2171  if (Tmp2 >= TyBits || // Bad shift.
2172  Tmp2 >= Tmp) break; // Shifted all sign bits out.
2173  return Tmp - Tmp2;
2174  }
2175  break;
2176  }
2177  case Instruction::And:
2178  case Instruction::Or:
2179  case Instruction::Xor: // NOT is handled here.
2180  // Logical binary ops preserve the number of sign bits at the worst.
2181  Tmp = ComputeNumSignBits(U->getOperand(0), Depth + 1, Q);
2182  if (Tmp != 1) {
2183  Tmp2 = ComputeNumSignBits(U->getOperand(1), Depth + 1, Q);
2184  FirstAnswer = std::min(Tmp, Tmp2);
2185  // We computed what we know about the sign bits as our first
2186  // answer. Now proceed to the generic code that uses
2187  // computeKnownBits, and pick whichever answer is better.
2188  }
2189  break;
2190 
2191  case Instruction::Select:
2192  Tmp = ComputeNumSignBits(U->getOperand(1), Depth + 1, Q);
2193  if (Tmp == 1) return 1; // Early out.
2194  Tmp2 = ComputeNumSignBits(U->getOperand(2), Depth + 1, Q);
2195  return std::min(Tmp, Tmp2);
2196 
2197  case Instruction::Add:
2198  // Add can have at most one carry bit. Thus we know that the output
2199  // is, at worst, one more bit than the inputs.
2200  Tmp = ComputeNumSignBits(U->getOperand(0), Depth + 1, Q);
2201  if (Tmp == 1) return 1; // Early out.
2202 
2203  // Special case decrementing a value (ADD X, -1):
2204  if (const auto *CRHS = dyn_cast<Constant>(U->getOperand(1)))
2205  if (CRHS->isAllOnesValue()) {
2206  APInt KnownZero(TyBits, 0), KnownOne(TyBits, 0);
2207  computeKnownBits(U->getOperand(0), KnownZero, KnownOne, Depth + 1, Q);
2208 
2209  // If the input is known to be 0 or 1, the output is 0/-1, which is all
2210  // sign bits set.
2211  if ((KnownZero | APInt(TyBits, 1)).isAllOnesValue())
2212  return TyBits;
2213 
2214  // If we are subtracting one from a positive number, there is no carry
2215  // out of the result.
2216  if (KnownZero.isNegative())
2217  return Tmp;
2218  }
2219 
2220  Tmp2 = ComputeNumSignBits(U->getOperand(1), Depth + 1, Q);
2221  if (Tmp2 == 1) return 1;
2222  return std::min(Tmp, Tmp2)-1;
2223 
2224  case Instruction::Sub:
2225  Tmp2 = ComputeNumSignBits(U->getOperand(1), Depth + 1, Q);
2226  if (Tmp2 == 1) return 1;
2227 
2228  // Handle NEG.
2229  if (const auto *CLHS = dyn_cast<Constant>(U->getOperand(0)))
2230  if (CLHS->isNullValue()) {
2231  APInt KnownZero(TyBits, 0), KnownOne(TyBits, 0);
2232  computeKnownBits(U->getOperand(1), KnownZero, KnownOne, Depth + 1, Q);
2233  // If the input is known to be 0 or 1, the output is 0/-1, which is all
2234  // sign bits set.
2235  if ((KnownZero | APInt(TyBits, 1)).isAllOnesValue())
2236  return TyBits;
2237 
2238  // If the input is known to be positive (the sign bit is known clear),
2239  // the output of the NEG has the same number of sign bits as the input.
2240  if (KnownZero.isNegative())
2241  return Tmp2;
2242 
2243  // Otherwise, we treat this like a SUB.
2244  }
2245 
2246  // Sub can have at most one carry bit. Thus we know that the output
2247  // is, at worst, one more bit than the inputs.
2248  Tmp = ComputeNumSignBits(U->getOperand(0), Depth + 1, Q);
2249  if (Tmp == 1) return 1; // Early out.
2250  return std::min(Tmp, Tmp2)-1;
2251 
2252  case Instruction::PHI: {
2253  const PHINode *PN = cast<PHINode>(U);
2254  unsigned NumIncomingValues = PN->getNumIncomingValues();
2255  // Don't analyze large in-degree PHIs.
2256  if (NumIncomingValues > 4) break;
2257  // Unreachable blocks may have zero-operand PHI nodes.
2258  if (NumIncomingValues == 0) break;
2259 
2260  // Take the minimum of all incoming values. This can't infinitely loop
2261  // because of our depth threshold.
2262  Tmp = ComputeNumSignBits(PN->getIncomingValue(0), Depth + 1, Q);
2263  for (unsigned i = 1, e = NumIncomingValues; i != e; ++i) {
2264  if (Tmp == 1) return Tmp;
2265  Tmp = std::min(
2266  Tmp, ComputeNumSignBits(PN->getIncomingValue(i), Depth + 1, Q));
2267  }
2268  return Tmp;
2269  }
2270 
2271  case Instruction::Trunc:
2272  // FIXME: it's tricky to do anything useful for this, but it is an important
2273  // case for targets like X86.
2274  break;
2275 
2276  case Instruction::ExtractElement:
2277  // Look through extract element. At the moment we keep this simple and skip
2278  // tracking the specific element. But at least we might find information
2279  // valid for all elements of the vector (for example if vector is sign
2280  // extended, shifted, etc).
2281  return ComputeNumSignBits(U->getOperand(0), Depth + 1, Q);
2282  }
2283 
2284  // Finally, if we can prove that the top bits of the result are 0's or 1's,
2285  // use this information.
2286 
2287  // If we can examine all elements of a vector constant successfully, we're
2288  // done (we can't do any better than that). If not, keep trying.
2289  if (unsigned VecSignBits = computeNumSignBitsVectorConstant(V, TyBits))
2290  return VecSignBits;
2291 
2292  APInt KnownZero(TyBits, 0), KnownOne(TyBits, 0);
2293  computeKnownBits(V, KnownZero, KnownOne, Depth, Q);
2294 
2295  // If we know that the sign bit is either zero or one, determine the number of
2296  // identical bits in the top of the input value.
2297  if (KnownZero.isNegative())
2298  return std::max(FirstAnswer, KnownZero.countLeadingOnes());
2299 
2300  if (KnownOne.isNegative())
2301  return std::max(FirstAnswer, KnownOne.countLeadingOnes());
2302 
2303  // computeKnownBits gave us no extra information about the top bits.
2304  return FirstAnswer;
2305 }
2306 
2307 /// This function computes the integer multiple of Base that equals V.
2308 /// If successful, it returns true and returns the multiple in
2309 /// Multiple. If unsuccessful, it returns false. It looks
2310 /// through SExt instructions only if LookThroughSExt is true.
2311 bool llvm::ComputeMultiple(Value *V, unsigned Base, Value *&Multiple,
2312  bool LookThroughSExt, unsigned Depth) {
2313  const unsigned MaxDepth = 6;
2314 
2315  assert(V && "No Value?");
2316  assert(Depth <= MaxDepth && "Limit Search Depth");
2317  assert(V->getType()->isIntegerTy() && "Not integer or pointer type!");
2318 
2319  Type *T = V->getType();
2320 
2321  ConstantInt *CI = dyn_cast<ConstantInt>(V);
2322 
2323  if (Base == 0)
2324  return false;
2325 
2326  if (Base == 1) {
2327  Multiple = V;
2328  return true;
2329  }
2330 
2332  Constant *BaseVal = ConstantInt::get(T, Base);
2333  if (CO && CO == BaseVal) {
2334  // Multiple is 1.
2335  Multiple = ConstantInt::get(T, 1);
2336  return true;
2337  }
2338 
2339  if (CI && CI->getZExtValue() % Base == 0) {
2340  Multiple = ConstantInt::get(T, CI->getZExtValue() / Base);
2341  return true;
2342  }
2343 
2344  if (Depth == MaxDepth) return false; // Limit search depth.
2345 
2346  Operator *I = dyn_cast<Operator>(V);
2347  if (!I) return false;
2348 
2349  switch (I->getOpcode()) {
2350  default: break;
2351  case Instruction::SExt:
2352  if (!LookThroughSExt) return false;
2353  // otherwise fall through to ZExt
2354  case Instruction::ZExt:
2355  return ComputeMultiple(I->getOperand(0), Base, Multiple,
2356  LookThroughSExt, Depth+1);
2357  case Instruction::Shl:
2358  case Instruction::Mul: {
2359  Value *Op0 = I->getOperand(0);
2360  Value *Op1 = I->getOperand(1);
2361 
2362  if (I->getOpcode() == Instruction::Shl) {
2363  ConstantInt *Op1CI = dyn_cast<ConstantInt>(Op1);
2364  if (!Op1CI) return false;
2365  // Turn Op0 << Op1 into Op0 * 2^Op1
2366  APInt Op1Int = Op1CI->getValue();
2367  uint64_t BitToSet = Op1Int.getLimitedValue(Op1Int.getBitWidth() - 1);
2368  APInt API(Op1Int.getBitWidth(), 0);
2369  API.setBit(BitToSet);
2370  Op1 = ConstantInt::get(V->getContext(), API);
2371  }
2372 
2373  Value *Mul0 = nullptr;
2374  if (ComputeMultiple(Op0, Base, Mul0, LookThroughSExt, Depth+1)) {
2375  if (Constant *Op1C = dyn_cast<Constant>(Op1))
2376  if (Constant *MulC = dyn_cast<Constant>(Mul0)) {
2377  if (Op1C->getType()->getPrimitiveSizeInBits() <
2378  MulC->getType()->getPrimitiveSizeInBits())
2379  Op1C = ConstantExpr::getZExt(Op1C, MulC->getType());
2380  if (Op1C->getType()->getPrimitiveSizeInBits() >
2381  MulC->getType()->getPrimitiveSizeInBits())
2382  MulC = ConstantExpr::getZExt(MulC, Op1C->getType());
2383 
2384  // V == Base * (Mul0 * Op1), so return (Mul0 * Op1)
2385  Multiple = ConstantExpr::getMul(MulC, Op1C);
2386  return true;
2387  }
2388 
2389  if (ConstantInt *Mul0CI = dyn_cast<ConstantInt>(Mul0))
2390  if (Mul0CI->getValue() == 1) {
2391  // V == Base * Op1, so return Op1
2392  Multiple = Op1;
2393  return true;
2394  }
2395  }
2396 
2397  Value *Mul1 = nullptr;
2398  if (ComputeMultiple(Op1, Base, Mul1, LookThroughSExt, Depth+1)) {
2399  if (Constant *Op0C = dyn_cast<Constant>(Op0))
2400  if (Constant *MulC = dyn_cast<Constant>(Mul1)) {
2401  if (Op0C->getType()->getPrimitiveSizeInBits() <
2402  MulC->getType()->getPrimitiveSizeInBits())
2403  Op0C = ConstantExpr::getZExt(Op0C, MulC->getType());
2404  if (Op0C->getType()->getPrimitiveSizeInBits() >
2405  MulC->getType()->getPrimitiveSizeInBits())
2406  MulC = ConstantExpr::getZExt(MulC, Op0C->getType());
2407 
2408  // V == Base * (Mul1 * Op0), so return (Mul1 * Op0)
2409  Multiple = ConstantExpr::getMul(MulC, Op0C);
2410  return true;
2411  }
2412 
2413  if (ConstantInt *Mul1CI = dyn_cast<ConstantInt>(Mul1))
2414  if (Mul1CI->getValue() == 1) {
2415  // V == Base * Op0, so return Op0
2416  Multiple = Op0;
2417  return true;
2418  }
2419  }
2420  }
2421  }
2422 
2423  // We could not determine if V is a multiple of Base.
2424  return false;
2425 }
2426 
2428  const TargetLibraryInfo *TLI) {
2429  const Function *F = ICS.getCalledFunction();
2430  if (!F)
2431  return Intrinsic::not_intrinsic;
2432 
2433  if (F->isIntrinsic())
2434  return F->getIntrinsicID();
2435 
2436  if (!TLI)
2437  return Intrinsic::not_intrinsic;
2438 
2440  // We're going to make assumptions on the semantics of the functions, check
2441  // that the target knows that it's available in this environment and it does
2442  // not have local linkage.
2443  if (!F || F->hasLocalLinkage() || !TLI->getLibFunc(*F, Func))
2444  return Intrinsic::not_intrinsic;
2445 
2446  if (!ICS.onlyReadsMemory())
2447  return Intrinsic::not_intrinsic;
2448 
2449  // Otherwise check if we have a call to a function that can be turned into a
2450  // vector intrinsic.
2451  switch (Func) {
2452  default:
2453  break;
2454  case LibFunc::sin:
2455  case LibFunc::sinf:
2456  case LibFunc::sinl:
2457  return Intrinsic::sin;
2458  case LibFunc::cos:
2459  case LibFunc::cosf:
2460  case LibFunc::cosl:
2461  return Intrinsic::cos;
2462  case LibFunc::exp:
2463  case LibFunc::expf:
2464  case LibFunc::expl:
2465  return Intrinsic::exp;
2466  case LibFunc::exp2:
2467  case LibFunc::exp2f:
2468  case LibFunc::exp2l:
2469  return Intrinsic::exp2;
2470  case LibFunc::log:
2471  case LibFunc::logf:
2472  case LibFunc::logl:
2473  return Intrinsic::log;
2474  case LibFunc::log10:
2475  case LibFunc::log10f:
2476  case LibFunc::log10l:
2477  return Intrinsic::log10;
2478  case LibFunc::log2:
2479  case LibFunc::log2f:
2480  case LibFunc::log2l:
2481  return Intrinsic::log2;
2482  case LibFunc::fabs:
2483  case LibFunc::fabsf:
2484  case LibFunc::fabsl:
2485  return Intrinsic::fabs;
2486  case LibFunc::fmin:
2487  case LibFunc::fminf:
2488  case LibFunc::fminl:
2489  return Intrinsic::minnum;
2490  case LibFunc::fmax:
2491  case LibFunc::fmaxf:
2492  case LibFunc::fmaxl:
2493  return Intrinsic::maxnum;
2494  case LibFunc::copysign:
2495  case LibFunc::copysignf:
2496  case LibFunc::copysignl:
2497  return Intrinsic::copysign;
2498  case LibFunc::floor:
2499  case LibFunc::floorf:
2500  case LibFunc::floorl:
2501  return Intrinsic::floor;
2502  case LibFunc::ceil:
2503  case LibFunc::ceilf:
2504  case LibFunc::ceill:
2505  return Intrinsic::ceil;
2506  case LibFunc::trunc:
2507  case LibFunc::truncf:
2508  case LibFunc::truncl:
2509  return Intrinsic::trunc;
2510  case LibFunc::rint:
2511  case LibFunc::rintf:
2512  case LibFunc::rintl:
2513  return Intrinsic::rint;
2514  case LibFunc::nearbyint:
2515  case LibFunc::nearbyintf:
2516  case LibFunc::nearbyintl:
2517  return Intrinsic::nearbyint;
2518  case LibFunc::round:
2519  case LibFunc::roundf:
2520  case LibFunc::roundl:
2521  return Intrinsic::round;
2522  case LibFunc::pow:
2523  case LibFunc::powf:
2524  case LibFunc::powl:
2525  return Intrinsic::pow;
2526  case LibFunc::sqrt:
2527  case LibFunc::sqrtf:
2528  case LibFunc::sqrtl:
2529  if (ICS->hasNoNaNs())
2530  return Intrinsic::sqrt;
2531  return Intrinsic::not_intrinsic;
2532  }
2533 
2534  return Intrinsic::not_intrinsic;
2535 }
2536 
2537 /// Return true if we can prove that the specified FP value is never equal to
2538 /// -0.0.
2539 ///
2540 /// NOTE: this function will need to be revisited when we support non-default
2541 /// rounding modes!
2542 ///
2543 bool llvm::CannotBeNegativeZero(const Value *V, const TargetLibraryInfo *TLI,
2544  unsigned Depth) {
2545  if (const ConstantFP *CFP = dyn_cast<ConstantFP>(V))
2546  return !CFP->getValueAPF().isNegZero();
2547 
2548  if (Depth == MaxDepth)
2549  return false; // Limit search depth.
2550 
2551  const Operator *I = dyn_cast<Operator>(V);
2552  if (!I) return false;
2553 
2554  // Check if the nsz fast-math flag is set
2555  if (const FPMathOperator *FPO = dyn_cast<FPMathOperator>(I))
2556  if (FPO->hasNoSignedZeros())
2557  return true;
2558 
2559  // (add x, 0.0) is guaranteed to return +0.0, not -0.0.
2560  if (I->getOpcode() == Instruction::FAdd)
2561  if (ConstantFP *CFP = dyn_cast<ConstantFP>(I->getOperand(1)))
2562  if (CFP->isNullValue())
2563  return true;
2564 
2565  // sitofp and uitofp turn into +0.0 for zero.
2566  if (isa<SIToFPInst>(I) || isa<UIToFPInst>(I))
2567  return true;
2568 
2569  if (const CallInst *CI = dyn_cast<CallInst>(I)) {
2570  Intrinsic::ID IID = getIntrinsicForCallSite(CI, TLI);
2571  switch (IID) {
2572  default:
2573  break;
2574  // sqrt(-0.0) = -0.0, no other negative results are possible.
2575  case Intrinsic::sqrt:
2576  return CannotBeNegativeZero(CI->getArgOperand(0), TLI, Depth + 1);
2577  // fabs(x) != -0.0
2578  case Intrinsic::fabs:
2579  return true;
2580  }
2581  }
2582 
2583  return false;
2584 }
2585 
2586 /// If \p SignBitOnly is true, test for a known 0 sign bit rather than a
2587 /// standard ordered compare. e.g. make -0.0 olt 0.0 be true because of the sign
2588 /// bit despite comparing equal.
2589 static bool cannotBeOrderedLessThanZeroImpl(const Value *V,
2590  const TargetLibraryInfo *TLI,
2591  bool SignBitOnly,
2592  unsigned Depth) {
2593  if (const ConstantFP *CFP = dyn_cast<ConstantFP>(V)) {
2594  return !CFP->getValueAPF().isNegative() ||
2595  (!SignBitOnly && CFP->getValueAPF().isZero());
2596  }
2597 
2598  if (Depth == MaxDepth)
2599  return false; // Limit search depth.
2600 
2601  const Operator *I = dyn_cast<Operator>(V);
2602  if (!I)
2603  return false;
2604 
2605  switch (I->getOpcode()) {
2606  default:
2607  break;
2608  // Unsigned integers are always nonnegative.
2609  case Instruction::UIToFP:
2610  return true;
2611  case Instruction::FMul:
2612  // x*x is always non-negative or a NaN.
2613  if (I->getOperand(0) == I->getOperand(1) &&
2614  (!SignBitOnly || cast<FPMathOperator>(I)->hasNoNaNs()))
2615  return true;
2616 
2618  case Instruction::FAdd:
2619  case Instruction::FDiv:
2620  case Instruction::FRem:
2621  return cannotBeOrderedLessThanZeroImpl(I->getOperand(0), TLI, SignBitOnly,
2622  Depth + 1) &&
2623  cannotBeOrderedLessThanZeroImpl(I->getOperand(1), TLI, SignBitOnly,
2624  Depth + 1);
2625  case Instruction::Select:
2626  return cannotBeOrderedLessThanZeroImpl(I->getOperand(1), TLI, SignBitOnly,
2627  Depth + 1) &&
2628  cannotBeOrderedLessThanZeroImpl(I->getOperand(2), TLI, SignBitOnly,
2629  Depth + 1);
2630  case Instruction::FPExt:
2631  case Instruction::FPTrunc:
2632  // Widening/narrowing never change sign.
2633  return cannotBeOrderedLessThanZeroImpl(I->getOperand(0), TLI, SignBitOnly,
2634  Depth + 1);
2635  case Instruction::Call:
2636  Intrinsic::ID IID = getIntrinsicForCallSite(cast<CallInst>(I), TLI);
2637  switch (IID) {
2638  default:
2639  break;
2640  case Intrinsic::maxnum:
2641  return cannotBeOrderedLessThanZeroImpl(I->getOperand(0), TLI, SignBitOnly,
2642  Depth + 1) ||
2643  cannotBeOrderedLessThanZeroImpl(I->getOperand(1), TLI, SignBitOnly,
2644  Depth + 1);
2645  case Intrinsic::minnum:
2646  return cannotBeOrderedLessThanZeroImpl(I->getOperand(0), TLI, SignBitOnly,
2647  Depth + 1) &&
2648  cannotBeOrderedLessThanZeroImpl(I->getOperand(1), TLI, SignBitOnly,
2649  Depth + 1);
2650  case Intrinsic::exp:
2651  case Intrinsic::exp2:
2652  case Intrinsic::fabs:
2653  case Intrinsic::sqrt:
2654  return true;
2655  case Intrinsic::powi:
2656  if (ConstantInt *CI = dyn_cast<ConstantInt>(I->getOperand(1))) {
2657  // powi(x,n) is non-negative if n is even.
2658  if (CI->getBitWidth() <= 64 && CI->getSExtValue() % 2u == 0)
2659  return true;
2660  }
2661  return cannotBeOrderedLessThanZeroImpl(I->getOperand(0), TLI, SignBitOnly,
2662  Depth + 1);
2663  case Intrinsic::fma:
2664  case Intrinsic::fmuladd:
2665  // x*x+y is non-negative if y is non-negative.
2666  return I->getOperand(0) == I->getOperand(1) &&
2667  (!SignBitOnly || cast<FPMathOperator>(I)->hasNoNaNs()) &&
2668  cannotBeOrderedLessThanZeroImpl(I->getOperand(2), TLI, SignBitOnly,
2669  Depth + 1);
2670  }
2671  break;
2672  }
2673  return false;
2674 }
2675 
2677  const TargetLibraryInfo *TLI) {
2678  return cannotBeOrderedLessThanZeroImpl(V, TLI, false, 0);
2679 }
2680 
2681 bool llvm::SignBitMustBeZero(const Value *V, const TargetLibraryInfo *TLI) {
2682  return cannotBeOrderedLessThanZeroImpl(V, TLI, true, 0);
2683 }
2684 
2685 /// If the specified value can be set by repeating the same byte in memory,
2686 /// return the i8 value that it is represented with. This is
2687 /// true for all i8 values obviously, but is also true for i32 0, i32 -1,
2688 /// i16 0xF0F0, double 0.0 etc. If the value can't be handled with a repeated
2689 /// byte store (e.g. i16 0x1234), return null.
2690 Value *llvm::isBytewiseValue(Value *V) {
2691  // All byte-wide stores are splatable, even of arbitrary variables.
2692  if (V->getType()->isIntegerTy(8)) return V;
2693 
2694  // Handle 'null' ConstantArrayZero etc.
2695  if (Constant *C = dyn_cast<Constant>(V))
2696  if (C->isNullValue())
2698 
2699  // Constant float and double values can be handled as integer values if the
2700  // corresponding integer value is "byteable". An important case is 0.0.
2701  if (ConstantFP *CFP = dyn_cast<ConstantFP>(V)) {
2702  if (CFP->getType()->isFloatTy())
2704  if (CFP->getType()->isDoubleTy())
2706  // Don't handle long double formats, which have strange constraints.
2707  }
2708 
2709  // We can handle constant integers that are multiple of 8 bits.
2710  if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
2711  if (CI->getBitWidth() % 8 == 0) {
2712  assert(CI->getBitWidth() > 8 && "8 bits should be handled above!");
2713 
2714  if (!CI->getValue().isSplat(8))
2715  return nullptr;
2716  return ConstantInt::get(V->getContext(), CI->getValue().trunc(8));
2717  }
2718  }
2719 
2720  // A ConstantDataArray/Vector is splatable if all its members are equal and
2721  // also splatable.
2722  if (ConstantDataSequential *CA = dyn_cast<ConstantDataSequential>(V)) {
2723  Value *Elt = CA->getElementAsConstant(0);
2724  Value *Val = isBytewiseValue(Elt);
2725  if (!Val)
2726  return nullptr;
2727 
2728  for (unsigned I = 1, E = CA->getNumElements(); I != E; ++I)
2729  if (CA->getElementAsConstant(I) != Elt)
2730  return nullptr;
2731 
2732  return Val;
2733  }
2734 
2735  // Conceptually, we could handle things like:
2736  // %a = zext i8 %X to i16
2737  // %b = shl i16 %a, 8
2738  // %c = or i16 %a, %b
2739  // but until there is an example that actually needs this, it doesn't seem
2740  // worth worrying about.
2741  return nullptr;
2742 }
2743 
2744 
2745 // This is the recursive version of BuildSubAggregate. It takes a few different
2746 // arguments. Idxs is the index within the nested struct From that we are
2747 // looking at now (which is of type IndexedType). IdxSkip is the number of
2748 // indices from Idxs that should be left out when inserting into the resulting
2749 // struct. To is the result struct built so far, new insertvalue instructions
2750 // build on that.
2751 static Value *BuildSubAggregate(Value *From, Value* To, Type *IndexedType,
2753  unsigned IdxSkip,
2754  Instruction *InsertBefore) {
2755  llvm::StructType *STy = dyn_cast<llvm::StructType>(IndexedType);
2756  if (STy) {
2757  // Save the original To argument so we can modify it
2758  Value *OrigTo = To;
2759  // General case, the type indexed by Idxs is a struct
2760  for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) {
2761  // Process each struct element recursively
2762  Idxs.push_back(i);
2763  Value *PrevTo = To;
2764  To = BuildSubAggregate(From, To, STy->getElementType(i), Idxs, IdxSkip,
2765  InsertBefore);
2766  Idxs.pop_back();
2767  if (!To) {
2768  // Couldn't find any inserted value for this index? Cleanup
2769  while (PrevTo != OrigTo) {
2770  InsertValueInst* Del = cast<InsertValueInst>(PrevTo);
2771  PrevTo = Del->getAggregateOperand();
2772  Del->eraseFromParent();
2773  }
2774  // Stop processing elements
2775  break;
2776  }
2777  }
2778  // If we successfully found a value for each of our subaggregates
2779  if (To)
2780  return To;
2781  }
2782  // Base case, the type indexed by SourceIdxs is not a struct, or not all of
2783  // the struct's elements had a value that was inserted directly. In the latter
2784  // case, perhaps we can't determine each of the subelements individually, but
2785  // we might be able to find the complete struct somewhere.
2786 
2787  // Find the value that is at that particular spot
2788  Value *V = FindInsertedValue(From, Idxs);
2789 
2790  if (!V)
2791  return nullptr;
2792 
2793  // Insert the value in the new (sub) aggregrate
2794  return llvm::InsertValueInst::Create(To, V, makeArrayRef(Idxs).slice(IdxSkip),
2795  "tmp", InsertBefore);
2796 }
2797 
2798 // This helper takes a nested struct and extracts a part of it (which is again a
2799 // struct) into a new value. For example, given the struct:
2800 // { a, { b, { c, d }, e } }
2801 // and the indices "1, 1" this returns
2802 // { c, d }.
2803 //
2804 // It does this by inserting an insertvalue for each element in the resulting
2805 // struct, as opposed to just inserting a single struct. This will only work if
2806 // each of the elements of the substruct are known (ie, inserted into From by an
2807 // insertvalue instruction somewhere).
2808 //
2809 // All inserted insertvalue instructions are inserted before InsertBefore
2810 static Value *BuildSubAggregate(Value *From, ArrayRef<unsigned> idx_range,
2811  Instruction *InsertBefore) {
2812  assert(InsertBefore && "Must have someplace to insert!");
2813  Type *IndexedType = ExtractValueInst::getIndexedType(From->getType(),
2814  idx_range);
2815  Value *To = UndefValue::get(IndexedType);
2816  SmallVector<unsigned, 10> Idxs(idx_range.begin(), idx_range.end());
2817  unsigned IdxSkip = Idxs.size();
2818 
2819  return BuildSubAggregate(From, To, IndexedType, Idxs, IdxSkip, InsertBefore);
2820 }
2821 
2822 /// Given an aggregrate and an sequence of indices, see if
2823 /// the scalar value indexed is already around as a register, for example if it
2824 /// were inserted directly into the aggregrate.
2825 ///
2826 /// If InsertBefore is not null, this function will duplicate (modified)
2827 /// insertvalues when a part of a nested struct is extracted.
2828 Value *llvm::FindInsertedValue(Value *V, ArrayRef<unsigned> idx_range,
2829  Instruction *InsertBefore) {
2830  // Nothing to index? Just return V then (this is useful at the end of our
2831  // recursion).
2832  if (idx_range.empty())
2833  return V;
2834  // We have indices, so V should have an indexable type.
2835  assert((V->getType()->isStructTy() || V->getType()->isArrayTy()) &&
2836  "Not looking at a struct or array?");
2837  assert(ExtractValueInst::getIndexedType(V->getType(), idx_range) &&
2838  "Invalid indices for type?");
2839 
2840  if (Constant *C = dyn_cast<Constant>(V)) {
2841  C = C->getAggregateElement(idx_range[0]);
2842  if (!C) return nullptr;
2843  return FindInsertedValue(C, idx_range.slice(1), InsertBefore);
2844  }
2845 
2846  if (InsertValueInst *I = dyn_cast<InsertValueInst>(V)) {
2847  // Loop the indices for the insertvalue instruction in parallel with the
2848  // requested indices
2849  const unsigned *req_idx = idx_range.begin();
2850  for (const unsigned *i = I->idx_begin(), *e = I->idx_end();
2851  i != e; ++i, ++req_idx) {
2852  if (req_idx == idx_range.end()) {
2853  // We can't handle this without inserting insertvalues
2854  if (!InsertBefore)
2855  return nullptr;
2856 
2857  // The requested index identifies a part of a nested aggregate. Handle
2858  // this specially. For example,
2859  // %A = insertvalue { i32, {i32, i32 } } undef, i32 10, 1, 0
2860  // %B = insertvalue { i32, {i32, i32 } } %A, i32 11, 1, 1
2861  // %C = extractvalue {i32, { i32, i32 } } %B, 1
2862  // This can be changed into
2863  // %A = insertvalue {i32, i32 } undef, i32 10, 0
2864  // %C = insertvalue {i32, i32 } %A, i32 11, 1
2865  // which allows the unused 0,0 element from the nested struct to be
2866  // removed.
2867  return BuildSubAggregate(V, makeArrayRef(idx_range.begin(), req_idx),
2868  InsertBefore);
2869  }
2870 
2871  // This insert value inserts something else than what we are looking for.
2872  // See if the (aggregate) value inserted into has the value we are
2873  // looking for, then.
2874  if (*req_idx != *i)
2875  return FindInsertedValue(I->getAggregateOperand(), idx_range,
2876  InsertBefore);
2877  }
2878  // If we end up here, the indices of the insertvalue match with those
2879  // requested (though possibly only partially). Now we recursively look at
2880  // the inserted value, passing any remaining indices.
2881  return FindInsertedValue(I->getInsertedValueOperand(),
2882  makeArrayRef(req_idx, idx_range.end()),
2883  InsertBefore);
2884  }
2885 
2886  if (ExtractValueInst *I = dyn_cast<ExtractValueInst>(V)) {
2887  // If we're extracting a value from an aggregate that was extracted from
2888  // something else, we can extract from that something else directly instead.
2889  // However, we will need to chain I's indices with the requested indices.
2890 
2891  // Calculate the number of indices required
2892  unsigned size = I->getNumIndices() + idx_range.size();
2893  // Allocate some space to put the new indices in
2895  Idxs.reserve(size);
2896  // Add indices from the extract value instruction
2897  Idxs.append(I->idx_begin(), I->idx_end());
2898 
2899  // Add requested indices
2900  Idxs.append(idx_range.begin(), idx_range.end());
2901 
2902  assert(Idxs.size() == size
2903  && "Number of indices added not correct?");
2904 
2905  return FindInsertedValue(I->getAggregateOperand(), Idxs, InsertBefore);
2906  }
2907  // Otherwise, we don't know (such as, extracting from a function return value
2908  // or load instruction)
2909  return nullptr;
2910 }
2911 
2912 /// Analyze the specified pointer to see if it can be expressed as a base
2913 /// pointer plus a constant offset. Return the base and offset to the caller.
2915  const DataLayout &DL) {
2916  unsigned BitWidth = DL.getPointerTypeSizeInBits(Ptr->getType());
2917  APInt ByteOffset(BitWidth, 0);
2918 
2919  // We walk up the defs but use a visited set to handle unreachable code. In
2920  // that case, we stop after accumulating the cycle once (not that it
2921  // matters).
2922  SmallPtrSet<Value *, 16> Visited;
2923  while (Visited.insert(Ptr).second) {
2924  if (Ptr->getType()->isVectorTy())
2925  break;
2926 
2927  if (GEPOperator *GEP = dyn_cast<GEPOperator>(Ptr)) {
2928  // If one of the values we have visited is an addrspacecast, then
2929  // the pointer type of this GEP may be different from the type
2930  // of the Ptr parameter which was passed to this function. This
2931  // means when we construct GEPOffset, we need to use the size
2932  // of GEP's pointer type rather than the size of the original
2933  // pointer type.
2934  APInt GEPOffset(DL.getPointerTypeSizeInBits(Ptr->getType()), 0);
2935  if (!GEP->accumulateConstantOffset(DL, GEPOffset))
2936  break;
2937 
2938  ByteOffset += GEPOffset.getSExtValue();
2939 
2940  Ptr = GEP->getPointerOperand();
2941  } else if (Operator::getOpcode(Ptr) == Instruction::BitCast ||
2942  Operator::getOpcode(Ptr) == Instruction::AddrSpaceCast) {
2943  Ptr = cast<Operator>(Ptr)->getOperand(0);
2944  } else if (GlobalAlias *GA = dyn_cast<GlobalAlias>(Ptr)) {
2945  if (GA->isInterposable())
2946  break;
2947  Ptr = GA->getAliasee();
2948  } else {
2949  break;
2950  }
2951  }
2952  Offset = ByteOffset.getSExtValue();
2953  return Ptr;
2954 }
2955 
2957  // Make sure the GEP has exactly three arguments.
2958  if (GEP->getNumOperands() != 3)
2959  return false;
2960 
2961  // Make sure the index-ee is a pointer to array of i8.
2963  if (!AT || !AT->getElementType()->isIntegerTy(8))
2964  return false;
2965 
2966  // Check to make sure that the first operand of the GEP is an integer and
2967  // has value 0 so that we are sure we're indexing into the initializer.
2968  const ConstantInt *FirstIdx = dyn_cast<ConstantInt>(GEP->getOperand(1));
2969  if (!FirstIdx || !FirstIdx->isZero())
2970  return false;
2971 
2972  return true;
2973 }
2974 
2975 /// This function computes the length of a null-terminated C string pointed to
2976 /// by V. If successful, it returns true and returns the string in Str.
2977 /// If unsuccessful, it returns false.
2978 bool llvm::getConstantStringInfo(const Value *V, StringRef &Str,
2979  uint64_t Offset, bool TrimAtNul) {
2980  assert(V);
2981 
2982  // Look through bitcast instructions and geps.
2983  V = V->stripPointerCasts();
2984 
2985  // If the value is a GEP instruction or constant expression, treat it as an
2986  // offset.
2987  if (const GEPOperator *GEP = dyn_cast<GEPOperator>(V)) {
2988  // The GEP operator should be based on a pointer to string constant, and is
2989  // indexing into the string constant.
2991  return false;
2992 
2993  // If the second index isn't a ConstantInt, then this is a variable index
2994  // into the array. If this occurs, we can't say anything meaningful about
2995  // the string.
2996  uint64_t StartIdx = 0;
2997  if (const ConstantInt *CI = dyn_cast<ConstantInt>(GEP->getOperand(2)))
2998  StartIdx = CI->getZExtValue();
2999  else
3000  return false;
3001  return getConstantStringInfo(GEP->getOperand(0), Str, StartIdx + Offset,
3002  TrimAtNul);
3003  }
3004 
3005  // The GEP instruction, constant or instruction, must reference a global
3006  // variable that is a constant and is initialized. The referenced constant
3007  // initializer is the array that we'll use for optimization.
3008  const GlobalVariable *GV = dyn_cast<GlobalVariable>(V);
3009  if (!GV || !GV->isConstant() || !GV->hasDefinitiveInitializer())
3010  return false;
3011 
3012  // Handle the all-zeros case.
3013  if (GV->getInitializer()->isNullValue()) {
3014  // This is a degenerate case. The initializer is constant zero so the
3015  // length of the string must be zero.
3016  Str = "";
3017  return true;
3018  }
3019 
3020  // This must be a ConstantDataArray.
3021  const auto *Array = dyn_cast<ConstantDataArray>(GV->getInitializer());
3022  if (!Array || !Array->isString())
3023  return false;
3024 
3025  // Get the number of elements in the array.
3026  uint64_t NumElts = Array->getType()->getArrayNumElements();
3027 
3028  // Start out with the entire array in the StringRef.
3029  Str = Array->getAsString();
3030 
3031  if (Offset > NumElts)
3032  return false;
3033 
3034  // Skip over 'offset' bytes.
3035  Str = Str.substr(Offset);
3036 
3037  if (TrimAtNul) {
3038  // Trim off the \0 and anything after it. If the array is not nul
3039  // terminated, we just return the whole end of string. The client may know
3040  // some other way that the string is length-bound.
3041  Str = Str.substr(0, Str.find('\0'));
3042  }
3043  return true;
3044 }
3045 
3046 // These next two are very similar to the above, but also look through PHI
3047 // nodes.
3048 // TODO: See if we can integrate these two together.
3049 
3050 /// If we can compute the length of the string pointed to by
3051 /// the specified pointer, return 'len+1'. If we can't, return 0.
3052 static uint64_t GetStringLengthH(const Value *V,
3054  // Look through noop bitcast instructions.
3055  V = V->stripPointerCasts();
3056 
3057  // If this is a PHI node, there are two cases: either we have already seen it
3058  // or we haven't.
3059  if (const PHINode *PN = dyn_cast<PHINode>(V)) {
3060  if (!PHIs.insert(PN).second)
3061  return ~0ULL; // already in the set.
3062 
3063  // If it was new, see if all the input strings are the same length.
3064  uint64_t LenSoFar = ~0ULL;
3065  for (Value *IncValue : PN->incoming_values()) {
3066  uint64_t Len = GetStringLengthH(IncValue, PHIs);
3067  if (Len == 0) return 0; // Unknown length -> unknown.
3068 
3069  if (Len == ~0ULL) continue;
3070 
3071  if (Len != LenSoFar && LenSoFar != ~0ULL)
3072  return 0; // Disagree -> unknown.
3073  LenSoFar = Len;
3074  }
3075 
3076  // Success, all agree.
3077  return LenSoFar;
3078  }
3079 
3080  // strlen(select(c,x,y)) -> strlen(x) ^ strlen(y)
3081  if (const SelectInst *SI = dyn_cast<SelectInst>(V)) {
3082  uint64_t Len1 = GetStringLengthH(SI->getTrueValue(), PHIs);
3083  if (Len1 == 0) return 0;
3084  uint64_t Len2 = GetStringLengthH(SI->getFalseValue(), PHIs);
3085  if (Len2 == 0) return 0;
3086  if (Len1 == ~0ULL) return Len2;
3087  if (Len2 == ~0ULL) return Len1;
3088  if (Len1 != Len2) return 0;
3089  return Len1;
3090  }
3091 
3092  // Otherwise, see if we can read the string.
3093  StringRef StrData;
3094  if (!getConstantStringInfo(V, StrData))
3095  return 0;
3096 
3097  return StrData.size()+1;
3098 }
3099 
3100 /// If we can compute the length of the string pointed to by
3101 /// the specified pointer, return 'len+1'. If we can't, return 0.
3102 uint64_t llvm::GetStringLength(const Value *V) {
3103  if (!V->getType()->isPointerTy()) return 0;
3104 
3106  uint64_t Len = GetStringLengthH(V, PHIs);
3107  // If Len is ~0ULL, we had an infinite phi cycle: this is dead code, so return
3108  // an empty string as a length.
3109  return Len == ~0ULL ? 1 : Len;
3110 }
3111 
3112 /// \brief \p PN defines a loop-variant pointer to an object. Check if the
3113 /// previous iteration of the loop was referring to the same object as \p PN.
3115  const LoopInfo *LI) {
3116  // Find the loop-defined value.
3117  Loop *L = LI->getLoopFor(PN->getParent());
3118  if (PN->getNumIncomingValues() != 2)
3119  return true;
3120 
3121  // Find the value from previous iteration.
3122  auto *PrevValue = dyn_cast<Instruction>(PN->getIncomingValue(0));
3123  if (!PrevValue || LI->getLoopFor(PrevValue->getParent()) != L)
3124  PrevValue = dyn_cast<Instruction>(PN->getIncomingValue(1));
3125  if (!PrevValue || LI->getLoopFor(PrevValue->getParent()) != L)
3126  return true;
3127 
3128  // If a new pointer is loaded in the loop, the pointer references a different
3129  // object in every iteration. E.g.:
3130  // for (i)
3131  // int *p = a[i];
3132  // ...
3133  if (auto *Load = dyn_cast<LoadInst>(PrevValue))
3134  if (!L->isLoopInvariant(Load->getPointerOperand()))
3135  return false;
3136  return true;
3137 }
3138 
3139 Value *llvm::GetUnderlyingObject(Value *V, const DataLayout &DL,
3140  unsigned MaxLookup) {
3141  if (!V->getType()->isPointerTy())
3142  return V;
3143  for (unsigned Count = 0; MaxLookup == 0 || Count < MaxLookup; ++Count) {
3144  if (GEPOperator *GEP = dyn_cast<GEPOperator>(V)) {
3145  V = GEP->getPointerOperand();
3146  } else if (Operator::getOpcode(V) == Instruction::BitCast ||
3147  Operator::getOpcode(V) == Instruction::AddrSpaceCast) {
3148  V = cast<Operator>(V)->getOperand(0);
3149  } else if (GlobalAlias *GA = dyn_cast<GlobalAlias>(V)) {
3150  if (GA->isInterposable())
3151  return V;
3152  V = GA->getAliasee();
3153  } else {
3154  if (auto CS = CallSite(V))
3155  if (Value *RV = CS.getReturnedArgOperand()) {
3156  V = RV;
3157  continue;
3158  }
3159 
3160  // See if InstructionSimplify knows any relevant tricks.
3161  if (Instruction *I = dyn_cast<Instruction>(V))
3162  // TODO: Acquire a DominatorTree and AssumptionCache and use them.
3163  if (Value *Simplified = SimplifyInstruction(I, DL, nullptr)) {
3164  V = Simplified;
3165  continue;
3166  }
3167 
3168  return V;
3169  }
3170  assert(V->getType()->isPointerTy() && "Unexpected operand type!");
3171  }
3172  return V;
3173 }
3174 
3176  const DataLayout &DL, LoopInfo *LI,
3177  unsigned MaxLookup) {
3178  SmallPtrSet<Value *, 4> Visited;
3179  SmallVector<Value *, 4> Worklist;
3180  Worklist.push_back(V);
3181  do {
3182  Value *P = Worklist.pop_back_val();
3183  P = GetUnderlyingObject(P, DL, MaxLookup);
3184 
3185  if (!Visited.insert(P).second)
3186  continue;
3187 
3188  if (SelectInst *SI = dyn_cast<SelectInst>(P)) {
3189  Worklist.push_back(SI->getTrueValue());
3190  Worklist.push_back(SI->getFalseValue());
3191  continue;
3192  }
3193 
3194  if (PHINode *PN = dyn_cast<PHINode>(P)) {
3195  // If this PHI changes the underlying object in every iteration of the
3196  // loop, don't look through it. Consider:
3197  // int **A;
3198  // for (i) {
3199  // Prev = Curr; // Prev = PHI (Prev_0, Curr)
3200  // Curr = A[i];
3201  // *Prev, *Curr;
3202  //
3203  // Prev is tracking Curr one iteration behind so they refer to different
3204  // underlying objects.
3205  if (!LI || !LI->isLoopHeader(PN->getParent()) ||
3207  for (Value *IncValue : PN->incoming_values())
3208  Worklist.push_back(IncValue);
3209  continue;
3210  }
3211 
3212  Objects.push_back(P);
3213  } while (!Worklist.empty());
3214 }
3215 
3216 /// Return true if the only users of this pointer are lifetime markers.
3217 bool llvm::onlyUsedByLifetimeMarkers(const Value *V) {
3218  for (const User *U : V->users()) {
3219  const IntrinsicInst *II = dyn_cast<IntrinsicInst>(U);
3220  if (!II) return false;
3221 
3222  if (II->getIntrinsicID() != Intrinsic::lifetime_start &&
3223  II->getIntrinsicID() != Intrinsic::lifetime_end)
3224  return false;
3225  }
3226  return true;
3227 }
3228 
3230  const Instruction *CtxI,
3231  const DominatorTree *DT) {
3232  const Operator *Inst = dyn_cast<Operator>(V);
3233  if (!Inst)
3234  return false;
3235 
3236  for (unsigned i = 0, e = Inst->getNumOperands(); i != e; ++i)
3237  if (Constant *C = dyn_cast<Constant>(Inst->getOperand(i)))
3238  if (C->canTrap())
3239  return false;
3240 
3241  switch (Inst->getOpcode()) {
3242  default:
3243  return true;
3244  case Instruction::UDiv:
3245  case Instruction::URem: {
3246  // x / y is undefined if y == 0.
3247  const APInt *V;
3248  if (match(Inst->getOperand(1), m_APInt(V)))
3249  return *V != 0;
3250  return false;
3251  }
3252  case Instruction::SDiv:
3253  case Instruction::SRem: {
3254  // x / y is undefined if y == 0 or x == INT_MIN and y == -1
3255  const APInt *Numerator, *Denominator;
3256  if (!match(Inst->getOperand(1), m_APInt(Denominator)))
3257  return false;
3258  // We cannot hoist this division if the denominator is 0.
3259  if (*Denominator == 0)
3260  return false;
3261  // It's safe to hoist if the denominator is not 0 or -1.
3262  if (*Denominator != -1)
3263  return true;
3264  // At this point we know that the denominator is -1. It is safe to hoist as
3265  // long we know that the numerator is not INT_MIN.
3266  if (match(Inst->getOperand(0), m_APInt(Numerator)))
3267  return !Numerator->isMinSignedValue();
3268  // The numerator *might* be MinSignedValue.
3269  return false;
3270  }
3271  case Instruction::Load: {
3272  const LoadInst *LI = cast<LoadInst>(Inst);
3273  if (!LI->isUnordered() ||
3274  // Speculative load may create a race that did not exist in the source.
3275  LI->getFunction()->hasFnAttribute(Attribute::SanitizeThread) ||
3276  // Speculative load may load data from dirty regions.
3277  LI->getFunction()->hasFnAttribute(Attribute::SanitizeAddress))
3278  return false;
3279  const DataLayout &DL = LI->getModule()->getDataLayout();
3281  LI->getAlignment(), DL, CtxI, DT);
3282  }
3283  case Instruction::Call: {
3284  if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(Inst)) {
3285  switch (II->getIntrinsicID()) {
3286  // These synthetic intrinsics have no side-effects and just mark
3287  // information about their operands.
3288  // FIXME: There are other no-op synthetic instructions that potentially
3289  // should be considered at least *safe* to speculate...
3290  case Intrinsic::dbg_declare:
3291  case Intrinsic::dbg_value:
3292  return true;
3293 
3294  case Intrinsic::bitreverse:
3295  case Intrinsic::bswap:
3296  case Intrinsic::ctlz:
3297  case Intrinsic::ctpop:
3298  case Intrinsic::cttz:
3299  case Intrinsic::objectsize:
3300  case Intrinsic::sadd_with_overflow:
3301  case Intrinsic::smul_with_overflow:
3302  case Intrinsic::ssub_with_overflow:
3303  case Intrinsic::uadd_with_overflow:
3304  case Intrinsic::umul_with_overflow:
3305  case Intrinsic::usub_with_overflow:
3306  return true;
3307  // These intrinsics are defined to have the same behavior as libm
3308  // functions except for setting errno.
3309  case Intrinsic::sqrt:
3310  case Intrinsic::fma:
3311  case Intrinsic::fmuladd:
3312  return true;
3313  // These intrinsics are defined to have the same behavior as libm
3314  // functions, and the corresponding libm functions never set errno.
3315  case Intrinsic::trunc:
3316  case Intrinsic::copysign:
3317  case Intrinsic::fabs:
3318  case Intrinsic::minnum:
3319  case Intrinsic::maxnum:
3320  return true;
3321  // These intrinsics are defined to have the same behavior as libm
3322  // functions, which never overflow when operating on the IEEE754 types
3323  // that we support, and never set errno otherwise.
3324  case Intrinsic::ceil:
3325  case Intrinsic::floor:
3326  case Intrinsic::nearbyint:
3327  case Intrinsic::rint:
3328  case Intrinsic::round:
3329  return true;
3330  // TODO: are convert_{from,to}_fp16 safe?
3331  // TODO: can we list target-specific intrinsics here?
3332  default: break;
3333  }
3334  }
3335  return false; // The called function could have undefined behavior or
3336  // side-effects, even if marked readnone nounwind.
3337  }
3338  case Instruction::VAArg:
3339  case Instruction::Alloca:
3340  case Instruction::Invoke:
3341  case Instruction::PHI:
3342  case Instruction::Store:
3343  case Instruction::Ret:
3344  case Instruction::Br:
3345  case Instruction::IndirectBr:
3346  case Instruction::Switch:
3347  case Instruction::Unreachable:
3348  case Instruction::Fence:
3349  case Instruction::AtomicRMW:
3350  case Instruction::AtomicCmpXchg:
3351  case Instruction::LandingPad:
3352  case Instruction::Resume:
3353  case Instruction::CatchSwitch:
3354  case Instruction::CatchPad:
3355  case Instruction::CatchRet:
3356  case Instruction::CleanupPad:
3357  case Instruction::CleanupRet:
3358  return false; // Misc instructions which have effects
3359  }
3360 }
3361 
3364 }
3365 
3366 /// Return true if we know that the specified value is never null.
3367 bool llvm::isKnownNonNull(const Value *V) {
3368  assert(V->getType()->isPointerTy() && "V must be pointer type");
3369 
3370  // Alloca never returns null, malloc might.
3371  if (isa<AllocaInst>(V)) return true;
3372 
3373  // A byval, inalloca, or nonnull argument is never null.
3374  if (const Argument *A = dyn_cast<Argument>(V))
3375  return A->hasByValOrInAllocaAttr() || A->hasNonNullAttr();
3376 
3377  // A global variable in address space 0 is non null unless extern weak
3378  // or an absolute symbol reference. Other address spaces may have null as a
3379  // valid address for a global, so we can't assume anything.
3380  if (const GlobalValue *GV = dyn_cast<GlobalValue>(V))
3381  return !GV->isAbsoluteSymbolRef() && !GV->hasExternalWeakLinkage() &&
3382  GV->getType()->getAddressSpace() == 0;
3383 
3384  // A Load tagged with nonnull metadata is never null.
3385  if (const LoadInst *LI = dyn_cast<LoadInst>(V))
3386  return LI->getMetadata(LLVMContext::MD_nonnull);
3387 
3388  if (auto CS = ImmutableCallSite(V))
3389  if (CS.isReturnNonNull())
3390  return true;
3391 
3392  return false;
3393 }
3394 
3395 static bool isKnownNonNullFromDominatingCondition(const Value *V,
3396  const Instruction *CtxI,
3397  const DominatorTree *DT) {
3398  assert(V->getType()->isPointerTy() && "V must be pointer type");
3399  assert(!isa<ConstantData>(V) && "Did not expect ConstantPointerNull");
3400  assert(CtxI && "Context instruction required for analysis");
3401  assert(DT && "Dominator tree required for analysis");
3402 
3403  unsigned NumUsesExplored = 0;
3404  for (auto *U : V->users()) {
3405  // Avoid massive lists
3406  if (NumUsesExplored >= DomConditionsMaxUses)
3407  break;
3408  NumUsesExplored++;
3409  // Consider only compare instructions uniquely controlling a branch
3410  CmpInst::Predicate Pred;
3411  if (!match(const_cast<User *>(U),
3412  m_c_ICmp(Pred, m_Specific(V), m_Zero())) ||
3413  (Pred != ICmpInst::ICMP_EQ && Pred != ICmpInst::ICMP_NE))
3414  continue;
3415 
3416  for (auto *CmpU : U->users()) {
3417  if (const BranchInst *BI = dyn_cast<BranchInst>(CmpU)) {
3418  assert(BI->isConditional() && "uses a comparison!");
3419 
3420  BasicBlock *NonNullSuccessor =
3421  BI->getSuccessor(Pred == ICmpInst::ICMP_EQ ? 1 : 0);
3422  BasicBlockEdge Edge(BI->getParent(), NonNullSuccessor);
3423  if (Edge.isSingleEdge() && DT->dominates(Edge, CtxI->getParent()))
3424  return true;
3425  } else if (Pred == ICmpInst::ICMP_NE &&
3426  match(CmpU, m_Intrinsic<Intrinsic::experimental_guard>()) &&
3427  DT->dominates(cast<Instruction>(CmpU), CtxI)) {
3428  return true;
3429  }
3430  }
3431  }
3432 
3433  return false;
3434 }
3435 
3436 bool llvm::isKnownNonNullAt(const Value *V, const Instruction *CtxI,
3437  const DominatorTree *DT) {
3438  if (isa<ConstantPointerNull>(V) || isa<UndefValue>(V))
3439  return false;
3440 
3441  if (isKnownNonNull(V))
3442  return true;
3443 
3444  if (!CtxI || !DT)
3445  return false;
3446 
3448 }
3449 
3451  const Value *RHS,
3452  const DataLayout &DL,
3453  AssumptionCache *AC,
3454  const Instruction *CxtI,
3455  const DominatorTree *DT) {
3456  // Multiplying n * m significant bits yields a result of n + m significant
3457  // bits. If the total number of significant bits does not exceed the
3458  // result bit width (minus 1), there is no overflow.
3459  // This means if we have enough leading zero bits in the operands
3460  // we can guarantee that the result does not overflow.
3461  // Ref: "Hacker's Delight" by Henry Warren
3462  unsigned BitWidth = LHS->getType()->getScalarSizeInBits();
3463  APInt LHSKnownZero(BitWidth, 0);
3464  APInt LHSKnownOne(BitWidth, 0);
3465  APInt RHSKnownZero(BitWidth, 0);
3466  APInt RHSKnownOne(BitWidth, 0);
3467  computeKnownBits(LHS, LHSKnownZero, LHSKnownOne, DL, /*Depth=*/0, AC, CxtI,
3468  DT);
3469  computeKnownBits(RHS, RHSKnownZero, RHSKnownOne, DL, /*Depth=*/0, AC, CxtI,
3470  DT);
3471  // Note that underestimating the number of zero bits gives a more
3472  // conservative answer.
3473  unsigned ZeroBits = LHSKnownZero.countLeadingOnes() +
3474  RHSKnownZero.countLeadingOnes();
3475  // First handle the easy case: if we have enough zero bits there's
3476  // definitely no overflow.
3477  if (ZeroBits >= BitWidth)
3479 
3480  // Get the largest possible values for each operand.
3481  APInt LHSMax = ~LHSKnownZero;
3482  APInt RHSMax = ~RHSKnownZero;
3483 
3484  // We know the multiply operation doesn't overflow if the maximum values for
3485  // each operand will not overflow after we multiply them together.
3486  bool MaxOverflow;
3487  LHSMax.umul_ov(RHSMax, MaxOverflow);
3488  if (!MaxOverflow)
3490 
3491  // We know it always overflows if multiplying the smallest possible values for
3492  // the operands also results in overflow.
3493  bool MinOverflow;
3494  LHSKnownOne.umul_ov(RHSKnownOne, MinOverflow);
3495  if (MinOverflow)
3497 
3499 }
3500 
3502  const Value *RHS,
3503  const DataLayout &DL,
3504  AssumptionCache *AC,
3505  const Instruction *CxtI,
3506  const DominatorTree *DT) {
3507  bool LHSKnownNonNegative, LHSKnownNegative;
3508  ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, DL, /*Depth=*/0,
3509  AC, CxtI, DT);
3510  if (LHSKnownNonNegative || LHSKnownNegative) {
3511  bool RHSKnownNonNegative, RHSKnownNegative;
3512  ComputeSignBit(RHS, RHSKnownNonNegative, RHSKnownNegative, DL, /*Depth=*/0,
3513  AC, CxtI, DT);
3514 
3515  if (LHSKnownNegative && RHSKnownNegative) {
3516  // The sign bit is set in both cases: this MUST overflow.
3517  // Create a simple add instruction, and insert it into the struct.
3519  }
3520 
3521  if (LHSKnownNonNegative && RHSKnownNonNegative) {
3522  // The sign bit is clear in both cases: this CANNOT overflow.
3523  // Create a simple add instruction, and insert it into the struct.
3525  }
3526  }
3527 
3529 }
3530 
3532  const Value *RHS,
3533  const AddOperator *Add,
3534  const DataLayout &DL,
3535  AssumptionCache *AC,
3536  const Instruction *CxtI,
3537  const DominatorTree *DT) {
3538  if (Add && Add->hasNoSignedWrap()) {
3540  }
3541 
3542  bool LHSKnownNonNegative, LHSKnownNegative;
3543  bool RHSKnownNonNegative, RHSKnownNegative;
3544  ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, DL, /*Depth=*/0,
3545  AC, CxtI, DT);
3546  ComputeSignBit(RHS, RHSKnownNonNegative, RHSKnownNegative, DL, /*Depth=*/0,
3547  AC, CxtI, DT);
3548 
3549  if ((LHSKnownNonNegative && RHSKnownNegative) ||
3550  (LHSKnownNegative && RHSKnownNonNegative)) {
3551  // The sign bits are opposite: this CANNOT overflow.
3553  }
3554 
3555  // The remaining code needs Add to be available. Early returns if not so.
3556  if (!Add)
3558 
3559  // If the sign of Add is the same as at least one of the operands, this add
3560  // CANNOT overflow. This is particularly useful when the sum is
3561  // @llvm.assume'ed non-negative rather than proved so from analyzing its
3562  // operands.
3563  bool LHSOrRHSKnownNonNegative =
3564  (LHSKnownNonNegative || RHSKnownNonNegative);
3565  bool LHSOrRHSKnownNegative = (LHSKnownNegative || RHSKnownNegative);
3566  if (LHSOrRHSKnownNonNegative || LHSOrRHSKnownNegative) {
3567  bool AddKnownNonNegative, AddKnownNegative;
3568  ComputeSignBit(Add, AddKnownNonNegative, AddKnownNegative, DL,
3569  /*Depth=*/0, AC, CxtI, DT);
3570  if ((AddKnownNonNegative && LHSOrRHSKnownNonNegative) ||
3571  (AddKnownNegative && LHSOrRHSKnownNegative)) {
3573  }
3574  }
3575 
3577 }
3578 
3580  const DominatorTree &DT) {
3581 #ifndef NDEBUG
3582  auto IID = II->getIntrinsicID();
3583  assert((IID == Intrinsic::sadd_with_overflow ||
3584  IID == Intrinsic::uadd_with_overflow ||
3585  IID == Intrinsic::ssub_with_overflow ||
3586  IID == Intrinsic::usub_with_overflow ||
3587  IID == Intrinsic::smul_with_overflow ||
3588  IID == Intrinsic::umul_with_overflow) &&
3589  "Not an overflow intrinsic!");
3590 #endif
3591 
3592  SmallVector<const BranchInst *, 2> GuardingBranches;
3594 
3595  for (const User *U : II->users()) {
3596  if (const auto *EVI = dyn_cast<ExtractValueInst>(U)) {
3597  assert(EVI->getNumIndices() == 1 && "Obvious from CI's type");
3598 
3599  if (EVI->getIndices()[0] == 0)
3600  Results.push_back(EVI);
3601  else {
3602  assert(EVI->getIndices()[0] == 1 && "Obvious from CI's type");
3603 
3604  for (const auto *U : EVI->users())
3605  if (const auto *B = dyn_cast<BranchInst>(U)) {
3606  assert(B->isConditional() && "How else is it using an i1?");
3607  GuardingBranches.push_back(B);
3608  }
3609  }
3610  } else {
3611  // We are using the aggregate directly in a way we don't want to analyze
3612  // here (storing it to a global, say).
3613  return false;
3614  }
3615  }
3616 
3617  auto AllUsesGuardedByBranch = [&](const BranchInst *BI) {
3618  BasicBlockEdge NoWrapEdge(BI->getParent(), BI->getSuccessor(1));
3619  if (!NoWrapEdge.isSingleEdge())
3620  return false;
3621 
3622  // Check if all users of the add are provably no-wrap.
3623  for (const auto *Result : Results) {
3624  // If the extractvalue itself is not executed on overflow, the we don't
3625  // need to check each use separately, since domination is transitive.
3626  if (DT.dominates(NoWrapEdge, Result->getParent()))
3627  continue;
3628 
3629  for (auto &RU : Result->uses())
3630  if (!DT.dominates(NoWrapEdge, RU))
3631  return false;
3632  }
3633 
3634  return true;
3635  };
3636 
3637  return any_of(GuardingBranches, AllUsesGuardedByBranch);
3638 }
3639 
3640 
3642  const DataLayout &DL,
3643  AssumptionCache *AC,
3644  const Instruction *CxtI,
3645  const DominatorTree *DT) {
3647  Add, DL, AC, CxtI, DT);
3648 }
3649 
3651  const Value *RHS,
3652  const DataLayout &DL,
3653  AssumptionCache *AC,
3654  const Instruction *CxtI,
3655  const DominatorTree *DT) {
3656  return ::computeOverflowForSignedAdd(LHS, RHS, nullptr, DL, AC, CxtI, DT);
3657 }
3658 
3660  // A memory operation returns normally if it isn't volatile. A volatile
3661  // operation is allowed to trap.
3662  //
3663  // An atomic operation isn't guaranteed to return in a reasonable amount of
3664  // time because it's possible for another thread to interfere with it for an
3665  // arbitrary length of time, but programs aren't allowed to rely on that.
3666  if (const LoadInst *LI = dyn_cast<LoadInst>(I))
3667  return !LI->isVolatile();
3668  if (const StoreInst *SI = dyn_cast<StoreInst>(I))
3669  return !SI->isVolatile();
3670  if (const AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(I))
3671  return !CXI->isVolatile();
3672  if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(I))
3673  return !RMWI->isVolatile();
3674  if (const MemIntrinsic *MII = dyn_cast<MemIntrinsic>(I))
3675  return !MII->isVolatile();
3676 
3677  // If there is no successor, then execution can't transfer to it.
3678  if (const auto *CRI = dyn_cast<CleanupReturnInst>(I))
3679  return !CRI->unwindsToCaller();
3680  if (const auto *CatchSwitch = dyn_cast<CatchSwitchInst>(I))
3681  return !CatchSwitch->unwindsToCaller();
3682  if (isa<ResumeInst>(I))
3683  return false;
3684  if (isa<ReturnInst>(I))
3685  return false;
3686 
3687  // Calls can throw, or contain an infinite loop, or kill the process.
3688  if (auto CS = ImmutableCallSite(I)) {
3689  // Call sites that throw have implicit non-local control flow.
3690  if (!CS.doesNotThrow())
3691  return false;
3692 
3693  // Non-throwing call sites can loop infinitely, call exit/pthread_exit
3694  // etc. and thus not return. However, LLVM already assumes that
3695  //
3696  // - Thread exiting actions are modeled as writes to memory invisible to
3697  // the program.
3698  //
3699  // - Loops that don't have side effects (side effects are volatile/atomic
3700  // stores and IO) always terminate (see http://llvm.org/PR965).
3701  // Furthermore IO itself is also modeled as writes to memory invisible to
3702  // the program.
3703  //
3704  // We rely on those assumptions here, and use the memory effects of the call
3705  // target as a proxy for checking that it always returns.
3706 
3707  // FIXME: This isn't aggressive enough; a call which only writes to a global
3708  // is guaranteed to return.
3709  return CS.onlyReadsMemory() || CS.onlyAccessesArgMemory() ||
3710  match(I, m_Intrinsic<Intrinsic::assume>());
3711  }
3712 
3713  // Other instructions return normally.
3714  return true;
3715 }
3716 
3718  const Loop *L) {
3719  // The loop header is guaranteed to be executed for every iteration.
3720  //
3721  // FIXME: Relax this constraint to cover all basic blocks that are
3722  // guaranteed to be executed at every iteration.
3723  if (I->getParent() != L->getHeader()) return false;
3724 
3725  for (const Instruction &LI : *L->getHeader()) {
3726  if (&LI == I) return true;
3727  if (!isGuaranteedToTransferExecutionToSuccessor(&LI)) return false;
3728  }
3729  llvm_unreachable("Instruction not contained in its own parent basic block.");
3730 }
3731 
3733  switch (I->getOpcode()) {
3734  case Instruction::Add:
3735  case Instruction::Sub:
3736  case Instruction::Xor:
3737  case Instruction::Trunc:
3738  case Instruction::BitCast:
3739  case Instruction::AddrSpaceCast:
3740  // These operations all propagate poison unconditionally. Note that poison
3741  // is not any particular value, so xor or subtraction of poison with
3742  // itself still yields poison, not zero.
3743  return true;
3744 
3745  case Instruction::AShr:
3746  case Instruction::SExt:
3747  // For these operations, one bit of the input is replicated across
3748  // multiple output bits. A replicated poison bit is still poison.
3749  return true;
3750 
3751  case Instruction::Shl: {
3752  // Left shift *by* a poison value is poison. The number of
3753  // positions to shift is unsigned, so no negative values are
3754  // possible there. Left shift by zero places preserves poison. So
3755  // it only remains to consider left shift of poison by a positive
3756  // number of places.
3757  //
3758  // A left shift by a positive number of places leaves the lowest order bit
3759  // non-poisoned. However, if such a shift has a no-wrap flag, then we can
3760  // make the poison operand violate that flag, yielding a fresh full-poison
3761  // value.
3762  auto *OBO = cast<OverflowingBinaryOperator>(I);
3763  return OBO->hasNoUnsignedWrap() || OBO->hasNoSignedWrap();
3764  }
3765 
3766  case Instruction::Mul: {
3767  // A multiplication by zero yields a non-poison zero result, so we need to
3768  // rule out zero as an operand. Conservatively, multiplication by a
3769  // non-zero constant is not multiplication by zero.
3770  //
3771  // Multiplication by a non-zero constant can leave some bits
3772  // non-poisoned. For example, a multiplication by 2 leaves the lowest
3773  // order bit unpoisoned. So we need to consider that.
3774  //
3775  // Multiplication by 1 preserves poison. If the multiplication has a
3776  // no-wrap flag, then we can make the poison operand violate that flag
3777  // when multiplied by any integer other than 0 and 1.
3778  auto *OBO = cast<OverflowingBinaryOperator>(I);
3779  if (OBO->hasNoUnsignedWrap() || OBO->hasNoSignedWrap()) {
3780  for (Value *V : OBO->operands()) {
3781  if (auto *CI = dyn_cast<ConstantInt>(V)) {
3782  // A ConstantInt cannot yield poison, so we can assume that it is
3783  // the other operand that is poison.
3784  return !CI->isZero();
3785  }
3786  }
3787  }
3788  return false;
3789  }
3790 
3791  case Instruction::ICmp:
3792  // Comparing poison with any value yields poison. This is why, for
3793  // instance, x s< (x +nsw 1) can be folded to true.
3794  return true;
3795 
3796  case Instruction::GetElementPtr:
3797  // A GEP implicitly represents a sequence of additions, subtractions,
3798  // truncations, sign extensions and multiplications. The multiplications
3799  // are by the non-zero sizes of some set of types, so we do not have to be
3800  // concerned with multiplication by zero. If the GEP is in-bounds, then
3801  // these operations are implicitly no-signed-wrap so poison is propagated
3802  // by the arguments above for Add, Sub, Trunc, SExt and Mul.
3803  return cast<GEPOperator>(I)->isInBounds();
3804 
3805  default:
3806  return false;
3807  }
3808 }
3809 
3811  switch (I->getOpcode()) {
3812  case Instruction::Store:
3813  return cast<StoreInst>(I)->getPointerOperand();
3814 
3815  case Instruction::Load:
3816  return cast<LoadInst>(I)->getPointerOperand();
3817 
3818  case Instruction::AtomicCmpXchg:
3819  return cast<AtomicCmpXchgInst>(I)->getPointerOperand();
3820 
3821  case Instruction::AtomicRMW:
3822  return cast<AtomicRMWInst>(I)->getPointerOperand();
3823 
3824  case Instruction::UDiv:
3825  case Instruction::SDiv:
3826  case Instruction::URem:
3827  case Instruction::SRem:
3828  return I->getOperand(1);
3829 
3830  default:
3831  return nullptr;
3832  }
3833 }
3834 
3836  // We currently only look for uses of poison values within the same basic
3837  // block, as that makes it easier to guarantee that the uses will be
3838  // executed given that PoisonI is executed.
3839  //
3840  // FIXME: Expand this to consider uses beyond the same basic block. To do
3841  // this, look out for the distinction between post-dominance and strong
3842  // post-dominance.
3843  const BasicBlock *BB = PoisonI->getParent();
3844 
3845  // Set of instructions that we have proved will yield poison if PoisonI
3846  // does.
3847  SmallSet<const Value *, 16> YieldsPoison;
3849  YieldsPoison.insert(PoisonI);
3850  Visited.insert(PoisonI->getParent());
3851 
3852  BasicBlock::const_iterator Begin = PoisonI->getIterator(), End = BB->end();
3853 
3854  unsigned Iter = 0;
3855  while (Iter++ < MaxDepth) {
3856  for (auto &I : make_range(Begin, End)) {
3857  if (&I != PoisonI) {
3858  const Value *NotPoison = getGuaranteedNonFullPoisonOp(&I);
3859  if (NotPoison != nullptr && YieldsPoison.count(NotPoison))
3860  return true;
3862  return false;
3863  }
3864 
3865  // Mark poison that propagates from I through uses of I.
3866  if (YieldsPoison.count(&I)) {
3867  for (const User *User : I.users()) {
3868  const Instruction *UserI = cast<Instruction>(User);
3869  if (propagatesFullPoison(UserI))
3870  YieldsPoison.insert(User);
3871  }
3872  }
3873  }
3874 
3875  if (auto *NextBB = BB->getSingleSuccessor()) {
3876  if (Visited.insert(NextBB).second) {
3877  BB = NextBB;
3878  Begin = BB->getFirstNonPHI()->getIterator();
3879  End = BB->end();
3880  continue;
3881  }
3882  }
3883 
3884  break;
3885  };
3886  return false;
3887 }
3888 
3889 static bool isKnownNonNaN(const Value *V, FastMathFlags FMF) {
3890  if (FMF.noNaNs())
3891  return true;
3892 
3893  if (auto *C = dyn_cast<ConstantFP>(V))
3894  return !C->isNaN();
3895  return false;
3896 }
3897 
3898 static bool isKnownNonZero(const Value *V) {
3899  if (auto *C = dyn_cast<ConstantFP>(V))
3900  return !C->isZero();
3901  return false;
3902 }
3903 
3904 /// Match non-obvious integer minimum and maximum sequences.
3906  Value *CmpLHS, Value *CmpRHS,
3907  Value *TrueVal, Value *FalseVal,
3908  Value *&LHS, Value *&RHS) {
3909  if (Pred != CmpInst::ICMP_SGT && Pred != CmpInst::ICMP_SLT)
3910  return {SPF_UNKNOWN, SPNB_NA, false};
3911 
3912  // Z = X -nsw Y
3913  // (X >s Y) ? 0 : Z ==> (Z >s 0) ? 0 : Z ==> SMIN(Z, 0)
3914  // (X <s Y) ? 0 : Z ==> (Z <s 0) ? 0 : Z ==> SMAX(Z, 0)
3915  if (match(TrueVal, m_Zero()) &&
3916  match(FalseVal, m_NSWSub(m_Specific(CmpLHS), m_Specific(CmpRHS)))) {
3917  LHS = TrueVal;
3918  RHS = FalseVal;
3919  return {Pred == CmpInst::ICMP_SGT ? SPF_SMIN : SPF_SMAX, SPNB_NA, false};
3920  }
3921 
3922  // Z = X -nsw Y
3923  // (X >s Y) ? Z : 0 ==> (Z >s 0) ? Z : 0 ==> SMAX(Z, 0)
3924  // (X <s Y) ? Z : 0 ==> (Z <s 0) ? Z : 0 ==> SMIN(Z, 0)
3925  if (match(FalseVal, m_Zero()) &&
3926  match(TrueVal, m_NSWSub(m_Specific(CmpLHS), m_Specific(CmpRHS)))) {
3927  LHS = TrueVal;
3928  RHS = FalseVal;
3929  return {Pred == CmpInst::ICMP_SGT ? SPF_SMAX : SPF_SMIN, SPNB_NA, false};
3930  }
3931 
3932  const APInt *C1;
3933  if (!match(CmpRHS, m_APInt(C1)))
3934  return {SPF_UNKNOWN, SPNB_NA, false};
3935 
3936  // An unsigned min/max can be written with a signed compare.
3937  const APInt *C2;
3938  if ((CmpLHS == TrueVal && match(FalseVal, m_APInt(C2))) ||
3939  (CmpLHS == FalseVal && match(TrueVal, m_APInt(C2)))) {
3940  // Is the sign bit set?
3941  // (X <s 0) ? X : MAXVAL ==> (X >u MAXVAL) ? X : MAXVAL ==> UMAX
3942  // (X <s 0) ? MAXVAL : X ==> (X >u MAXVAL) ? MAXVAL : X ==> UMIN
3943  if (Pred == CmpInst::ICMP_SLT && *C1 == 0 && C2->isMaxSignedValue()) {
3944  LHS = TrueVal;
3945  RHS = FalseVal;
3946  return {CmpLHS == TrueVal ? SPF_UMAX : SPF_UMIN, SPNB_NA, false};
3947  }
3948 
3949  // Is the sign bit clear?
3950  // (X >s -1) ? MINVAL : X ==> (X <u MINVAL) ? MINVAL : X ==> UMAX
3951  // (X >s -1) ? X : MINVAL ==> (X <u MINVAL) ? X : MINVAL ==> UMIN
3952  if (Pred == CmpInst::ICMP_SGT && C1->isAllOnesValue() &&
3953  C2->isMinSignedValue()) {
3954  LHS = TrueVal;
3955  RHS = FalseVal;
3956  return {CmpLHS == FalseVal ? SPF_UMAX : SPF_UMIN, SPNB_NA, false};
3957  }
3958  }
3959 
3960  // Look through 'not' ops to find disguised signed min/max.
3961  // (X >s C) ? ~X : ~C ==> (~X <s ~C) ? ~X : ~C ==> SMIN(~X, ~C)
3962  // (X <s C) ? ~X : ~C ==> (~X >s ~C) ? ~X : ~C ==> SMAX(~X, ~C)
3963  if (match(TrueVal, m_Not(m_Specific(CmpLHS))) &&
3964  match(FalseVal, m_APInt(C2)) && ~(*C1) == *C2) {
3965  LHS = TrueVal;
3966  RHS = FalseVal;
3967  return {Pred == CmpInst::ICMP_SGT ? SPF_SMIN : SPF_SMAX, SPNB_NA, false};
3968  }
3969 
3970  // (X >s C) ? ~C : ~X ==> (~X <s ~C) ? ~C : ~X ==> SMAX(~C, ~X)
3971  // (X <s C) ? ~C : ~X ==> (~X >s ~C) ? ~C : ~X ==> SMIN(~C, ~X)
3972  if (match(FalseVal, m_Not(m_Specific(CmpLHS))) &&
3973  match(TrueVal, m_APInt(C2)) && ~(*C1) == *C2) {
3974  LHS = TrueVal;
3975  RHS = FalseVal;
3976  return {Pred == CmpInst::ICMP_SGT ? SPF_SMAX : SPF_SMIN, SPNB_NA, false};
3977  }
3978 
3979  return {SPF_UNKNOWN, SPNB_NA, false};
3980 }
3981 
3983  FastMathFlags FMF,
3984  Value *CmpLHS, Value *CmpRHS,
3985  Value *TrueVal, Value *FalseVal,
3986  Value *&LHS, Value *&RHS) {
3987  LHS = CmpLHS;
3988  RHS = CmpRHS;
3989 
3990  // If the predicate is an "or-equal" (FP) predicate, then signed zeroes may
3991  // return inconsistent results between implementations.
3992  // (0.0 <= -0.0) ? 0.0 : -0.0 // Returns 0.0
3993  // minNum(0.0, -0.0) // May return -0.0 or 0.0 (IEEE 754-2008 5.3.1)
3994  // Therefore we behave conservatively and only proceed if at least one of the
3995  // operands is known to not be zero, or if we don't care about signed zeroes.
3996  switch (Pred) {
3997  default: break;
4000  if (!FMF.noSignedZeros() && !isKnownNonZero(CmpLHS) &&
4001  !isKnownNonZero(CmpRHS))
4002  return {SPF_UNKNOWN, SPNB_NA, false};
4003  }
4004 
4005  SelectPatternNaNBehavior NaNBehavior = SPNB_NA;
4006  bool Ordered = false;
4007 
4008  // When given one NaN and one non-NaN input:
4009  // - maxnum/minnum (C99 fmaxf()/fminf()) return the non-NaN input.
4010  // - A simple C99 (a < b ? a : b) construction will return 'b' (as the
4011  // ordered comparison fails), which could be NaN or non-NaN.
4012  // so here we discover exactly what NaN behavior is required/accepted.
4013  if (CmpInst::isFPPredicate(Pred)) {
4014  bool LHSSafe = isKnownNonNaN(CmpLHS, FMF);
4015  bool RHSSafe = isKnownNonNaN(CmpRHS, FMF);
4016 
4017  if (LHSSafe && RHSSafe) {
4018  // Both operands are known non-NaN.
4019  NaNBehavior = SPNB_RETURNS_ANY;
4020  } else if (CmpInst::isOrdered(Pred)) {
4021  // An ordered comparison will return false when given a NaN, so it
4022  // returns the RHS.
4023  Ordered = true;
4024  if (LHSSafe)
4025  // LHS is non-NaN, so if RHS is NaN then NaN will be returned.
4026  NaNBehavior = SPNB_RETURNS_NAN;
4027  else if (RHSSafe)
4028  NaNBehavior = SPNB_RETURNS_OTHER;
4029  else
4030  // Completely unsafe.
4031  return {SPF_UNKNOWN, SPNB_NA, false};
4032  } else {
4033  Ordered = false;
4034  // An unordered comparison will return true when given a NaN, so it
4035  // returns the LHS.
4036  if (LHSSafe)
4037  // LHS is non-NaN, so if RHS is NaN then non-NaN will be returned.
4038  NaNBehavior = SPNB_RETURNS_OTHER;
4039  else if (RHSSafe)
4040  NaNBehavior = SPNB_RETURNS_NAN;
4041  else
4042  // Completely unsafe.
4043  return {SPF_UNKNOWN, SPNB_NA, false};
4044  }
4045  }
4046 
4047  if (TrueVal == CmpRHS && FalseVal == CmpLHS) {
4048  std::swap(CmpLHS, CmpRHS);
4049  Pred = CmpInst::getSwappedPredicate(Pred);
4050  if (NaNBehavior == SPNB_RETURNS_NAN)
4051  NaNBehavior = SPNB_RETURNS_OTHER;
4052  else if (NaNBehavior == SPNB_RETURNS_OTHER)
4053  NaNBehavior = SPNB_RETURNS_NAN;
4054  Ordered = !Ordered;
4055  }
4056 
4057  // ([if]cmp X, Y) ? X : Y
4058  if (TrueVal == CmpLHS && FalseVal == CmpRHS) {
4059  switch (Pred) {
4060  default: return {SPF_UNKNOWN, SPNB_NA, false}; // Equality.
4061  case ICmpInst::ICMP_UGT:
4062  case ICmpInst::ICMP_UGE: return {SPF_UMAX, SPNB_NA, false};
4063  case ICmpInst::ICMP_SGT:
4064  case ICmpInst::ICMP_SGE: return {SPF_SMAX, SPNB_NA, false};
4065  case ICmpInst::ICMP_ULT:
4066  case ICmpInst::ICMP_ULE: return {SPF_UMIN, SPNB_NA, false};
4067  case ICmpInst::ICMP_SLT:
4068  case ICmpInst::ICMP_SLE: return {SPF_SMIN, SPNB_NA, false};
4069  case FCmpInst::FCMP_UGT:
4070  case FCmpInst::FCMP_UGE:
4071  case FCmpInst::FCMP_OGT:
4072  case FCmpInst::FCMP_OGE: return {SPF_FMAXNUM, NaNBehavior, Ordered};
4073  case FCmpInst::FCMP_ULT:
4074  case FCmpInst::FCMP_ULE:
4075  case FCmpInst::FCMP_OLT:
4076  case FCmpInst::FCMP_OLE: return {SPF_FMINNUM, NaNBehavior, Ordered};
4077  }
4078  }
4079 
4080  const APInt *C1;
4081  if (match(CmpRHS, m_APInt(C1))) {
4082  if ((CmpLHS == TrueVal && match(FalseVal, m_Neg(m_Specific(CmpLHS)))) ||
4083  (CmpLHS == FalseVal && match(TrueVal, m_Neg(m_Specific(CmpLHS))))) {
4084 
4085  // ABS(X) ==> (X >s 0) ? X : -X and (X >s -1) ? X : -X
4086  // NABS(X) ==> (X >s 0) ? -X : X and (X >s -1) ? -X : X
4087  if (Pred == ICmpInst::ICMP_SGT && (*C1 == 0 || C1->isAllOnesValue())) {
4088  return {(CmpLHS == TrueVal) ? SPF_ABS : SPF_NABS, SPNB_NA, false};
4089  }
4090 
4091  // ABS(X) ==> (X <s 0) ? -X : X and (X <s 1) ? -X : X
4092  // NABS(X) ==> (X <s 0) ? X : -X and (X <s 1) ? X : -X
4093  if (Pred == ICmpInst::ICMP_SLT && (*C1 == 0 || *C1 == 1)) {
4094  return {(CmpLHS == FalseVal) ? SPF_ABS : SPF_NABS, SPNB_NA, false};
4095  }
4096  }
4097  }
4098 
4099  return matchMinMax(Pred, CmpLHS, CmpRHS, TrueVal, FalseVal, LHS, RHS);
4100 }
4101 
4102 static Value *lookThroughCast(CmpInst *CmpI, Value *V1, Value *V2,
4103  Instruction::CastOps *CastOp) {
4104  CastInst *CI = dyn_cast<CastInst>(V1);
4105  Constant *C = dyn_cast<Constant>(V2);
4106  if (!CI)
4107  return nullptr;
4108  *CastOp = CI->getOpcode();
4109 
4110  if (auto *CI2 = dyn_cast<CastInst>(V2)) {
4111  // If V1 and V2 are both the same cast from the same type, we can look
4112  // through V1.
4113  if (CI2->getOpcode() == CI->getOpcode() &&
4114  CI2->getSrcTy() == CI->getSrcTy())
4115  return CI2->getOperand(0);
4116  return nullptr;
4117  } else if (!C) {
4118  return nullptr;
4119  }
4120 
4121  Constant *CastedTo = nullptr;
4122 
4123  if (isa<ZExtInst>(CI) && CmpI->isUnsigned())
4124  CastedTo = ConstantExpr::getTrunc(C, CI->getSrcTy());
4125 
4126  if (isa<SExtInst>(CI) && CmpI->isSigned())
4127  CastedTo = ConstantExpr::getTrunc(C, CI->getSrcTy(), true);
4128 
4129  if (isa<TruncInst>(CI))
4130  CastedTo = ConstantExpr::getIntegerCast(C, CI->getSrcTy(), CmpI->isSigned());
4131 
4132  if (isa<FPTruncInst>(CI))
4133  CastedTo = ConstantExpr::getFPExtend(C, CI->getSrcTy(), true);
4134 
4135  if (isa<FPExtInst>(CI))
4136  CastedTo = ConstantExpr::getFPTrunc(C, CI->getSrcTy(), true);
4137 
4138  if (isa<FPToUIInst>(CI))
4139  CastedTo = ConstantExpr::getUIToFP(C, CI->getSrcTy(), true);
4140 
4141  if (isa<FPToSIInst>(CI))
4142  CastedTo = ConstantExpr::getSIToFP(C, CI->getSrcTy(), true);
4143 
4144  if (isa<UIToFPInst>(CI))
4145  CastedTo = ConstantExpr::getFPToUI(C, CI->getSrcTy(), true);
4146 
4147  if (isa<SIToFPInst>(CI))
4148  CastedTo = ConstantExpr::getFPToSI(C, CI->getSrcTy(), true);
4149 
4150  if (!CastedTo)
4151  return nullptr;
4152 
4153  Constant *CastedBack =
4154  ConstantExpr::getCast(CI->getOpcode(), CastedTo, C->getType(), true);
4155  // Make sure the cast doesn't lose any information.
4156  if (CastedBack != C)
4157  return nullptr;
4158 
4159  return CastedTo;
4160 }
4161 
4162 SelectPatternResult llvm::matchSelectPattern(Value *V, Value *&LHS, Value *&RHS,
4163  Instruction::CastOps *CastOp) {
4165  if (!SI) return {SPF_UNKNOWN, SPNB_NA, false};
4166 
4167  CmpInst *CmpI = dyn_cast<CmpInst>(SI->getCondition());
4168  if (!CmpI) return {SPF_UNKNOWN, SPNB_NA, false};
4169 
4170  CmpInst::Predicate Pred = CmpI->getPredicate();
4171  Value *CmpLHS = CmpI->getOperand(0);
4172  Value *CmpRHS = CmpI->getOperand(1);
4173  Value *TrueVal = SI->getTrueValue();
4174  Value *FalseVal = SI->getFalseValue();
4175  FastMathFlags FMF;
4176  if (isa<FPMathOperator>(CmpI))
4177  FMF = CmpI->getFastMathFlags();
4178 
4179  // Bail out early.
4180  if (CmpI->isEquality())
4181  return {SPF_UNKNOWN, SPNB_NA, false};
4182 
4183  // Deal with type mismatches.
4184  if (CastOp && CmpLHS->getType() != TrueVal->getType()) {
4185  if (Value *C = lookThroughCast(CmpI, TrueVal, FalseVal, CastOp))
4186  return ::matchSelectPattern(Pred, FMF, CmpLHS, CmpRHS,
4187  cast<CastInst>(TrueVal)->getOperand(0), C,
4188  LHS, RHS);
4189  if (Value *C = lookThroughCast(CmpI, FalseVal, TrueVal, CastOp))
4190  return ::matchSelectPattern(Pred, FMF, CmpLHS, CmpRHS,
4191  C, cast<CastInst>(FalseVal)->getOperand(0),
4192  LHS, RHS);
4193  }
4194  return ::matchSelectPattern(Pred, FMF, CmpLHS, CmpRHS, TrueVal, FalseVal,
4195  LHS, RHS);
4196 }
4197 
4198 /// Return true if "icmp Pred LHS RHS" is always true.
4200  const Value *LHS, const Value *RHS,
4201  const DataLayout &DL, unsigned Depth,
4202  AssumptionCache *AC, const Instruction *CxtI,
4203  const DominatorTree *DT) {
4204  assert(!LHS->getType()->isVectorTy() && "TODO: extend to handle vectors!");
4205  if (ICmpInst::isTrueWhenEqual(Pred) && LHS == RHS)
4206  return true;
4207 
4208  switch (Pred) {
4209  default:
4210  return false;
4211 
4212  case CmpInst::ICMP_SLE: {
4213  const APInt *C;
4214 
4215  // LHS s<= LHS +_{nsw} C if C >= 0
4216  if (match(RHS, m_NSWAdd(m_Specific(LHS), m_APInt(C))))
4217  return !C->isNegative();
4218  return false;
4219  }
4220 
4221  case CmpInst::ICMP_ULE: {
4222  const APInt *C;
4223 
4224  // LHS u<= LHS +_{nuw} C for any C
4225  if (match(RHS, m_NUWAdd(m_Specific(LHS), m_APInt(C))))
4226  return true;
4227 
4228  // Match A to (X +_{nuw} CA) and B to (X +_{nuw} CB)
4229  auto MatchNUWAddsToSameValue = [&](const Value *A, const Value *B,
4230  const Value *&X,
4231  const APInt *&CA, const APInt *&CB) {
4232  if (match(A, m_NUWAdd(m_Value(X), m_APInt(CA))) &&
4233  match(B, m_NUWAdd(m_Specific(X), m_APInt(CB))))
4234  return true;
4235 
4236  // If X & C == 0 then (X | C) == X +_{nuw} C
4237  if (match(A, m_Or(m_Value(X), m_APInt(CA))) &&
4238  match(B, m_Or(m_Specific(X), m_APInt(CB)))) {
4239  unsigned BitWidth = CA->getBitWidth();
4240  APInt KnownZero(BitWidth, 0), KnownOne(BitWidth, 0);
4241  computeKnownBits(X, KnownZero, KnownOne, DL, Depth + 1, AC, CxtI, DT);
4242 
4243  if ((KnownZero & *CA) == *CA && (KnownZero & *CB) == *CB)
4244  return true;
4245  }
4246 
4247  return false;
4248  };
4249 
4250  const Value *X;
4251  const APInt *CLHS, *CRHS;
4252  if (MatchNUWAddsToSameValue(LHS, RHS, X, CLHS, CRHS))
4253  return CLHS->ule(*CRHS);
4254 
4255  return false;
4256  }
4257  }
4258 }
4259 
4260 /// Return true if "icmp Pred BLHS BRHS" is true whenever "icmp Pred
4261 /// ALHS ARHS" is true. Otherwise, return None.
4262 static Optional<bool>
4264  const Value *ARHS, const Value *BLHS,
4265  const Value *BRHS, const DataLayout &DL,
4266  unsigned Depth, AssumptionCache *AC,
4267  const Instruction *CxtI, const DominatorTree *DT) {
4268  switch (Pred) {
4269  default:
4270  return None;
4271 
4272  case CmpInst::ICMP_SLT:
4273  case CmpInst::ICMP_SLE:
4274  if (isTruePredicate(CmpInst::ICMP_SLE, BLHS, ALHS, DL, Depth, AC, CxtI,
4275  DT) &&
4276  isTruePredicate(CmpInst::ICMP_SLE, ARHS, BRHS, DL, Depth, AC, CxtI, DT))
4277  return true;
4278  return None;
4279 
4280  case CmpInst::ICMP_ULT:
4281  case CmpInst::ICMP_ULE:
4282  if (isTruePredicate(CmpInst::ICMP_ULE, BLHS, ALHS, DL, Depth, AC, CxtI,
4283  DT) &&
4284  isTruePredicate(CmpInst::ICMP_ULE, ARHS, BRHS, DL, Depth, AC, CxtI, DT))
4285  return true;
4286  return None;
4287  }
4288 }
4289 
4290 /// Return true if the operands of the two compares match. IsSwappedOps is true
4291 /// when the operands match, but are swapped.
4292 static bool isMatchingOps(const Value *ALHS, const Value *ARHS,
4293  const Value *BLHS, const Value *BRHS,
4294  bool &IsSwappedOps) {
4295 
4296  bool IsMatchingOps = (ALHS == BLHS && ARHS == BRHS);
4297  IsSwappedOps = (ALHS == BRHS && ARHS == BLHS);
4298  return IsMatchingOps || IsSwappedOps;
4299 }
4300 
4301 /// Return true if "icmp1 APred ALHS ARHS" implies "icmp2 BPred BLHS BRHS" is
4302 /// true. Return false if "icmp1 APred ALHS ARHS" implies "icmp2 BPred BLHS
4303 /// BRHS" is false. Otherwise, return None if we can't infer anything.
4305  const Value *ALHS,
4306  const Value *ARHS,
4307  CmpInst::Predicate BPred,
4308  const Value *BLHS,
4309  const Value *BRHS,
4310  bool IsSwappedOps) {
4311  // Canonicalize the operands so they're matching.
4312  if (IsSwappedOps) {
4313  std::swap(BLHS, BRHS);
4314  BPred = ICmpInst::getSwappedPredicate(BPred);
4315  }
4316  if (CmpInst::isImpliedTrueByMatchingCmp(APred, BPred))
4317  return true;
4318  if (CmpInst::isImpliedFalseByMatchingCmp(APred, BPred))
4319  return false;
4320 
4321  return None;
4322 }
4323 
4324 /// Return true if "icmp1 APred ALHS C1" implies "icmp2 BPred BLHS C2" is
4325 /// true. Return false if "icmp1 APred ALHS C1" implies "icmp2 BPred BLHS
4326 /// C2" is false. Otherwise, return None if we can't infer anything.
4327 static Optional<bool>
4329  const ConstantInt *C1,
4330  CmpInst::Predicate BPred,
4331  const Value *BLHS, const ConstantInt *C2) {
4332  assert(ALHS == BLHS && "LHS operands must match.");
4333  ConstantRange DomCR =
4335  ConstantRange CR =
4337  ConstantRange Intersection = DomCR.intersectWith(CR);
4338  ConstantRange Difference = DomCR.difference(CR);
4339  if (Intersection.isEmptySet())
4340  return false;
4341  if (Difference.isEmptySet())
4342  return true;
4343  return None;
4344 }
4345 
4346 Optional<bool> llvm::isImpliedCondition(const Value *LHS, const Value *RHS,
4347  const DataLayout &DL, bool InvertAPred,
4348  unsigned Depth, AssumptionCache *AC,
4349  const Instruction *CxtI,
4350  const DominatorTree *DT) {
4351  // A mismatch occurs when we compare a scalar cmp to a vector cmp, for example.
4352  if (LHS->getType() != RHS->getType())
4353  return None;
4354 
4355  Type *OpTy = LHS->getType();
4356  assert(OpTy->getScalarType()->isIntegerTy(1));
4357 
4358  // LHS ==> RHS by definition
4359  if (!InvertAPred && LHS == RHS)
4360  return true;
4361 
4362  if (OpTy->isVectorTy())
4363  // TODO: extending the code below to handle vectors
4364  return None;
4365  assert(OpTy->isIntegerTy(1) && "implied by above");
4366 
4367  ICmpInst::Predicate APred, BPred;
4368  Value *ALHS, *ARHS;
4369  Value *BLHS, *BRHS;
4370 
4371  if (!match(LHS, m_ICmp(APred, m_Value(ALHS), m_Value(ARHS))) ||
4372  !match(RHS, m_ICmp(BPred, m_Value(BLHS), m_Value(BRHS))))
4373  return None;
4374 
4375  if (InvertAPred)
4376  APred = CmpInst::getInversePredicate(APred);
4377 
4378  // Can we infer anything when the two compares have matching operands?
4379  bool IsSwappedOps;
4380  if (isMatchingOps(ALHS, ARHS, BLHS, BRHS, IsSwappedOps)) {
4382  APred, ALHS, ARHS, BPred, BLHS, BRHS, IsSwappedOps))
4383  return Implication;
4384  // No amount of additional analysis will infer the second condition, so
4385  // early exit.
4386  return None;
4387  }
4388 
4389  // Can we infer anything when the LHS operands match and the RHS operands are
4390  // constants (not necessarily matching)?
4391  if (ALHS == BLHS && isa<ConstantInt>(ARHS) && isa<ConstantInt>(BRHS)) {
4393  APred, ALHS, cast<ConstantInt>(ARHS), BPred, BLHS,
4394  cast<ConstantInt>(BRHS)))
4395  return Implication;
4396  // No amount of additional analysis will infer the second condition, so
4397  // early exit.
4398  return None;
4399  }
4400 
4401  if (APred == BPred)
4402  return isImpliedCondOperands(APred, ALHS, ARHS, BLHS, BRHS, DL, Depth, AC,
4403  CxtI, DT);
4404 
4405  return None;
4406 }
MachineLoop * L
void clearAllBits()
Set every bit to 0.
Definition: APInt.h:1221
static unsigned getBitWidth(Type *Ty, const DataLayout &DL)
Returns the bitwidth of the given scalar or pointer type (if unknown returns 0).
const Value * getGuaranteedNonFullPoisonOp(const Instruction *I)
Return either nullptr or an operand of I such that I will trigger undefined behavior if I is executed...
static Constant * getFPTrunc(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:1601
const NoneType None
Definition: None.h:23
static bool isAddOfNonZero(const Value *V1, const Value *V2, const Query &Q)
Return true if V2 == V1 + X, where X is known non-zero.
BinaryOp_match< LHS, RHS, Instruction::And > m_And(const LHS &L, const RHS &R)
Definition: PatternMatch.h:506
static cl::opt< ITMode > IT(cl::desc("IT block support"), cl::Hidden, cl::init(DefaultIT), cl::ZeroOrMore, cl::values(clEnumValN(DefaultIT,"arm-default-it","Generate IT block based on arch"), clEnumValN(RestrictedIT,"arm-restrict-it","Disallow deprecated IT based on ARMv8"), clEnumValN(NoRestrictedIT,"arm-no-restrict-it","Allow IT blocks based on ARMv7")))
SymbolTableList< Instruction >::iterator eraseFromParent()
This method unlinks 'this' from the containing basic block and deletes it.
Definition: Instruction.cpp:76
bool isImpliedTrueByMatchingCmp(Predicate Pred2)
Determine if Pred1 implies Pred2 is true when two compares have matching operands.
Definition: InstrTypes.h:1064
void computeKnownBits(const 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...
Type * getSourceElementType() const
Definition: Operator.cpp:9
OverflowingBinaryOp_match< LHS, RHS, Instruction::Sub, OverflowingBinaryOperator::NoSignedWrap > m_NSWSub(const LHS &L, const RHS &R)
Definition: PatternMatch.h:577
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:102
bool isKnownToBeAPowerOfTwo(const Value *V, const DataLayout &DL, bool OrZero=false, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr)
Return true if the given value is known to have exactly one bit set when defined. ...
Instruction::CastOps getOpcode() const
Return the opcode of this CastInst.
Definition: InstrTypes.h:840
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:870
static APInt getSignBit(unsigned BitWidth)
Get the SignBit for a specific bit width.
Definition: APInt.h:451
cst_pred_ty< is_sign_bit > m_SignBit()
Match an integer or vector with only the sign bit(s) set.
Definition: PatternMatch.h:262
APInt byteSwap() const
Definition: APInt.cpp:744
static bool isKnownToBeAPowerOfTwo(const Value *V, bool OrZero, unsigned Depth, const Query &Q)
Return true if the given value is known to have exactly one bit set when defined. ...
This instruction extracts a struct member or array element value from an aggregate value...
static APInt getAllOnesValue(unsigned numBits)
Get the all-ones value.
Definition: APInt.h:458
LLVM Argument representation.
Definition: Argument.h:34
Value * getAggregateOperand()
uint64_t getZExtValue() const
Get zero extended value.
Definition: APInt.h:1309
static void computeKnownBitsFromOperator(const Operator *I, APInt &KnownZero, APInt &KnownOne, unsigned Depth, const Query &Q)
Unsigned minimum.
bool hasValue() const
Definition: Optional.h:125
static bool MaskedValueIsZero(const Value *V, const APInt &Mask, unsigned Depth, const Query &Q)
Return true if 'V & Mask' is known to be zero.
size_t i
Value * isBytewiseValue(Value *V)
If the specified value can be set by repeating the same byte in memory, return the i8 value that it i...
static bool isKnownNonEqual(const Value *V1, const Value *V2, const Query &Q)
Return true if it is known that V1 != V2.
Intrinsic::ID getIntrinsicID() const
Return the intrinsic ID of this intrinsic.
Definition: IntrinsicInst.h:51
an instruction that atomically checks whether a specified value is in a memory location, and, if it is, stores a new value there.
Definition: Instructions.h:504
match_zero m_Zero()
Match an arbitrary zero/null constant.
Definition: PatternMatch.h:137
Constant * getSplatValue() const
If this is a splat vector constant, meaning that all of the elements have the same value...
Definition: Constants.cpp:1290
bool isLoopHeader(const BlockT *BB) const
Definition: LoopInfo.h:590
void setBit(unsigned bitPosition)
Set a given bit to 1.
Definition: APInt.cpp:553
uint64_t GetStringLength(const Value *V)
If we can compute the length of the string pointed to by the specified pointer, return 'len+1'...
bool isKnownNotFullPoison(const Instruction *PoisonI)
Return true if this function can prove that if PoisonI is executed and yields a full-poison value (al...
This class represents zero extension of integer types.
unsigned getNumOperands() const
Definition: User.h:167
unsigned getNumOperands() const
Return number of MDNode operands.
Definition: Metadata.h:1040
match_combine_or< BinaryOp_match< LHS, RHS, Instruction::Xor >, BinaryOp_match< RHS, LHS, Instruction::Xor > > m_c_Xor(const LHS &L, const RHS &R)
Matches an Xor with LHS and RHS in either order.
bool hasNoSignedWrap() const
Test whether this operation is known to never undergo signed overflow, aka the nsw property...
Definition: Operator.h:104
unsigned getPointerTypeSizeInBits(Type *) const
Layout pointer size, in bits, based on the type.
Definition: DataLayout.cpp:617
BinaryOp_match< LHS, RHS, Instruction::Mul > m_Mul(const LHS &L, const RHS &R)
Definition: PatternMatch.h:458
iterator end() const
Definition: ArrayRef.h:130
bool isNonNegative() const
Determine if this APInt Value is non-negative (>= 0)
Definition: APInt.h:329
This class represents a function call, abstracting a target machine's calling convention.
bool isIntrinsic() const
isIntrinsic - Returns true if the function's name starts with "llvm.".
Definition: Function.h:151
This file contains the declarations for metadata subclasses.
size_type count(PtrType Ptr) const
count - Return 1 if the specified pointer is in the set, 0 otherwise.
Definition: SmallPtrSet.h:380
static APInt getLowBitsSet(unsigned numBits, unsigned loBitsSet)
Get a value with low bits set.
Definition: APInt.h:536
Predicate getInversePredicate() const
For example, EQ -> NE, UGT -> ULE, SLT -> SGE, OEQ -> UNE, UGT -> OLE, OLT -> UGE, etc.
Definition: InstrTypes.h:984
static uint64_t round(uint64_t Acc, uint64_t Input)
Definition: xxhash.cpp:57
gep_type_iterator gep_type_end(const User *GEP)
unsigned less or equal
Definition: InstrTypes.h:906
unsigned less than
Definition: InstrTypes.h:905
BinaryOp_match< LHS, RHS, Instruction::AShr > m_AShr(const LHS &L, const RHS &R)
Definition: PatternMatch.h:536
An efficient, type-erasing, non-owning reference to a callable.
Definition: STLExtras.h:83
bool isSigned() const
Determine if this instruction is using a signed comparison.
Definition: InstrTypes.h:1027
A cache of .assume calls within a function.
0 1 0 0 True if ordered and less than
Definition: InstrTypes.h:886
static void computeKnownBitsMul(const Value *Op0, const Value *Op1, bool NSW, APInt &KnownZero, APInt &KnownOne, APInt &KnownZero2, APInt &KnownOne2, unsigned Depth, const Query &Q)
Function Alias Analysis Results
bool onlyReadsMemory() const
Determine if the call does not access or only reads memory.
Definition: CallSite.h:429
uint64_t getLimitedValue(uint64_t Limit=~0ULL) const
If this value is smaller than the specified limit, return it, otherwise return the limit value...
Definition: APInt.h:409
static bool isOrdered(Predicate predicate)
Determine if the predicate is an ordered operation.
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:736
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:100
void setAllBits()
Set every bit to 1.
Definition: APInt.h:1203
bool isValidAssumeForContext(const Instruction *I, const Instruction *CxtI, const DominatorTree *DT=nullptr)
Return true if it is valid to use the assumptions provided by an assume intrinsic, I, at the point in the control-flow identified by the context instruction, CxtI.
Metadata node.
Definition: Metadata.h:830
An instruction for reading from memory.
Definition: Instructions.h:164
static IntegerType * getInt64Ty(LLVMContext &C)
Definition: Type.cpp:170
an instruction that atomically reads a memory location, combines it with another value, and then stores the result back.
Definition: Instructions.h:669
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
LoopT * getLoopFor(const BlockT *BB) const
Return the inner most loop that BB lives in.
Definition: LoopInfo.h:575
static ConstantRange makeAllowedICmpRegion(CmpInst::Predicate Pred, const ConstantRange &Other)
Produce the smallest range such that all values that may satisfy the given predicate with any value c...
match_combine_or< BinaryOp_match< LHS, RHS, Instruction::And >, BinaryOp_match< RHS, LHS, Instruction::And > > m_c_And(const LHS &L, const RHS &R)
Matches an And with LHS and RHS in either order.
void reserve(size_type N)
Definition: SmallVector.h:377
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
bool isExact() const
Test whether this division is known to be exact, with zero remainder.
Definition: Operator.h:144
APInt zextOrTrunc(unsigned width) const
Zero extend or truncate to width.
Definition: APInt.cpp:999
std::size_t countLeadingZeros(T Val, ZeroBehavior ZB=ZB_Width)
Count number of 0's from the most significant bit to the least stopping at the first 1...
Definition: MathExtras.h:180
BlockT * getHeader() const
Definition: LoopInfo.h:102
bool isEquality() const
This is just a convenience that dispatches to the subclasses.
static APInt getSignedMaxValue(unsigned numBits)
Gets maximum signed value of APInt for a specific bit width.
Definition: APInt.h:431
static OverflowResult computeOverflowForSignedAdd(const Value *LHS, const Value *RHS, const AddOperator *Add, const DataLayout &DL, AssumptionCache *AC, const Instruction *CxtI, const DominatorTree *DT)
bool propagatesFullPoison(const Instruction *I)
Return true if this function can prove that I is guaranteed to yield full-poison (all bits poison) if...
Signed maximum.
uint64_t getArrayNumElements() const
Definition: DerivedTypes.h:364
static Constant * getNullValue(Type *Ty)
Constructor to create a '0' constant of arbitrary type.
Definition: Constants.cpp:195
Intrinsic::ID getIntrinsicForCallSite(ImmutableCallSite ICS, const TargetLibraryInfo *TLI)
Map a call instruction to an intrinsic ID.
A templated base class for SmallPtrSet which provides the typesafe interface that is common across al...
Definition: SmallPtrSet.h:345
ArrayType * getType() const
Specialize the getType() method to always return an ArrayType, which reduces the amount of casting ne...
Definition: Constants.h:723
bool isNegative() const
Determine sign of this APInt.
Definition: APInt.h:324
ArrayRef< unsigned > getIndices() const
bool match(Val *V, const Pattern &P)
Definition: PatternMatch.h:41
ArrayRef< T > slice(size_t N, size_t M) const
slice(n, m) - Chop off the first N elements of the array, and keep M elements in the array...
Definition: ArrayRef.h:171
match_combine_or< BinaryOp_match< LHS, RHS, Instruction::Or >, BinaryOp_match< RHS, LHS, Instruction::Or > > m_c_Or(const LHS &L, const RHS &R)
Matches an Or with LHS and RHS in either order.
Used to lazily calculate structure layout information for a target machine, based on the DataLayout s...
Definition: DataLayout.h:496
static Constant * getIntegerCast(Constant *C, Type *Ty, bool isSigned)
Create a ZExt, Bitcast or Trunc for integer -> integer casts.
Definition: Constants.cpp:1535
static Value * getPointerOperand(Instruction &Inst)
static Type * getIndexedType(Type *Agg, ArrayRef< unsigned > Idxs)
Returns the type of the element that would be extracted with an extractvalue instruction with the spe...
This class represents the LLVM 'select' instruction.
bool noSignedZeros() const
Definition: Operator.h:196
unsigned getPointerAlignment(const DataLayout &DL) const
Returns an alignment of the pointer value.
Definition: Value.cpp:599
Absolute value.
This is the base class for all instructions that perform data casts.
Definition: InstrTypes.h:578
const APInt & getValue() const
Return the constant as an APInt value reference.
Definition: Constants.h:143
bool isUnordered() const
Definition: Instructions.h:264
ArrayRef< T > makeArrayRef(const T &OneElt)
Construct an ArrayRef from a single element.
Definition: ArrayRef.h:440
Exact_match< T > m_Exact(const T &SubPattern)
Definition: PatternMatch.h:691
void computeKnownBitsFromRangeMetadata(const MDNode &Ranges, APInt &KnownZero, APInt &KnownOne)
Compute known bits from the range metadata.
static bool isAssumeLikeIntrinsic(const Instruction *I)
Class to represent struct types.
Definition: DerivedTypes.h:199
BinOp2_match< LHS, RHS, Instruction::LShr, Instruction::AShr > m_Shr(const LHS &L, const RHS &R)
Matches LShr or AShr.
Definition: PatternMatch.h:658
A Use represents the edge between a Value definition and its users.
Definition: Use.h:56
APInt lshr(unsigned shiftAmt) const
Logical right-shift function.
Definition: APInt.cpp:1122
Instruction * getFirstNonPHI()
Returns a pointer to the first instruction in this block that is not a PHINode instruction.
Definition: BasicBlock.cpp:180
unsigned getNumIndices() const
0 1 0 1 True if ordered and less than or equal
Definition: InstrTypes.h:887
NaN behavior not applicable.
bool isLoopInvariant(const Value *V) const
Return true if the specified value is loop invariant.
Definition: LoopInfo.cpp:55
not_match< LHS > m_Not(const LHS &L)
Definition: PatternMatch.h:854
bool isNegative() const
Definition: Constants.h:193
BinaryOp_match< LHS, RHS, Instruction::Add > m_Add(const LHS &L, const RHS &R)
Definition: PatternMatch.h:434
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:60
bool getBoolValue() const
Convert APInt to a boolean value.
Definition: APInt.h:405
APInt lshr(const APInt &LHS, unsigned shiftAmt)
Logical right-shift function.
Definition: APInt.h:1892
uint64_t getZExtValue() const
Return the constant as a 64-bit unsigned integer value after it has been zero extended as appropriate...
Definition: Constants.h:154
static bool isEphemeralValueOf(const Instruction *I, const Value *E)
static Constant * getZExt(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:1587
OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoUnsignedWrap > m_NUWAdd(const LHS &L, const RHS &R)
Definition: PatternMatch.h:602
A constant value that is initialized with an expression using other constant values.
Definition: Constants.h:873
#define F(x, y, z)
Definition: MD5.cpp:51
match_combine_or< LTy, RTy > m_CombineOr(const LTy &L, const RTy &R)
Combine two pattern matchers matching L || R.
Definition: PatternMatch.h:117
ConstantDataSequential - A vector or array constant whose element type is a simple 1/2/4/8-byte integ...
Definition: Constants.h:564
Value * GetPointerBaseWithConstantOffset(Value *Ptr, int64_t &Offset, const DataLayout &DL)
Analyze the specified pointer to see if it can be expressed as a base pointer plus a constant offset...
Class to represent array types.
Definition: DerivedTypes.h:345
match_combine_or< CmpClass_match< LHS, RHS, ICmpInst, ICmpInst::Predicate >, CmpClass_match< RHS, LHS, ICmpInst, ICmpInst::Predicate > > m_c_ICmp(ICmpInst::Predicate &Pred, const LHS &L, const RHS &R)
Matches an ICmp with a predicate over LHS and RHS in either order.
static SelectPatternResult matchSelectPattern(CmpInst::Predicate Pred, FastMathFlags FMF, Value *CmpLHS, Value *CmpRHS, Value *TrueVal, Value *FalseVal, Value *&LHS, Value *&RHS)
class_match< ConstantInt > m_ConstantInt()
Match an arbitrary ConstantInt and ignore it.
Definition: PatternMatch.h:75
static GCRegistry::Add< OcamlGC > B("ocaml","ocaml 3.10-compatible GC")
const Function * getFunction() const
Return the function this instruction belongs to.
Definition: Instruction.cpp:68
An instruction for storing to memory.
Definition: Instructions.h:300
bool isGEPBasedOnPointerToString(const GEPOperator *GEP)
Returns true if the GEP is based on a pointer to a string (array of i8), and is indexing into this st...
bool haveNoCommonBitsSet(const Value *LHS, const Value *RHS, const DataLayout &DL, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr)
Return true if LHS and RHS have no common bits set.
bool hasDefinitiveInitializer() const
hasDefinitiveInitializer - Whether the global variable has an initializer, and any other instances of...
bool isArrayTy() const
True if this is an instance of ArrayType.
Definition: Type.h:210
APInt umul_ov(const APInt &RHS, bool &Overflow) const
Definition: APInt.cpp:2025
APInt ashr(const APInt &LHS, unsigned shiftAmt)
Arithmetic right-shift function.
Definition: APInt.h:1885
static Optional< bool > isImpliedCondOperands(CmpInst::Predicate Pred, const Value *ALHS, const Value *ARHS, const Value *BLHS, const Value *BRHS, const DataLayout &DL, unsigned Depth, AssumptionCache *AC, const Instruction *CxtI, const DominatorTree *DT)
Return true if "icmp Pred BLHS BRHS" is true whenever "icmp Pred ALHS ARHS" is true.
static unsigned ComputeNumSignBits(const Value *V, unsigned Depth, const Query &Q)
Return the number of times the sign bit of the register is replicated into the other bits...
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t size() const
size - Get the string size.
Definition: StringRef.h:135
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree...
Definition: Dominators.h:96
Type * getScalarType() const LLVM_READONLY
If this is a vector type, return the element type, otherwise return 'this'.
Definition: Type.cpp:44
int Switch(int a)
Definition: Switch2Test.cpp:11
Type * getElementType() const
Definition: DerivedTypes.h:336
size_t size() const
size - Get the array size.
Definition: ArrayRef.h:141
Maximum length of the test input libFuzzer tries to guess a good value based on the corpus and reports it always prefer smaller inputs during the corpus shuffle When libFuzzer itself reports a bug this exit code will be used If indicates the maximal total time in seconds to run the fuzzer minimizes the provided crash input Use with etc Experimental Use value profile to guide fuzzing Number of simultaneous worker processes to run the jobs If min(jobs, NumberOfCpuCores()/2)\" is used.") FUZZER_FLAG_INT(reload
bool mayReadOrWriteMemory() const
Return true if this instruction may read or write memory.
Definition: Instruction.h:416
bool CannotBeNegativeZero(const Value *V, const TargetLibraryInfo *TLI, unsigned Depth=0)
Return true if we can prove that the specified FP value is never equal to -0.0.
static GCRegistry::Add< CoreCLRGC > E("coreclr","CoreCLR-compatible GC")
unsigned getNumIncomingValues() const
Return the number of incoming edges.
SelectPatternResult matchSelectPattern(Value *V, Value *&LHS, Value *&RHS, Instruction::CastOps *CastOp=nullptr)
Pattern match integer [SU]MIN, [SU]MAX and ABS idioms, returning the kind and providing the out param...
static bool isKnownNonNaN(const Value *V, FastMathFlags FMF)
uint64_t getElementOffset(unsigned Idx) const
Definition: DataLayout.h:517
static APInt getHighBitsSet(unsigned numBits, unsigned hiBitsSet)
Get a value with high bits set.
Definition: APInt.h:518
static Constant * getBitCast(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:1695
bool isSized(SmallPtrSetImpl< Type * > *Visited=nullptr) const
Return true if it makes sense to take the size of this type.
Definition: Type.h:254
bool getLibFunc(StringRef funcName, LibFunc::Func &F) const
Searches for a particular function name.
#define P(N)
bool isIntOrIntVectorTy() const
Return true if this is an integer type or a vector of integer types.
Definition: Type.h:201
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:395
bool isGuaranteedToTransferExecutionToSuccessor(const Instruction *I)
Return true if this function can prove that the instruction I will always transfer execution to one o...
BinaryOp_match< LHS, RHS, Instruction::LShr > m_LShr(const LHS &L, const RHS &R)
Definition: PatternMatch.h:530
static bool isSameUnderlyingObjectInLoop(const PHINode *PN, const LoopInfo *LI)
PN defines a loop-variant pointer to an object.
OverflowResult computeOverflowForSignedAdd(const Value *LHS, const Value *RHS, const DataLayout &DL, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr)
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
static uint64_t GetStringLengthH(const Value *V, SmallPtrSetImpl< const PHINode * > &PHIs)
If we can compute the length of the string pointed to by the specified pointer, return 'len+1'...
ConstantRange intersectWith(const ConstantRange &CR) const
Return the range that results from the intersection of this range with another range.
std::size_t countTrailingZeros(T Val, ZeroBehavior ZB=ZB_Width)
Count number of 0's from the least significant bit to the most stopping at the first 1...
Definition: MathExtras.h:111
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE size_t find(char C, size_t From=0) const
Search for the first character C in the string.
Definition: StringRef.h:295
APInt trunc(unsigned width) const
Truncate to new width.
Definition: APInt.cpp:916
An array constant whose element type is a simple 1/2/4/8-byte integer or float/double, and whose elements are just simple data values (i.e.
Definition: Constants.h:676
LLVM Basic Block Representation.
Definition: BasicBlock.h:51
Value * hasConstantValue() const
If the specified PHI node always merges together the same value, return the value, otherwise return null.
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
Conditional or Unconditional Branch instruction.
bool isVectorTy() const
True if this is an instance of VectorType.
Definition: Type.h:219
bool isKnownNonNegative(const Value *V, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr)
Returns true if the give value is known to be non-negative.
Type * getElementType(unsigned N) const
Definition: DerivedTypes.h:290
CastClass_match< OpTy, Instruction::BitCast > m_BitCast(const OpTy &Op)
Matches BitCast.
Definition: PatternMatch.h:789
This is an important base class in LLVM.
Definition: Constant.h:42
bool isMaxSignedValue() const
Determine if this is the largest signed value.
Definition: APInt.h:358
const Value * getCondition() const
int64_t getSExtValue() const
Get sign extended value.
Definition: APInt.h:1321
SmallSet - This maintains a set of unique values, optimizing for the case when the set is small (less...
Definition: SmallSet.h:36
This file contains the declarations for the subclasses of Constant, which represent the different fla...
bool onlyUsedByLifetimeMarkers(const Value *V)
Return true if the only users of this pointer are lifetime markers.
bool MaskedValueIsZero(const Value *V, const APInt &Mask, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr)
Return true if 'V & Mask' is known to be zero.
APInt Or(const APInt &LHS, const APInt &RHS)
Bitwise OR function for APInt.
Definition: APInt.h:1947
unsigned getAlignment() const
Return the alignment of the memory that is being allocated by the instruction.
Definition: Instructions.h:109
ConstantFP - Floating Point Values [float, double].
Definition: Constants.h:269
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:368
APInt Xor(const APInt &LHS, const APInt &RHS)
Bitwise XOR function for APInt.
Definition: APInt.h:1952
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE StringRef substr(size_t Start, size_t N=npos) const
Return a reference to the substring from [Start, Start + N).
Definition: StringRef.h:587
bool isZeroValue() const
Return true if the value is negative zero or null value.
Definition: Constants.cpp:70
bool isOverflowIntrinsicNoWrap(const IntrinsicInst *II, const DominatorTree &DT)
Returns true if the arithmetic part of the II 's result is used only along the paths control dependen...
specificval_ty m_Specific(const Value *V)
Match if we have a specific specified value.
Definition: PatternMatch.h:322
static SelectPatternResult matchMinMax(CmpInst::Predicate Pred, Value *CmpLHS, Value *CmpRHS, Value *TrueVal, Value *FalseVal, Value *&LHS, Value *&RHS)
Match non-obvious integer minimum and maximum sequences.
A udiv or sdiv instruction, which can be marked as "exact", indicating that no bits are destroyed...
Definition: Operator.h:128
static bool isGEPKnownNonNull(const GEPOperator *GEP, unsigned Depth, const Query &Q)
Test whether a GEP's result is known to be non-null.
BinaryOp_match< LHS, RHS, Instruction::Shl > m_Shl(const LHS &L, const RHS &R)
Definition: PatternMatch.h:524
bool any_of(R &&Range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:743
uint32_t Offset
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang","erlang-compatible garbage collector")
Predicate
This enumeration lists the possible predicates for CmpInst subclasses.
Definition: InstrTypes.h:880
Utility class for integer arithmetic operators which may exhibit overflow - Add, Sub, and Mul.
Definition: Operator.h:75
unsigned getBitWidth() const
Return the number of bits in the APInt.
Definition: APInt.h:1255
static const unsigned End
static bool isKnownNonNullFromDominatingCondition(const Value *V, const Instruction *CtxI, const DominatorTree *DT)
iterator begin() const
Definition: ArrayRef.h:129
Value * getPointerOperand()
Definition: Operator.h:401
Value * getOperand(unsigned i) const
Definition: User.h:145
op_range operands()
Definition: User.h:213
Value * getPointerOperand()
Definition: Instructions.h:270
self_iterator getIterator()
Definition: ilist_node.h:81
Class to represent integer types.
Definition: DerivedTypes.h:39
std::pair< NoneType, bool > insert(const T &V)
insert - Insert an element into the set if it isn't already there.
Definition: SmallSet.h:80
Type * getSrcTy() const
Return the source type, as a convenience.
Definition: InstrTypes.h:845
unsigned countPopulation() const
Count the number of bits set.
Definition: APInt.h:1397
SelectPatternNaNBehavior
Behavior when a floating point min/max is given one NaN and one non-NaN as input. ...
Predicate getPredicate() const
Return the predicate for this instruction.
Definition: InstrTypes.h:960
Optional< bool > isImpliedCondition(const Value *LHS, const Value *RHS, const DataLayout &DL, bool InvertAPred=false, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr)
Return true if RHS is known to be implied true by LHS.
bool empty() const
empty - Check if the array is empty.
Definition: ArrayRef.h:136
Constant * getAggregateElement(unsigned Elt) const
For aggregates (struct/array/vector) return the constant that corresponds to the specified element if...
Definition: Constants.cpp:265
void append(in_iter in_start, in_iter in_end)
Add the specified range to the end of the SmallVector.
Definition: SmallVector.h:392
bool isEmptySet() const
Return true if this set contains no members.
ConstantRange difference(const ConstantRange &CR) const
Subtract the specified range from this range (aka relative complement of the sets).
bool isPointerTy() const
True if this is an instance of PointerType.
Definition: Type.h:213
static UndefValue * get(Type *T)
Static factory methods - Return an 'undef' object of the specified type.
Definition: Constants.cpp:1337
LLVMContext & getContext() const
All values hold a context through their type.
Definition: Value.cpp:654
static Value * BuildSubAggregate(Value *From, Value *To, Type *IndexedType, SmallVectorImpl< unsigned > &Idxs, unsigned IdxSkip, Instruction *InsertBefore)
const Value * getTrueValue() const
bool isPowerOf2() const
Check if this APInt's value is a power of two greater than zero.
Definition: APInt.h:391
1 1 0 1 True if unordered, less than, or equal
Definition: InstrTypes.h:895
Value * GetUnderlyingObject(Value *V, const DataLayout &DL, unsigned MaxLookup=6)
This method strips off any GEP address adjustments and pointer casts from the specified value...
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
static bool isTruePredicate(CmpInst::Predicate Pred, const Value *LHS, const Value *RHS, const DataLayout &DL, unsigned Depth, AssumptionCache *AC, const Instruction *CxtI, const DominatorTree *DT)
Return true if "icmp Pred LHS RHS" is always true.
LLVM_READONLY APFloat maxnum(const APFloat &A, const APFloat &B)
Implements IEEE maxNum semantics.
Definition: APFloat.h:1118
signed greater than
Definition: InstrTypes.h:907
Value * FindInsertedValue(Value *V, ArrayRef< unsigned > idx_range, Instruction *InsertBefore=nullptr)
Given an aggregrate and an sequence of indices, see if the scalar value indexed is already around as ...
static unsigned computeNumSignBitsVectorConstant(const Value *V, unsigned TyBits)
For vector constants, loop over the elements and find the constant with the minimum number of sign bi...
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:218
Floating point maxnum.
size_type count(const T &V) const
count - Return 1 if the element is in the set, 0 otherwise.
Definition: SmallSet.h:64
const unsigned MaxDepth
Given one NaN input, returns the non-NaN.
0 0 1 0 True if ordered and greater than
Definition: InstrTypes.h:884
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
static Constant * getSIToFP(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:1636
BinaryOps getOpcode() const
Definition: InstrTypes.h:541
const MDOperand & getOperand(unsigned I) const
Definition: Metadata.h:1034
This is the common base class for memset/memcpy/memmove.
Iterator for intrusive lists based on ilist_node.
static ConstantRange makeExactICmpRegion(CmpInst::Predicate Pred, const APInt &Other)
Produce the exact range such that all values in the returned range satisfy the given predicate with a...
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements...
Definition: SmallPtrSet.h:425
This is the shared class of boolean and integer constants.
Definition: Constants.h:88
auto find(R &&Range, const T &Val) -> decltype(std::begin(Range))
Provide wrappers to std::find which take ranges instead of having to pass begin/end explicitly...
Definition: STLExtras.h:757
SelectPatternFlavor Flavor
unsigned ComputeNumSignBits(const Value *Op, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr)
Return the number of times the sign bit of the register is replicated into the other bits...
static void computeKnownBitsFromShiftOperator(const Operator *I, APInt &KnownZero, APInt &KnownOne, APInt &KnownZero2, APInt &KnownOne2, unsigned Depth, const Query &Q, function_ref< APInt(const APInt &, unsigned)> KZF, function_ref< APInt(const APInt &, unsigned)> KOF)
Value * getIncomingValue(unsigned i) const
Return incoming value number x.
iterator end()
Definition: BasicBlock.h:230
unsigned getScalarSizeInBits() const LLVM_READONLY
If this is a vector type, return the getPrimitiveSizeInBits value for the element type...
Definition: Type.cpp:123
const Module * getModule() const
Return the module owning the function this instruction belongs to or nullptr it the function does not...
Definition: Instruction.cpp:58
static void computeKnownBitsFromAssume(const Value *V, APInt &KnownZero, APInt &KnownOne, unsigned Depth, const Query &Q)
unsigned logBase2() const
Definition: APInt.h:1507
Unsigned maximum.
1 1 0 0 True if unordered or less than
Definition: InstrTypes.h:894
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:843
Utility class for floating point operations which can have information about relaxed accuracy require...
Definition: Operator.h:220
This is a utility class that provides an abstraction for the common functionality between Instruction...
Definition: Operator.h:33
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:230
SelectPatternFlavor
Specific patterns of select instructions we can match.
Provides information about what library functions are available for the current target.
static Optional< bool > isImpliedCondMatchingImmOperands(CmpInst::Predicate APred, const Value *ALHS, const ConstantInt *C1, CmpInst::Predicate BPred, const Value *BLHS, const ConstantInt *C2)
Return true if "icmp1 APred ALHS C1" implies "icmp2 BPred BLHS C2" is true.
This class represents a range of values.
Definition: ConstantRange.h:45
Floating point minnum.
BinaryOp_match< LHS, RHS, Instruction::UDiv > m_UDiv(const LHS &L, const RHS &R)
Definition: PatternMatch.h:470
signed less than
Definition: InstrTypes.h:909
bool isTrueWhenEqual() const
This is just a convenience.
Definition: InstrTypes.h:1052
LLVM_NODISCARD T pop_back_val()
Definition: SmallVector.h:382
Value * stripPointerCasts()
Strip off pointer casts, all-zero GEPs, and aliases.
Definition: Value.cpp:490
bool isStrictlyPositive() const
Determine if this APInt Value is positive.
Definition: APInt.h:337
Predicate getSwappedPredicate() const
For example, EQ->EQ, SLE->SGE, ULT->UGT, OEQ->OEQ, ULE->UGE, OLT->OGT, etc.
Definition: InstrTypes.h:1000
static Constant * getTrunc(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:1559
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:558
Function * getCalledFunction() const
Return the function called, or null if this is an indirect function invocation.
bool isZero() const
This is just a convenience method to make client code smaller for a common code.
Definition: Constants.h:198
bool isNullValue() const
Return true if this is the value that would be returned by getNullValue.
Definition: Constants.cpp:90
static ConstantInt * getTrue(LLVMContext &Context)
Definition: Constants.cpp:506
Intrinsic::ID getIntrinsicID() const LLVM_READONLY
getIntrinsicID - This method returns the ID number of the specified function, or Intrinsic::not_intri...
Definition: Function.h:146
OverflowingBinaryOp_match< LHS, RHS, Instruction::Add, OverflowingBinaryOperator::NoSignedWrap > m_NSWAdd(const LHS &L, const RHS &R)
Definition: PatternMatch.h:569
static GCRegistry::Add< ShadowStackGC > C("shadow-stack","Very portable GC for uncooperative code generators")
unsigned ceilLogBase2() const
Definition: APInt.h:1510
unsigned Log2_32(uint32_t Value)
Log2_32 - This function returns the floor log base 2 of the specified value, -1 if the value is zero...
Definition: MathExtras.h:513
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
Definition: BitVector.h:586
Value * getArgOperand(unsigned i) const
getArgOperand/setArgOperand - Return/set the i-th call argument.
signed less or equal
Definition: InstrTypes.h:910
static cl::opt< unsigned > DomConditionsMaxUses("dom-conditions-max-uses", cl::Hidden, cl::init(20))
Class for arbitrary precision integers.
Definition: APInt.h:77
BasicBlock * getSingleSuccessor()
Return the successor of this block if it has a single successor.
Definition: BasicBlock.cpp:253
bool isConstant() const
If the value is a global constant, its value is immutable throughout the runtime execution of the pro...
bool isIntegerTy() const
True if this is an instance of IntegerType.
Definition: Type.h:195
CastClass_match< OpTy, Instruction::PtrToInt > m_PtrToInt(const OpTy &Op)
Matches PtrToInt.
Definition: PatternMatch.h:795
iterator_range< user_iterator > users()
Definition: Value.h:370
BasicBlock * getSinglePredecessor()
Return the predecessor of this block if it has a single predecessor block.
Definition: BasicBlock.cpp:226
static Constant * getCast(unsigned ops, Constant *C, Type *Ty, bool OnlyIfReduced=false)
Convenience function for getting a Cast operation.
Definition: Constants.cpp:1452
static Constant * getFPToUI(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:1647
bool isFPPredicate() const
Definition: InstrTypes.h:977
APInt And(const APInt &LHS, const APInt &RHS)
Bitwise AND function for APInt.
Definition: APInt.h:1942
bool isStructTy() const
True if this is an instance of StructType.
Definition: Type.h:207
unsigned getOpcode() const
Return the opcode for this Instruction or ConstantExpr.
Definition: Operator.h:49
static Value * lookThroughCast(CmpInst *CmpI, Value *V1, Value *V2, Instruction::CastOps *CastOp)
bool isKnownNegative(const Value *V, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr)
Returns true if the given value is known be negative (i.e.
bool isAllOnesValue() const
Determine if all bits are set.
Definition: APInt.h:342
unsigned countLeadingOnes() const
Count the number of leading one bits.
Definition: APInt.cpp:676
bool isImpliedFalseByMatchingCmp(Predicate Pred2)
Determine if Pred1 implies Pred2 is false when two compares have matching operands.
Definition: InstrTypes.h:1070
static void computeKnownBitsAddSub(bool Add, const Value *Op0, const Value *Op1, bool NSW, APInt &KnownZero, APInt &KnownOne, APInt &KnownZero2, APInt &KnownOne2, unsigned Depth, const Query &Q)
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.cpp:384
bool isKnownNonNull(const Value *V)
Return true if this pointer couldn't possibly be null by its definition.
void ComputeSignBit(const Value *V, bool &KnownZero, bool &KnownOne, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr)
Determine whether the sign bit is known to be zero or one.
bool isMinSignedValue() const
Determine if this is the smallest signed value.
Definition: APInt.h:372
bool mayBeMemoryDependent(const Instruction &I)
Returns true if the result or effects of the given instructions I depend on or influence global memor...
bool hasFnAttribute(Attribute::AttrKind Kind) const
Return true if the function has the attribute.
Definition: Function.h:226
static IntegerType * getInt32Ty(LLVMContext &C)
Definition: Type.cpp:169
OverflowResult
bool isInBounds() const
Test whether this is an inbounds GEP, as defined by LangRef.html.
Definition: Operator.h:385
static bool isMinOrMax(SelectPatternFlavor SPF)
When implementing this min/max pattern as fcmp; select, does the fcmp have to be ordered?
unsigned greater or equal
Definition: InstrTypes.h:904
Represents a single loop in the control flow graph.
Definition: LoopInfo.h:368
unsigned getAlignment() const
Return the alignment of the access that is being performed.
Definition: Instructions.h:227
static InsertValueInst * Create(Value *Agg, Value *Val, ArrayRef< unsigned > Idxs, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
ImmutableCallSite - establish a view to a call site for examination.
Definition: CallSite.h:665
#define I(x, y, z)
Definition: MD5.cpp:54
bool SignBitMustBeZero(const Value *V, const TargetLibraryInfo *TLI)
LLVM_ATTRIBUTE_ALWAYS_INLINE size_type size() const
Definition: SmallVector.h:135
bool ComputeMultiple(Value *V, unsigned Base, Value *&Multiple, bool LookThroughSExt=false, unsigned Depth=0)
This function computes the integer multiple of Base that equals V.
static void Query(const MachineInstr &MI, AliasAnalysis &AA, bool &Read, bool &Write, bool &Effects, bool &StackPointer)
unsigned countTrailingOnes() const
Count the number of trailing one bits.
Definition: APInt.h:1385
LLVM_NODISCARD 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:287
unsigned getPointerAddressSpace() const
Method to return the address space of the pointer operand.
Definition: Operator.h:420
bool isKnownNonNullAt(const Value *V, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr)
Return true if this pointer couldn't possibly be null.
bool isGuaranteedToExecuteForEveryIteration(const Instruction *I, const Loop *L)
Return true if this function can prove that the instruction I is executed for every iteration of the ...
1 0 1 0 True if unordered or greater than
Definition: InstrTypes.h:892
OverflowResult computeOverflowForUnsignedMul(const Value *LHS, const Value *RHS, const DataLayout &DL, AssumptionCache *AC, const Instruction *CxtI, const DominatorTree *DT)
Signed minimum.
bool isKnownNonEqual(const Value *V1, const Value *V2, const DataLayout &DL, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr)
Return true if the given values are known to be non-equal when defined.
OverflowResult computeOverflowForUnsignedAdd(const Value *LHS, const Value *RHS, const DataLayout &DL, AssumptionCache *AC, const Instruction *CxtI, const DominatorTree *DT)
bool hasLocalLinkage() const
Definition: GlobalValue.h:415
bool getConstantStringInfo(const Value *V, StringRef &Str, uint64_t Offset=0, bool TrimAtNul=true)
This function computes the length of a null-terminated C string pointed to by V.
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 isUnsigned() const
Determine if this instruction is using an unsigned comparison.
Definition: InstrTypes.h:1033
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
Given one NaN input, returns the NaN.
bool isSafeToSpeculativelyExecute(const Value *V, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr)
Return true if the instruction does not have any effects besides calculating the result and does not ...
static bool cannotBeOrderedLessThanZeroImpl(const Value *V, const TargetLibraryInfo *TLI, bool SignBitOnly, unsigned Depth)
If SignBitOnly is true, test for a known 0 sign bit rather than a standard ordered compare...
FunTy * getCalledFunction() const
getCalledFunction - Return the function being called if this is a direct call, otherwise return null ...
Definition: CallSite.h:110
LLVM Value Representation.
Definition: Value.h:71
1 0 1 1 True if unordered, greater than, or equal
Definition: InstrTypes.h:893
unsigned getOpcode() const
Returns a member of one of the enums like Instruction::Add.
Definition: Instruction.h:111
static const Instruction * safeCxtI(const Value *V, const Instruction *CxtI)
cst_pred_ty< is_one > m_One()
Match an integer 1 or a vector with all elements equal to 1.
Definition: PatternMatch.h:244
#define LLVM_FALLTHROUGH
LLVM_FALLTHROUGH - Mark fallthrough cases in switch statements.
Definition: Compiler.h:239
static bool isKnownNonZero(const Value *V, unsigned Depth, const Query &Q)
Return true if the given value is known to be non-zero when defined.
std::underlying_type< E >::type Mask()
Get a bitmask with 1s in all places up to the high-order bit of E's largest value.
Definition: BitmaskEnum.h:81
bool isKnownPositive(const Value *V, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr)
Returns true if the given value is known be positive (i.e.
static Constant * getUIToFP(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:1625
static Constant * getFPToSI(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:1658
static bool isMatchingOps(const Value *ALHS, const Value *ARHS, const Value *BLHS, const Value *BRHS, bool &IsSwappedOps)
Return true if the operands of the two compares match.
unsigned countLeadingZeros() const
The APInt version of the countLeadingZeros functions in MathExtras.h.
Definition: APInt.h:1343
bool isKnownNonZero(const Value *V, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr)
Return true if the given value is known to be non-zero when defined.
const Value * getFalseValue() const
Convenience struct for specifying and reasoning about fast-math flags.
Definition: Operator.h:168
unsigned greater than
Definition: InstrTypes.h:903
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:47
APInt zext(unsigned width) const
Zero extend to a new width.
Definition: APInt.cpp:980
Value * SimplifyInstruction(Instruction *I, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr)
See if we can compute a simplified version of this instruction.
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml","ocaml 3.10-compatible collector")
bool CannotBeOrderedLessThanZero(const Value *V, const TargetLibraryInfo *TLI)
Return true if we can prove that the specified FP value is either a NaN or never less than 0...
bool isDereferenceableAndAlignedPointer(const Value *V, unsigned Align, const DataLayout &DL, const Instruction *CtxI=nullptr, const DominatorTree *DT=nullptr)
Returns true if V is always a dereferenceable pointer with alignment greater or equal than requested...
Definition: Loads.cpp:119
int * Ptr
APInt abs() const
Get the absolute value;.
Definition: APInt.h:1559
static Constant * getMul(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
Definition: Constants.cpp:2154
unsigned getNumElements() const
Random access to the elements.
Definition: DerivedTypes.h:289
Type * getAllocatedType() const
Return the type that is being allocated by the instruction.
Definition: Instructions.h:102
op_range incoming_values()
0 0 1 1 True if ordered and greater than or equal
Definition: InstrTypes.h:885
static Constant * getFPExtend(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:1613
static GCRegistry::Add< ErlangGC > A("erlang","erlang-compatible garbage collector")
bool ule(const APInt &RHS) const
Unsigned less or equal comparison.
Definition: APInt.h:1051
static IntegerType * getInt8Ty(LLVMContext &C)
Definition: Type.cpp:167
const BasicBlock * getParent() const
Definition: Instruction.h:62
static cl::opt< bool > DontImproveNonNegativePhiBits("dont-improve-non-negative-phi-bits", cl::Hidden, cl::init(true))
LLVM_READONLY APFloat minnum(const APFloat &A, const APFloat &B)
Implements IEEE minNum semantics.
Definition: APFloat.h:1107
static Optional< bool > isImpliedCondMatchingOperands(CmpInst::Predicate APred, const Value *ALHS, const Value *ARHS, CmpInst::Predicate BPred, const Value *BLHS, const Value *BRHS, bool IsSwappedOps)
Return true if "icmp1 APred ALHS ARHS" implies "icmp2 BPred BLHS BRHS" is true.
bool hasNoUnsignedWrap() const
Test whether this operation is known to never undergo unsigned overflow, aka the nuw property...
Definition: Operator.h:98
signed greater or equal
Definition: InstrTypes.h:908
bool noNaNs() const
Flag queries.
Definition: Operator.h:194
A wrapper class for inspecting calls to intrinsic functions.
Definition: IntrinsicInst.h:44
an instruction to allocate memory on the stack
Definition: Instructions.h:60
This instruction inserts a struct field of array element value into an aggregate value.
CmpClass_match< LHS, RHS, ICmpInst, ICmpInst::Predicate > m_ICmp(ICmpInst::Predicate &Pred, const LHS &L, const RHS &R)
Definition: PatternMatch.h:726
gep_type_iterator gep_type_begin(const User *GEP)
static bool rangeMetadataExcludesValue(const MDNode *Ranges, const APInt &Value)
Does the 'Range' metadata (which must be a valid MD_range operand list) ensure that the value it's at...
bool is_contained(R &&Range, const E &Element)
Wrapper function around std::find to detect if an element exists in a container.
Definition: STLExtras.h:783