LLVM  3.7.0
InstCombineAddSub.cpp
Go to the documentation of this file.
1 //===- InstCombineAddSub.cpp ----------------------------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the visit functions for add, fadd, sub, and fsub.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "InstCombineInternal.h"
15 #include "llvm/ADT/STLExtras.h"
17 #include "llvm/IR/DataLayout.h"
19 #include "llvm/IR/PatternMatch.h"
20 using namespace llvm;
21 using namespace PatternMatch;
22 
23 #define DEBUG_TYPE "instcombine"
24 
25 namespace {
26 
27  /// Class representing coefficient of floating-point addend.
28  /// This class needs to be highly efficient, which is especially true for
29  /// the constructor. As of I write this comment, the cost of the default
30  /// constructor is merely 4-byte-store-zero (Assuming compiler is able to
31  /// perform write-merging).
32  ///
33  class FAddendCoef {
34  public:
35  // The constructor has to initialize a APFloat, which is unnecessary for
36  // most addends which have coefficient either 1 or -1. So, the constructor
37  // is expensive. In order to avoid the cost of the constructor, we should
38  // reuse some instances whenever possible. The pre-created instances
39  // FAddCombine::Add[0-5] embodies this idea.
40  //
41  FAddendCoef() : IsFp(false), BufHasFpVal(false), IntVal(0) {}
42  ~FAddendCoef();
43 
44  void set(short C) {
45  assert(!insaneIntVal(C) && "Insane coefficient");
46  IsFp = false; IntVal = C;
47  }
48 
49  void set(const APFloat& C);
50 
51  void negate();
52 
53  bool isZero() const { return isInt() ? !IntVal : getFpVal().isZero(); }
54  Value *getValue(Type *) const;
55 
56  // If possible, don't define operator+/operator- etc because these
57  // operators inevitably call FAddendCoef's constructor which is not cheap.
58  void operator=(const FAddendCoef &A);
59  void operator+=(const FAddendCoef &A);
60  void operator-=(const FAddendCoef &A);
61  void operator*=(const FAddendCoef &S);
62 
63  bool isOne() const { return isInt() && IntVal == 1; }
64  bool isTwo() const { return isInt() && IntVal == 2; }
65  bool isMinusOne() const { return isInt() && IntVal == -1; }
66  bool isMinusTwo() const { return isInt() && IntVal == -2; }
67 
68  private:
69  bool insaneIntVal(int V) { return V > 4 || V < -4; }
70  APFloat *getFpValPtr(void)
71  { return reinterpret_cast<APFloat*>(&FpValBuf.buffer[0]); }
72  const APFloat *getFpValPtr(void) const
73  { return reinterpret_cast<const APFloat*>(&FpValBuf.buffer[0]); }
74 
75  const APFloat &getFpVal(void) const {
76  assert(IsFp && BufHasFpVal && "Incorret state");
77  return *getFpValPtr();
78  }
79 
80  APFloat &getFpVal(void) {
81  assert(IsFp && BufHasFpVal && "Incorret state");
82  return *getFpValPtr();
83  }
84 
85  bool isInt() const { return !IsFp; }
86 
87  // If the coefficient is represented by an integer, promote it to a
88  // floating point.
89  void convertToFpType(const fltSemantics &Sem);
90 
91  // Construct an APFloat from a signed integer.
92  // TODO: We should get rid of this function when APFloat can be constructed
93  // from an *SIGNED* integer.
94  APFloat createAPFloatFromInt(const fltSemantics &Sem, int Val);
95  private:
96 
97  bool IsFp;
98 
99  // True iff FpValBuf contains an instance of APFloat.
100  bool BufHasFpVal;
101 
102  // The integer coefficient of an individual addend is either 1 or -1,
103  // and we try to simplify at most 4 addends from neighboring at most
104  // two instructions. So the range of <IntVal> falls in [-4, 4]. APInt
105  // is overkill of this end.
106  short IntVal;
107 
109  };
110 
111  /// FAddend is used to represent floating-point addend. An addend is
112  /// represented as <C, V>, where the V is a symbolic value, and C is a
113  /// constant coefficient. A constant addend is represented as <C, 0>.
114  ///
115  class FAddend {
116  public:
117  FAddend() { Val = nullptr; }
118 
119  Value *getSymVal (void) const { return Val; }
120  const FAddendCoef &getCoef(void) const { return Coeff; }
121 
122  bool isConstant() const { return Val == nullptr; }
123  bool isZero() const { return Coeff.isZero(); }
124 
125  void set(short Coefficient, Value *V) { Coeff.set(Coefficient), Val = V; }
126  void set(const APFloat& Coefficient, Value *V)
127  { Coeff.set(Coefficient); Val = V; }
128  void set(const ConstantFP* Coefficient, Value *V)
129  { Coeff.set(Coefficient->getValueAPF()); Val = V; }
130 
131  void negate() { Coeff.negate(); }
132 
133  /// Drill down the U-D chain one step to find the definition of V, and
134  /// try to break the definition into one or two addends.
135  static unsigned drillValueDownOneStep(Value* V, FAddend &A0, FAddend &A1);
136 
137  /// Similar to FAddend::drillDownOneStep() except that the value being
138  /// splitted is the addend itself.
139  unsigned drillAddendDownOneStep(FAddend &Addend0, FAddend &Addend1) const;
140 
141  void operator+=(const FAddend &T) {
142  assert((Val == T.Val) && "Symbolic-values disagree");
143  Coeff += T.Coeff;
144  }
145 
146  private:
147  void Scale(const FAddendCoef& ScaleAmt) { Coeff *= ScaleAmt; }
148 
149  // This addend has the value of "Coeff * Val".
150  Value *Val;
151  FAddendCoef Coeff;
152  };
153 
154  /// FAddCombine is the class for optimizing an unsafe fadd/fsub along
155  /// with its neighboring at most two instructions.
156  ///
157  class FAddCombine {
158  public:
159  FAddCombine(InstCombiner::BuilderTy *B) : Builder(B), Instr(nullptr) {}
160  Value *simplify(Instruction *FAdd);
161 
162  private:
163  typedef SmallVector<const FAddend*, 4> AddendVect;
164 
165  Value *simplifyFAdd(AddendVect& V, unsigned InstrQuota);
166 
167  Value *performFactorization(Instruction *I);
168 
169  /// Convert given addend to a Value
170  Value *createAddendVal(const FAddend &A, bool& NeedNeg);
171 
172  /// Return the number of instructions needed to emit the N-ary addition.
173  unsigned calcInstrNumber(const AddendVect& Vect);
174  Value *createFSub(Value *Opnd0, Value *Opnd1);
175  Value *createFAdd(Value *Opnd0, Value *Opnd1);
176  Value *createFMul(Value *Opnd0, Value *Opnd1);
177  Value *createFDiv(Value *Opnd0, Value *Opnd1);
178  Value *createFNeg(Value *V);
179  Value *createNaryFAdd(const AddendVect& Opnds, unsigned InstrQuota);
180  void createInstPostProc(Instruction *NewInst, bool NoNumber = false);
181 
182  InstCombiner::BuilderTy *Builder;
183  Instruction *Instr;
184 
185  private:
186  // Debugging stuff are clustered here.
187  #ifndef NDEBUG
188  unsigned CreateInstrNum;
189  void initCreateInstNum() { CreateInstrNum = 0; }
190  void incCreateInstNum() { CreateInstrNum++; }
191  #else
192  void initCreateInstNum() {}
193  void incCreateInstNum() {}
194  #endif
195  };
196 }
197 
198 //===----------------------------------------------------------------------===//
199 //
200 // Implementation of
201 // {FAddendCoef, FAddend, FAddition, FAddCombine}.
202 //
203 //===----------------------------------------------------------------------===//
204 FAddendCoef::~FAddendCoef() {
205  if (BufHasFpVal)
206  getFpValPtr()->~APFloat();
207 }
208 
209 void FAddendCoef::set(const APFloat& C) {
210  APFloat *P = getFpValPtr();
211 
212  if (isInt()) {
213  // As the buffer is meanless byte stream, we cannot call
214  // APFloat::operator=().
215  new(P) APFloat(C);
216  } else
217  *P = C;
218 
219  IsFp = BufHasFpVal = true;
220 }
221 
222 void FAddendCoef::convertToFpType(const fltSemantics &Sem) {
223  if (!isInt())
224  return;
225 
226  APFloat *P = getFpValPtr();
227  if (IntVal > 0)
228  new(P) APFloat(Sem, IntVal);
229  else {
230  new(P) APFloat(Sem, 0 - IntVal);
231  P->changeSign();
232  }
233  IsFp = BufHasFpVal = true;
234 }
235 
236 APFloat FAddendCoef::createAPFloatFromInt(const fltSemantics &Sem, int Val) {
237  if (Val >= 0)
238  return APFloat(Sem, Val);
239 
240  APFloat T(Sem, 0 - Val);
241  T.changeSign();
242 
243  return T;
244 }
245 
246 void FAddendCoef::operator=(const FAddendCoef &That) {
247  if (That.isInt())
248  set(That.IntVal);
249  else
250  set(That.getFpVal());
251 }
252 
253 void FAddendCoef::operator+=(const FAddendCoef &That) {
255  if (isInt() == That.isInt()) {
256  if (isInt())
257  IntVal += That.IntVal;
258  else
259  getFpVal().add(That.getFpVal(), RndMode);
260  return;
261  }
262 
263  if (isInt()) {
264  const APFloat &T = That.getFpVal();
265  convertToFpType(T.getSemantics());
266  getFpVal().add(T, RndMode);
267  return;
268  }
269 
270  APFloat &T = getFpVal();
271  T.add(createAPFloatFromInt(T.getSemantics(), That.IntVal), RndMode);
272 }
273 
274 void FAddendCoef::operator-=(const FAddendCoef &That) {
276  if (isInt() == That.isInt()) {
277  if (isInt())
278  IntVal -= That.IntVal;
279  else
280  getFpVal().subtract(That.getFpVal(), RndMode);
281  return;
282  }
283 
284  if (isInt()) {
285  const APFloat &T = That.getFpVal();
286  convertToFpType(T.getSemantics());
287  getFpVal().subtract(T, RndMode);
288  return;
289  }
290 
291  APFloat &T = getFpVal();
292  T.subtract(createAPFloatFromInt(T.getSemantics(), IntVal), RndMode);
293 }
294 
295 void FAddendCoef::operator*=(const FAddendCoef &That) {
296  if (That.isOne())
297  return;
298 
299  if (That.isMinusOne()) {
300  negate();
301  return;
302  }
303 
304  if (isInt() && That.isInt()) {
305  int Res = IntVal * (int)That.IntVal;
306  assert(!insaneIntVal(Res) && "Insane int value");
307  IntVal = Res;
308  return;
309  }
310 
311  const fltSemantics &Semantic =
312  isInt() ? That.getFpVal().getSemantics() : getFpVal().getSemantics();
313 
314  if (isInt())
315  convertToFpType(Semantic);
316  APFloat &F0 = getFpVal();
317 
318  if (That.isInt())
319  F0.multiply(createAPFloatFromInt(Semantic, That.IntVal),
321  else
322  F0.multiply(That.getFpVal(), APFloat::rmNearestTiesToEven);
323 
324  return;
325 }
326 
327 void FAddendCoef::negate() {
328  if (isInt())
329  IntVal = 0 - IntVal;
330  else
331  getFpVal().changeSign();
332 }
333 
334 Value *FAddendCoef::getValue(Type *Ty) const {
335  return isInt() ?
336  ConstantFP::get(Ty, float(IntVal)) :
337  ConstantFP::get(Ty->getContext(), getFpVal());
338 }
339 
340 // The definition of <Val> Addends
341 // =========================================
342 // A + B <1, A>, <1,B>
343 // A - B <1, A>, <1,B>
344 // 0 - B <-1, B>
345 // C * A, <C, A>
346 // A + C <1, A> <C, NULL>
347 // 0 +/- 0 <0, NULL> (corner case)
348 //
349 // Legend: A and B are not constant, C is constant
350 //
351 unsigned FAddend::drillValueDownOneStep
352  (Value *Val, FAddend &Addend0, FAddend &Addend1) {
353  Instruction *I = nullptr;
354  if (!Val || !(I = dyn_cast<Instruction>(Val)))
355  return 0;
356 
357  unsigned Opcode = I->getOpcode();
358 
359  if (Opcode == Instruction::FAdd || Opcode == Instruction::FSub) {
360  ConstantFP *C0, *C1;
361  Value *Opnd0 = I->getOperand(0);
362  Value *Opnd1 = I->getOperand(1);
363  if ((C0 = dyn_cast<ConstantFP>(Opnd0)) && C0->isZero())
364  Opnd0 = nullptr;
365 
366  if ((C1 = dyn_cast<ConstantFP>(Opnd1)) && C1->isZero())
367  Opnd1 = nullptr;
368 
369  if (Opnd0) {
370  if (!C0)
371  Addend0.set(1, Opnd0);
372  else
373  Addend0.set(C0, nullptr);
374  }
375 
376  if (Opnd1) {
377  FAddend &Addend = Opnd0 ? Addend1 : Addend0;
378  if (!C1)
379  Addend.set(1, Opnd1);
380  else
381  Addend.set(C1, nullptr);
382  if (Opcode == Instruction::FSub)
383  Addend.negate();
384  }
385 
386  if (Opnd0 || Opnd1)
387  return Opnd0 && Opnd1 ? 2 : 1;
388 
389  // Both operands are zero. Weird!
390  Addend0.set(APFloat(C0->getValueAPF().getSemantics()), nullptr);
391  return 1;
392  }
393 
394  if (I->getOpcode() == Instruction::FMul) {
395  Value *V0 = I->getOperand(0);
396  Value *V1 = I->getOperand(1);
397  if (ConstantFP *C = dyn_cast<ConstantFP>(V0)) {
398  Addend0.set(C, V1);
399  return 1;
400  }
401 
402  if (ConstantFP *C = dyn_cast<ConstantFP>(V1)) {
403  Addend0.set(C, V0);
404  return 1;
405  }
406  }
407 
408  return 0;
409 }
410 
411 // Try to break *this* addend into two addends. e.g. Suppose this addend is
412 // <2.3, V>, and V = X + Y, by calling this function, we obtain two addends,
413 // i.e. <2.3, X> and <2.3, Y>.
414 //
415 unsigned FAddend::drillAddendDownOneStep
416  (FAddend &Addend0, FAddend &Addend1) const {
417  if (isConstant())
418  return 0;
419 
420  unsigned BreakNum = FAddend::drillValueDownOneStep(Val, Addend0, Addend1);
421  if (!BreakNum || Coeff.isOne())
422  return BreakNum;
423 
424  Addend0.Scale(Coeff);
425 
426  if (BreakNum == 2)
427  Addend1.Scale(Coeff);
428 
429  return BreakNum;
430 }
431 
432 // Try to perform following optimization on the input instruction I. Return the
433 // simplified expression if was successful; otherwise, return 0.
434 //
435 // Instruction "I" is Simplified into
436 // -------------------------------------------------------
437 // (x * y) +/- (x * z) x * (y +/- z)
438 // (y / x) +/- (z / x) (y +/- z) / x
439 //
440 Value *FAddCombine::performFactorization(Instruction *I) {
441  assert((I->getOpcode() == Instruction::FAdd ||
442  I->getOpcode() == Instruction::FSub) && "Expect add/sub");
443 
446 
447  if (!I0 || !I1 || I0->getOpcode() != I1->getOpcode())
448  return nullptr;
449 
450  bool isMpy = false;
451  if (I0->getOpcode() == Instruction::FMul)
452  isMpy = true;
453  else if (I0->getOpcode() != Instruction::FDiv)
454  return nullptr;
455 
456  Value *Opnd0_0 = I0->getOperand(0);
457  Value *Opnd0_1 = I0->getOperand(1);
458  Value *Opnd1_0 = I1->getOperand(0);
459  Value *Opnd1_1 = I1->getOperand(1);
460 
461  // Input Instr I Factor AddSub0 AddSub1
462  // ----------------------------------------------
463  // (x*y) +/- (x*z) x y z
464  // (y/x) +/- (z/x) x y z
465  //
466  Value *Factor = nullptr;
467  Value *AddSub0 = nullptr, *AddSub1 = nullptr;
468 
469  if (isMpy) {
470  if (Opnd0_0 == Opnd1_0 || Opnd0_0 == Opnd1_1)
471  Factor = Opnd0_0;
472  else if (Opnd0_1 == Opnd1_0 || Opnd0_1 == Opnd1_1)
473  Factor = Opnd0_1;
474 
475  if (Factor) {
476  AddSub0 = (Factor == Opnd0_0) ? Opnd0_1 : Opnd0_0;
477  AddSub1 = (Factor == Opnd1_0) ? Opnd1_1 : Opnd1_0;
478  }
479  } else if (Opnd0_1 == Opnd1_1) {
480  Factor = Opnd0_1;
481  AddSub0 = Opnd0_0;
482  AddSub1 = Opnd1_0;
483  }
484 
485  if (!Factor)
486  return nullptr;
487 
489  Flags.setUnsafeAlgebra();
490  if (I0) Flags &= I->getFastMathFlags();
491  if (I1) Flags &= I->getFastMathFlags();
492 
493  // Create expression "NewAddSub = AddSub0 +/- AddsSub1"
494  Value *NewAddSub = (I->getOpcode() == Instruction::FAdd) ?
495  createFAdd(AddSub0, AddSub1) :
496  createFSub(AddSub0, AddSub1);
497  if (ConstantFP *CFP = dyn_cast<ConstantFP>(NewAddSub)) {
498  const APFloat &F = CFP->getValueAPF();
499  if (!F.isNormal())
500  return nullptr;
501  } else if (Instruction *II = dyn_cast<Instruction>(NewAddSub))
502  II->setFastMathFlags(Flags);
503 
504  if (isMpy) {
505  Value *RI = createFMul(Factor, NewAddSub);
506  if (Instruction *II = dyn_cast<Instruction>(RI))
507  II->setFastMathFlags(Flags);
508  return RI;
509  }
510 
511  Value *RI = createFDiv(NewAddSub, Factor);
512  if (Instruction *II = dyn_cast<Instruction>(RI))
513  II->setFastMathFlags(Flags);
514  return RI;
515 }
516 
518  assert(I->hasUnsafeAlgebra() && "Should be in unsafe mode");
519 
520  // Currently we are not able to handle vector type.
521  if (I->getType()->isVectorTy())
522  return nullptr;
523 
524  assert((I->getOpcode() == Instruction::FAdd ||
525  I->getOpcode() == Instruction::FSub) && "Expect add/sub");
526 
527  // Save the instruction before calling other member-functions.
528  Instr = I;
529 
530  FAddend Opnd0, Opnd1, Opnd0_0, Opnd0_1, Opnd1_0, Opnd1_1;
531 
532  unsigned OpndNum = FAddend::drillValueDownOneStep(I, Opnd0, Opnd1);
533 
534  // Step 1: Expand the 1st addend into Opnd0_0 and Opnd0_1.
535  unsigned Opnd0_ExpNum = 0;
536  unsigned Opnd1_ExpNum = 0;
537 
538  if (!Opnd0.isConstant())
539  Opnd0_ExpNum = Opnd0.drillAddendDownOneStep(Opnd0_0, Opnd0_1);
540 
541  // Step 2: Expand the 2nd addend into Opnd1_0 and Opnd1_1.
542  if (OpndNum == 2 && !Opnd1.isConstant())
543  Opnd1_ExpNum = Opnd1.drillAddendDownOneStep(Opnd1_0, Opnd1_1);
544 
545  // Step 3: Try to optimize Opnd0_0 + Opnd0_1 + Opnd1_0 + Opnd1_1
546  if (Opnd0_ExpNum && Opnd1_ExpNum) {
547  AddendVect AllOpnds;
548  AllOpnds.push_back(&Opnd0_0);
549  AllOpnds.push_back(&Opnd1_0);
550  if (Opnd0_ExpNum == 2)
551  AllOpnds.push_back(&Opnd0_1);
552  if (Opnd1_ExpNum == 2)
553  AllOpnds.push_back(&Opnd1_1);
554 
555  // Compute instruction quota. We should save at least one instruction.
556  unsigned InstQuota = 0;
557 
558  Value *V0 = I->getOperand(0);
559  Value *V1 = I->getOperand(1);
560  InstQuota = ((!isa<Constant>(V0) && V0->hasOneUse()) &&
561  (!isa<Constant>(V1) && V1->hasOneUse())) ? 2 : 1;
562 
563  if (Value *R = simplifyFAdd(AllOpnds, InstQuota))
564  return R;
565  }
566 
567  if (OpndNum != 2) {
568  // The input instruction is : "I=0.0 +/- V". If the "V" were able to be
569  // splitted into two addends, say "V = X - Y", the instruction would have
570  // been optimized into "I = Y - X" in the previous steps.
571  //
572  const FAddendCoef &CE = Opnd0.getCoef();
573  return CE.isOne() ? Opnd0.getSymVal() : nullptr;
574  }
575 
576  // step 4: Try to optimize Opnd0 + Opnd1_0 [+ Opnd1_1]
577  if (Opnd1_ExpNum) {
578  AddendVect AllOpnds;
579  AllOpnds.push_back(&Opnd0);
580  AllOpnds.push_back(&Opnd1_0);
581  if (Opnd1_ExpNum == 2)
582  AllOpnds.push_back(&Opnd1_1);
583 
584  if (Value *R = simplifyFAdd(AllOpnds, 1))
585  return R;
586  }
587 
588  // step 5: Try to optimize Opnd1 + Opnd0_0 [+ Opnd0_1]
589  if (Opnd0_ExpNum) {
590  AddendVect AllOpnds;
591  AllOpnds.push_back(&Opnd1);
592  AllOpnds.push_back(&Opnd0_0);
593  if (Opnd0_ExpNum == 2)
594  AllOpnds.push_back(&Opnd0_1);
595 
596  if (Value *R = simplifyFAdd(AllOpnds, 1))
597  return R;
598  }
599 
600  // step 6: Try factorization as the last resort,
601  return performFactorization(I);
602 }
603 
604 Value *FAddCombine::simplifyFAdd(AddendVect& Addends, unsigned InstrQuota) {
605 
606  unsigned AddendNum = Addends.size();
607  assert(AddendNum <= 4 && "Too many addends");
608 
609  // For saving intermediate results;
610  unsigned NextTmpIdx = 0;
611  FAddend TmpResult[3];
612 
613  // Points to the constant addend of the resulting simplified expression.
614  // If the resulting expr has constant-addend, this constant-addend is
615  // desirable to reside at the top of the resulting expression tree. Placing
616  // constant close to supper-expr(s) will potentially reveal some optimization
617  // opportunities in super-expr(s).
618  //
619  const FAddend *ConstAdd = nullptr;
620 
621  // Simplified addends are placed <SimpVect>.
622  AddendVect SimpVect;
623 
624  // The outer loop works on one symbolic-value at a time. Suppose the input
625  // addends are : <a1, x>, <b1, y>, <a2, x>, <c1, z>, <b2, y>, ...
626  // The symbolic-values will be processed in this order: x, y, z.
627  //
628  for (unsigned SymIdx = 0; SymIdx < AddendNum; SymIdx++) {
629 
630  const FAddend *ThisAddend = Addends[SymIdx];
631  if (!ThisAddend) {
632  // This addend was processed before.
633  continue;
634  }
635 
636  Value *Val = ThisAddend->getSymVal();
637  unsigned StartIdx = SimpVect.size();
638  SimpVect.push_back(ThisAddend);
639 
640  // The inner loop collects addends sharing same symbolic-value, and these
641  // addends will be later on folded into a single addend. Following above
642  // example, if the symbolic value "y" is being processed, the inner loop
643  // will collect two addends "<b1,y>" and "<b2,Y>". These two addends will
644  // be later on folded into "<b1+b2, y>".
645  //
646  for (unsigned SameSymIdx = SymIdx + 1;
647  SameSymIdx < AddendNum; SameSymIdx++) {
648  const FAddend *T = Addends[SameSymIdx];
649  if (T && T->getSymVal() == Val) {
650  // Set null such that next iteration of the outer loop will not process
651  // this addend again.
652  Addends[SameSymIdx] = nullptr;
653  SimpVect.push_back(T);
654  }
655  }
656 
657  // If multiple addends share same symbolic value, fold them together.
658  if (StartIdx + 1 != SimpVect.size()) {
659  FAddend &R = TmpResult[NextTmpIdx ++];
660  R = *SimpVect[StartIdx];
661  for (unsigned Idx = StartIdx + 1; Idx < SimpVect.size(); Idx++)
662  R += *SimpVect[Idx];
663 
664  // Pop all addends being folded and push the resulting folded addend.
665  SimpVect.resize(StartIdx);
666  if (Val) {
667  if (!R.isZero()) {
668  SimpVect.push_back(&R);
669  }
670  } else {
671  // Don't push constant addend at this time. It will be the last element
672  // of <SimpVect>.
673  ConstAdd = &R;
674  }
675  }
676  }
677 
678  assert((NextTmpIdx <= array_lengthof(TmpResult) + 1) &&
679  "out-of-bound access");
680 
681  if (ConstAdd)
682  SimpVect.push_back(ConstAdd);
683 
684  Value *Result;
685  if (!SimpVect.empty())
686  Result = createNaryFAdd(SimpVect, InstrQuota);
687  else {
688  // The addition is folded to 0.0.
689  Result = ConstantFP::get(Instr->getType(), 0.0);
690  }
691 
692  return Result;
693 }
694 
695 Value *FAddCombine::createNaryFAdd
696  (const AddendVect &Opnds, unsigned InstrQuota) {
697  assert(!Opnds.empty() && "Expect at least one addend");
698 
699  // Step 1: Check if the # of instructions needed exceeds the quota.
700  //
701  unsigned InstrNeeded = calcInstrNumber(Opnds);
702  if (InstrNeeded > InstrQuota)
703  return nullptr;
704 
705  initCreateInstNum();
706 
707  // step 2: Emit the N-ary addition.
708  // Note that at most three instructions are involved in Fadd-InstCombine: the
709  // addition in question, and at most two neighboring instructions.
710  // The resulting optimized addition should have at least one less instruction
711  // than the original addition expression tree. This implies that the resulting
712  // N-ary addition has at most two instructions, and we don't need to worry
713  // about tree-height when constructing the N-ary addition.
714 
715  Value *LastVal = nullptr;
716  bool LastValNeedNeg = false;
717 
718  // Iterate the addends, creating fadd/fsub using adjacent two addends.
719  for (AddendVect::const_iterator I = Opnds.begin(), E = Opnds.end();
720  I != E; I++) {
721  bool NeedNeg;
722  Value *V = createAddendVal(**I, NeedNeg);
723  if (!LastVal) {
724  LastVal = V;
725  LastValNeedNeg = NeedNeg;
726  continue;
727  }
728 
729  if (LastValNeedNeg == NeedNeg) {
730  LastVal = createFAdd(LastVal, V);
731  continue;
732  }
733 
734  if (LastValNeedNeg)
735  LastVal = createFSub(V, LastVal);
736  else
737  LastVal = createFSub(LastVal, V);
738 
739  LastValNeedNeg = false;
740  }
741 
742  if (LastValNeedNeg) {
743  LastVal = createFNeg(LastVal);
744  }
745 
746  #ifndef NDEBUG
747  assert(CreateInstrNum == InstrNeeded &&
748  "Inconsistent in instruction numbers");
749  #endif
750 
751  return LastVal;
752 }
753 
754 Value *FAddCombine::createFSub(Value *Opnd0, Value *Opnd1) {
755  Value *V = Builder->CreateFSub(Opnd0, Opnd1);
756  if (Instruction *I = dyn_cast<Instruction>(V))
757  createInstPostProc(I);
758  return V;
759 }
760 
761 Value *FAddCombine::createFNeg(Value *V) {
762  Value *Zero = cast<Value>(ConstantFP::getZeroValueForNegation(V->getType()));
763  Value *NewV = createFSub(Zero, V);
764  if (Instruction *I = dyn_cast<Instruction>(NewV))
765  createInstPostProc(I, true); // fneg's don't receive instruction numbers.
766  return NewV;
767 }
768 
769 Value *FAddCombine::createFAdd(Value *Opnd0, Value *Opnd1) {
770  Value *V = Builder->CreateFAdd(Opnd0, Opnd1);
771  if (Instruction *I = dyn_cast<Instruction>(V))
772  createInstPostProc(I);
773  return V;
774 }
775 
776 Value *FAddCombine::createFMul(Value *Opnd0, Value *Opnd1) {
777  Value *V = Builder->CreateFMul(Opnd0, Opnd1);
778  if (Instruction *I = dyn_cast<Instruction>(V))
779  createInstPostProc(I);
780  return V;
781 }
782 
783 Value *FAddCombine::createFDiv(Value *Opnd0, Value *Opnd1) {
784  Value *V = Builder->CreateFDiv(Opnd0, Opnd1);
785  if (Instruction *I = dyn_cast<Instruction>(V))
786  createInstPostProc(I);
787  return V;
788 }
789 
790 void FAddCombine::createInstPostProc(Instruction *NewInstr, bool NoNumber) {
791  NewInstr->setDebugLoc(Instr->getDebugLoc());
792 
793  // Keep track of the number of instruction created.
794  if (!NoNumber)
795  incCreateInstNum();
796 
797  // Propagate fast-math flags
798  NewInstr->setFastMathFlags(Instr->getFastMathFlags());
799 }
800 
801 // Return the number of instruction needed to emit the N-ary addition.
802 // NOTE: Keep this function in sync with createAddendVal().
803 unsigned FAddCombine::calcInstrNumber(const AddendVect &Opnds) {
804  unsigned OpndNum = Opnds.size();
805  unsigned InstrNeeded = OpndNum - 1;
806 
807  // The number of addends in the form of "(-1)*x".
808  unsigned NegOpndNum = 0;
809 
810  // Adjust the number of instructions needed to emit the N-ary add.
811  for (AddendVect::const_iterator I = Opnds.begin(), E = Opnds.end();
812  I != E; I++) {
813  const FAddend *Opnd = *I;
814  if (Opnd->isConstant())
815  continue;
816 
817  const FAddendCoef &CE = Opnd->getCoef();
818  if (CE.isMinusOne() || CE.isMinusTwo())
819  NegOpndNum++;
820 
821  // Let the addend be "c * x". If "c == +/-1", the value of the addend
822  // is immediately available; otherwise, it needs exactly one instruction
823  // to evaluate the value.
824  if (!CE.isMinusOne() && !CE.isOne())
825  InstrNeeded++;
826  }
827  if (NegOpndNum == OpndNum)
828  InstrNeeded++;
829  return InstrNeeded;
830 }
831 
832 // Input Addend Value NeedNeg(output)
833 // ================================================================
834 // Constant C C false
835 // <+/-1, V> V coefficient is -1
836 // <2/-2, V> "fadd V, V" coefficient is -2
837 // <C, V> "fmul V, C" false
838 //
839 // NOTE: Keep this function in sync with FAddCombine::calcInstrNumber.
840 Value *FAddCombine::createAddendVal(const FAddend &Opnd, bool &NeedNeg) {
841  const FAddendCoef &Coeff = Opnd.getCoef();
842 
843  if (Opnd.isConstant()) {
844  NeedNeg = false;
845  return Coeff.getValue(Instr->getType());
846  }
847 
848  Value *OpndVal = Opnd.getSymVal();
849 
850  if (Coeff.isMinusOne() || Coeff.isOne()) {
851  NeedNeg = Coeff.isMinusOne();
852  return OpndVal;
853  }
854 
855  if (Coeff.isTwo() || Coeff.isMinusTwo()) {
856  NeedNeg = Coeff.isMinusTwo();
857  return createFAdd(OpndVal, OpndVal);
858  }
859 
860  NeedNeg = false;
861  return createFMul(OpndVal, Coeff.getValue(Instr->getType()));
862 }
863 
864 // If one of the operands only has one non-zero bit, and if the other
865 // operand has a known-zero bit in a more significant place than it (not
866 // including the sign bit) the ripple may go up to and fill the zero, but
867 // won't change the sign. For example, (X & ~4) + 1.
868 static bool checkRippleForAdd(const APInt &Op0KnownZero,
869  const APInt &Op1KnownZero) {
870  APInt Op1MaybeOne = ~Op1KnownZero;
871  // Make sure that one of the operand has at most one bit set to 1.
872  if (Op1MaybeOne.countPopulation() != 1)
873  return false;
874 
875  // Find the most significant known 0 other than the sign bit.
876  int BitWidth = Op0KnownZero.getBitWidth();
877  APInt Op0KnownZeroTemp(Op0KnownZero);
878  Op0KnownZeroTemp.clearBit(BitWidth - 1);
879  int Op0ZeroPosition = BitWidth - Op0KnownZeroTemp.countLeadingZeros() - 1;
880 
881  int Op1OnePosition = BitWidth - Op1MaybeOne.countLeadingZeros() - 1;
882  assert(Op1OnePosition >= 0);
883 
884  // This also covers the case of no known zero, since in that case
885  // Op0ZeroPosition is -1.
886  return Op0ZeroPosition >= Op1OnePosition;
887 }
888 
889 /// WillNotOverflowSignedAdd - Return true if we can prove that:
890 /// (sext (add LHS, RHS)) === (add (sext LHS), (sext RHS))
891 /// This basically requires proving that the add in the original type would not
892 /// overflow to change the sign bit or have a carry out.
893 bool InstCombiner::WillNotOverflowSignedAdd(Value *LHS, Value *RHS,
894  Instruction &CxtI) {
895  // There are different heuristics we can use for this. Here are some simple
896  // ones.
897 
898  // If LHS and RHS each have at least two sign bits, the addition will look
899  // like
900  //
901  // XX..... +
902  // YY.....
903  //
904  // If the carry into the most significant position is 0, X and Y can't both
905  // be 1 and therefore the carry out of the addition is also 0.
906  //
907  // If the carry into the most significant position is 1, X and Y can't both
908  // be 0 and therefore the carry out of the addition is also 1.
909  //
910  // Since the carry into the most significant position is always equal to
911  // the carry out of the addition, there is no signed overflow.
912  if (ComputeNumSignBits(LHS, 0, &CxtI) > 1 &&
913  ComputeNumSignBits(RHS, 0, &CxtI) > 1)
914  return true;
915 
916  unsigned BitWidth = LHS->getType()->getScalarSizeInBits();
917  APInt LHSKnownZero(BitWidth, 0);
918  APInt LHSKnownOne(BitWidth, 0);
919  computeKnownBits(LHS, LHSKnownZero, LHSKnownOne, 0, &CxtI);
920 
921  APInt RHSKnownZero(BitWidth, 0);
922  APInt RHSKnownOne(BitWidth, 0);
923  computeKnownBits(RHS, RHSKnownZero, RHSKnownOne, 0, &CxtI);
924 
925  // Addition of two 2's compliment numbers having opposite signs will never
926  // overflow.
927  if ((LHSKnownOne[BitWidth - 1] && RHSKnownZero[BitWidth - 1]) ||
928  (LHSKnownZero[BitWidth - 1] && RHSKnownOne[BitWidth - 1]))
929  return true;
930 
931  // Check if carry bit of addition will not cause overflow.
932  if (checkRippleForAdd(LHSKnownZero, RHSKnownZero))
933  return true;
934  if (checkRippleForAdd(RHSKnownZero, LHSKnownZero))
935  return true;
936 
937  return false;
938 }
939 
940 /// \brief Return true if we can prove that:
941 /// (sub LHS, RHS) === (sub nsw LHS, RHS)
942 /// This basically requires proving that the add in the original type would not
943 /// overflow to change the sign bit or have a carry out.
944 /// TODO: Handle this for Vectors.
945 bool InstCombiner::WillNotOverflowSignedSub(Value *LHS, Value *RHS,
946  Instruction &CxtI) {
947  // If LHS and RHS each have at least two sign bits, the subtraction
948  // cannot overflow.
949  if (ComputeNumSignBits(LHS, 0, &CxtI) > 1 &&
950  ComputeNumSignBits(RHS, 0, &CxtI) > 1)
951  return true;
952 
953  unsigned BitWidth = LHS->getType()->getScalarSizeInBits();
954  APInt LHSKnownZero(BitWidth, 0);
955  APInt LHSKnownOne(BitWidth, 0);
956  computeKnownBits(LHS, LHSKnownZero, LHSKnownOne, 0, &CxtI);
957 
958  APInt RHSKnownZero(BitWidth, 0);
959  APInt RHSKnownOne(BitWidth, 0);
960  computeKnownBits(RHS, RHSKnownZero, RHSKnownOne, 0, &CxtI);
961 
962  // Subtraction of two 2's compliment numbers having identical signs will
963  // never overflow.
964  if ((LHSKnownOne[BitWidth - 1] && RHSKnownOne[BitWidth - 1]) ||
965  (LHSKnownZero[BitWidth - 1] && RHSKnownZero[BitWidth - 1]))
966  return true;
967 
968  // TODO: implement logic similar to checkRippleForAdd
969  return false;
970 }
971 
972 /// \brief Return true if we can prove that:
973 /// (sub LHS, RHS) === (sub nuw LHS, RHS)
974 bool InstCombiner::WillNotOverflowUnsignedSub(Value *LHS, Value *RHS,
975  Instruction &CxtI) {
976  // If the LHS is negative and the RHS is non-negative, no unsigned wrap.
977  bool LHSKnownNonNegative, LHSKnownNegative;
978  bool RHSKnownNonNegative, RHSKnownNegative;
979  ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, /*Depth=*/0,
980  &CxtI);
981  ComputeSignBit(RHS, RHSKnownNonNegative, RHSKnownNegative, /*Depth=*/0,
982  &CxtI);
983  if (LHSKnownNegative && RHSKnownNonNegative)
984  return true;
985 
986  return false;
987 }
988 
989 // Checks if any operand is negative and we can convert add to sub.
990 // This function checks for following negative patterns
991 // ADD(XOR(OR(Z, NOT(C)), C)), 1) == NEG(AND(Z, C))
992 // ADD(XOR(AND(Z, C), C), 1) == NEG(OR(Z, ~C))
993 // XOR(AND(Z, C), (C + 1)) == NEG(OR(Z, ~C)) if C is even
995  InstCombiner::BuilderTy *Builder) {
996  Value *LHS = I.getOperand(0), *RHS = I.getOperand(1);
997 
998  // This function creates 2 instructions to replace ADD, we need at least one
999  // of LHS or RHS to have one use to ensure benefit in transform.
1000  if (!LHS->hasOneUse() && !RHS->hasOneUse())
1001  return nullptr;
1002 
1003  Value *X = nullptr, *Y = nullptr, *Z = nullptr;
1004  const APInt *C1 = nullptr, *C2 = nullptr;
1005 
1006  // if ONE is on other side, swap
1007  if (match(RHS, m_Add(m_Value(X), m_One())))
1008  std::swap(LHS, RHS);
1009 
1010  if (match(LHS, m_Add(m_Value(X), m_One()))) {
1011  // if XOR on other side, swap
1012  if (match(RHS, m_Xor(m_Value(Y), m_APInt(C1))))
1013  std::swap(X, RHS);
1014 
1015  if (match(X, m_Xor(m_Value(Y), m_APInt(C1)))) {
1016  // X = XOR(Y, C1), Y = OR(Z, C2), C2 = NOT(C1) ==> X == NOT(AND(Z, C1))
1017  // ADD(ADD(X, 1), RHS) == ADD(X, ADD(RHS, 1)) == SUB(RHS, AND(Z, C1))
1018  if (match(Y, m_Or(m_Value(Z), m_APInt(C2))) && (*C2 == ~(*C1))) {
1019  Value *NewAnd = Builder->CreateAnd(Z, *C1);
1020  return Builder->CreateSub(RHS, NewAnd, "sub");
1021  } else if (match(Y, m_And(m_Value(Z), m_APInt(C2))) && (*C1 == *C2)) {
1022  // X = XOR(Y, C1), Y = AND(Z, C2), C2 == C1 ==> X == NOT(OR(Z, ~C1))
1023  // ADD(ADD(X, 1), RHS) == ADD(X, ADD(RHS, 1)) == SUB(RHS, OR(Z, ~C1))
1024  Value *NewOr = Builder->CreateOr(Z, ~(*C1));
1025  return Builder->CreateSub(RHS, NewOr, "sub");
1026  }
1027  }
1028  }
1029 
1030  // Restore LHS and RHS
1031  LHS = I.getOperand(0);
1032  RHS = I.getOperand(1);
1033 
1034  // if XOR is on other side, swap
1035  if (match(RHS, m_Xor(m_Value(Y), m_APInt(C1))))
1036  std::swap(LHS, RHS);
1037 
1038  // C2 is ODD
1039  // LHS = XOR(Y, C1), Y = AND(Z, C2), C1 == (C2 + 1) => LHS == NEG(OR(Z, ~C2))
1040  // ADD(LHS, RHS) == SUB(RHS, OR(Z, ~C2))
1041  if (match(LHS, m_Xor(m_Value(Y), m_APInt(C1))))
1042  if (C1->countTrailingZeros() == 0)
1043  if (match(Y, m_And(m_Value(Z), m_APInt(C2))) && *C1 == (*C2 + 1)) {
1044  Value *NewOr = Builder->CreateOr(Z, ~(*C2));
1045  return Builder->CreateSub(RHS, NewOr, "sub");
1046  }
1047  return nullptr;
1048 }
1049 
1051  bool Changed = SimplifyAssociativeOrCommutative(I);
1052  Value *LHS = I.getOperand(0), *RHS = I.getOperand(1);
1053 
1054  if (Value *V = SimplifyVectorOp(I))
1055  return ReplaceInstUsesWith(I, V);
1056 
1057  if (Value *V = SimplifyAddInst(LHS, RHS, I.hasNoSignedWrap(),
1058  I.hasNoUnsignedWrap(), DL, TLI, DT, AC))
1059  return ReplaceInstUsesWith(I, V);
1060 
1061  // (A*B)+(A*C) -> A*(B+C) etc
1062  if (Value *V = SimplifyUsingDistributiveLaws(I))
1063  return ReplaceInstUsesWith(I, V);
1064 
1065  if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) {
1066  // X + (signbit) --> X ^ signbit
1067  const APInt &Val = CI->getValue();
1068  if (Val.isSignBit())
1069  return BinaryOperator::CreateXor(LHS, RHS);
1070 
1071  // See if SimplifyDemandedBits can simplify this. This handles stuff like
1072  // (X & 254)+1 -> (X&254)|1
1073  if (SimplifyDemandedInstructionBits(I))
1074  return &I;
1075 
1076  // zext(bool) + C -> bool ? C + 1 : C
1077  if (ZExtInst *ZI = dyn_cast<ZExtInst>(LHS))
1078  if (ZI->getSrcTy()->isIntegerTy(1))
1079  return SelectInst::Create(ZI->getOperand(0), AddOne(CI), CI);
1080 
1081  Value *XorLHS = nullptr; ConstantInt *XorRHS = nullptr;
1082  if (match(LHS, m_Xor(m_Value(XorLHS), m_ConstantInt(XorRHS)))) {
1083  uint32_t TySizeBits = I.getType()->getScalarSizeInBits();
1084  const APInt &RHSVal = CI->getValue();
1085  unsigned ExtendAmt = 0;
1086  // If we have ADD(XOR(AND(X, 0xFF), 0x80), 0xF..F80), it's a sext.
1087  // If we have ADD(XOR(AND(X, 0xFF), 0xF..F80), 0x80), it's a sext.
1088  if (XorRHS->getValue() == -RHSVal) {
1089  if (RHSVal.isPowerOf2())
1090  ExtendAmt = TySizeBits - RHSVal.logBase2() - 1;
1091  else if (XorRHS->getValue().isPowerOf2())
1092  ExtendAmt = TySizeBits - XorRHS->getValue().logBase2() - 1;
1093  }
1094 
1095  if (ExtendAmt) {
1096  APInt Mask = APInt::getHighBitsSet(TySizeBits, ExtendAmt);
1097  if (!MaskedValueIsZero(XorLHS, Mask, 0, &I))
1098  ExtendAmt = 0;
1099  }
1100 
1101  if (ExtendAmt) {
1102  Constant *ShAmt = ConstantInt::get(I.getType(), ExtendAmt);
1103  Value *NewShl = Builder->CreateShl(XorLHS, ShAmt, "sext");
1104  return BinaryOperator::CreateAShr(NewShl, ShAmt);
1105  }
1106 
1107  // If this is a xor that was canonicalized from a sub, turn it back into
1108  // a sub and fuse this add with it.
1109  if (LHS->hasOneUse() && (XorRHS->getValue()+1).isPowerOf2()) {
1110  IntegerType *IT = cast<IntegerType>(I.getType());
1111  APInt LHSKnownOne(IT->getBitWidth(), 0);
1112  APInt LHSKnownZero(IT->getBitWidth(), 0);
1113  computeKnownBits(XorLHS, LHSKnownZero, LHSKnownOne, 0, &I);
1114  if ((XorRHS->getValue() | LHSKnownZero).isAllOnesValue())
1115  return BinaryOperator::CreateSub(ConstantExpr::getAdd(XorRHS, CI),
1116  XorLHS);
1117  }
1118  // (X + signbit) + C could have gotten canonicalized to (X ^ signbit) + C,
1119  // transform them into (X + (signbit ^ C))
1120  if (XorRHS->getValue().isSignBit())
1121  return BinaryOperator::CreateAdd(XorLHS,
1122  ConstantExpr::getXor(XorRHS, CI));
1123  }
1124  }
1125 
1126  if (isa<Constant>(RHS) && isa<PHINode>(LHS))
1127  if (Instruction *NV = FoldOpIntoPhi(I))
1128  return NV;
1129 
1130  if (I.getType()->getScalarType()->isIntegerTy(1))
1131  return BinaryOperator::CreateXor(LHS, RHS);
1132 
1133  // X + X --> X << 1
1134  if (LHS == RHS) {
1135  BinaryOperator *New =
1136  BinaryOperator::CreateShl(LHS, ConstantInt::get(I.getType(), 1));
1139  return New;
1140  }
1141 
1142  // -A + B --> B - A
1143  // -A + -B --> -(A + B)
1144  if (Value *LHSV = dyn_castNegVal(LHS)) {
1145  if (!isa<Constant>(RHS))
1146  if (Value *RHSV = dyn_castNegVal(RHS)) {
1147  Value *NewAdd = Builder->CreateAdd(LHSV, RHSV, "sum");
1148  return BinaryOperator::CreateNeg(NewAdd);
1149  }
1150 
1151  return BinaryOperator::CreateSub(RHS, LHSV);
1152  }
1153 
1154  // A + -B --> A - B
1155  if (!isa<Constant>(RHS))
1156  if (Value *V = dyn_castNegVal(RHS))
1157  return BinaryOperator::CreateSub(LHS, V);
1158 
1159  if (Value *V = checkForNegativeOperand(I, Builder))
1160  return ReplaceInstUsesWith(I, V);
1161 
1162  // A+B --> A|B iff A and B have no bits set in common.
1163  if (haveNoCommonBitsSet(LHS, RHS, DL, AC, &I, DT))
1164  return BinaryOperator::CreateOr(LHS, RHS);
1165 
1166  if (Constant *CRHS = dyn_cast<Constant>(RHS)) {
1167  Value *X;
1168  if (match(LHS, m_Not(m_Value(X)))) // ~X + C --> (C-1) - X
1169  return BinaryOperator::CreateSub(SubOne(CRHS), X);
1170  }
1171 
1172  if (ConstantInt *CRHS = dyn_cast<ConstantInt>(RHS)) {
1173  // (X & FF00) + xx00 -> (X+xx00) & FF00
1174  Value *X;
1175  ConstantInt *C2;
1176  if (LHS->hasOneUse() &&
1177  match(LHS, m_And(m_Value(X), m_ConstantInt(C2))) &&
1178  CRHS->getValue() == (CRHS->getValue() & C2->getValue())) {
1179  // See if all bits from the first bit set in the Add RHS up are included
1180  // in the mask. First, get the rightmost bit.
1181  const APInt &AddRHSV = CRHS->getValue();
1182 
1183  // Form a mask of all bits from the lowest bit added through the top.
1184  APInt AddRHSHighBits(~((AddRHSV & -AddRHSV)-1));
1185 
1186  // See if the and mask includes all of these bits.
1187  APInt AddRHSHighBitsAnd(AddRHSHighBits & C2->getValue());
1188 
1189  if (AddRHSHighBits == AddRHSHighBitsAnd) {
1190  // Okay, the xform is safe. Insert the new add pronto.
1191  Value *NewAdd = Builder->CreateAdd(X, CRHS, LHS->getName());
1192  return BinaryOperator::CreateAnd(NewAdd, C2);
1193  }
1194  }
1195 
1196  // Try to fold constant add into select arguments.
1197  if (SelectInst *SI = dyn_cast<SelectInst>(LHS))
1198  if (Instruction *R = FoldOpIntoSelect(I, SI))
1199  return R;
1200  }
1201 
1202  // add (select X 0 (sub n A)) A --> select X A n
1203  {
1204  SelectInst *SI = dyn_cast<SelectInst>(LHS);
1205  Value *A = RHS;
1206  if (!SI) {
1207  SI = dyn_cast<SelectInst>(RHS);
1208  A = LHS;
1209  }
1210  if (SI && SI->hasOneUse()) {
1211  Value *TV = SI->getTrueValue();
1212  Value *FV = SI->getFalseValue();
1213  Value *N;
1214 
1215  // Can we fold the add into the argument of the select?
1216  // We check both true and false select arguments for a matching subtract.
1217  if (match(FV, m_Zero()) && match(TV, m_Sub(m_Value(N), m_Specific(A))))
1218  // Fold the add into the true select value.
1219  return SelectInst::Create(SI->getCondition(), N, A);
1220 
1221  if (match(TV, m_Zero()) && match(FV, m_Sub(m_Value(N), m_Specific(A))))
1222  // Fold the add into the false select value.
1223  return SelectInst::Create(SI->getCondition(), A, N);
1224  }
1225  }
1226 
1227  // Check for (add (sext x), y), see if we can merge this into an
1228  // integer add followed by a sext.
1229  if (SExtInst *LHSConv = dyn_cast<SExtInst>(LHS)) {
1230  // (add (sext x), cst) --> (sext (add x, cst'))
1231  if (ConstantInt *RHSC = dyn_cast<ConstantInt>(RHS)) {
1232  Constant *CI =
1233  ConstantExpr::getTrunc(RHSC, LHSConv->getOperand(0)->getType());
1234  if (LHSConv->hasOneUse() &&
1235  ConstantExpr::getSExt(CI, I.getType()) == RHSC &&
1236  WillNotOverflowSignedAdd(LHSConv->getOperand(0), CI, I)) {
1237  // Insert the new, smaller add.
1238  Value *NewAdd = Builder->CreateNSWAdd(LHSConv->getOperand(0),
1239  CI, "addconv");
1240  return new SExtInst(NewAdd, I.getType());
1241  }
1242  }
1243 
1244  // (add (sext x), (sext y)) --> (sext (add int x, y))
1245  if (SExtInst *RHSConv = dyn_cast<SExtInst>(RHS)) {
1246  // Only do this if x/y have the same type, if at last one of them has a
1247  // single use (so we don't increase the number of sexts), and if the
1248  // integer add will not overflow.
1249  if (LHSConv->getOperand(0)->getType() ==
1250  RHSConv->getOperand(0)->getType() &&
1251  (LHSConv->hasOneUse() || RHSConv->hasOneUse()) &&
1252  WillNotOverflowSignedAdd(LHSConv->getOperand(0),
1253  RHSConv->getOperand(0), I)) {
1254  // Insert the new integer add.
1255  Value *NewAdd = Builder->CreateNSWAdd(LHSConv->getOperand(0),
1256  RHSConv->getOperand(0), "addconv");
1257  return new SExtInst(NewAdd, I.getType());
1258  }
1259  }
1260  }
1261 
1262  // (add (xor A, B) (and A, B)) --> (or A, B)
1263  {
1264  Value *A = nullptr, *B = nullptr;
1265  if (match(RHS, m_Xor(m_Value(A), m_Value(B))) &&
1266  (match(LHS, m_And(m_Specific(A), m_Specific(B))) ||
1267  match(LHS, m_And(m_Specific(B), m_Specific(A)))))
1268  return BinaryOperator::CreateOr(A, B);
1269 
1270  if (match(LHS, m_Xor(m_Value(A), m_Value(B))) &&
1271  (match(RHS, m_And(m_Specific(A), m_Specific(B))) ||
1272  match(RHS, m_And(m_Specific(B), m_Specific(A)))))
1273  return BinaryOperator::CreateOr(A, B);
1274  }
1275 
1276  // (add (or A, B) (and A, B)) --> (add A, B)
1277  {
1278  Value *A = nullptr, *B = nullptr;
1279  if (match(RHS, m_Or(m_Value(A), m_Value(B))) &&
1280  (match(LHS, m_And(m_Specific(A), m_Specific(B))) ||
1281  match(LHS, m_And(m_Specific(B), m_Specific(A))))) {
1282  auto *New = BinaryOperator::CreateAdd(A, B);
1283  New->setHasNoSignedWrap(I.hasNoSignedWrap());
1284  New->setHasNoUnsignedWrap(I.hasNoUnsignedWrap());
1285  return New;
1286  }
1287 
1288  if (match(LHS, m_Or(m_Value(A), m_Value(B))) &&
1289  (match(RHS, m_And(m_Specific(A), m_Specific(B))) ||
1290  match(RHS, m_And(m_Specific(B), m_Specific(A))))) {
1291  auto *New = BinaryOperator::CreateAdd(A, B);
1292  New->setHasNoSignedWrap(I.hasNoSignedWrap());
1293  New->setHasNoUnsignedWrap(I.hasNoUnsignedWrap());
1294  return New;
1295  }
1296  }
1297 
1298  // TODO(jingyue): Consider WillNotOverflowSignedAdd and
1299  // WillNotOverflowUnsignedAdd to reduce the number of invocations of
1300  // computeKnownBits.
1301  if (!I.hasNoSignedWrap() && WillNotOverflowSignedAdd(LHS, RHS, I)) {
1302  Changed = true;
1303  I.setHasNoSignedWrap(true);
1304  }
1305  if (!I.hasNoUnsignedWrap() &&
1306  computeOverflowForUnsignedAdd(LHS, RHS, &I) ==
1308  Changed = true;
1309  I.setHasNoUnsignedWrap(true);
1310  }
1311 
1312  return Changed ? &I : nullptr;
1313 }
1314 
1316  bool Changed = SimplifyAssociativeOrCommutative(I);
1317  Value *LHS = I.getOperand(0), *RHS = I.getOperand(1);
1318 
1319  if (Value *V = SimplifyVectorOp(I))
1320  return ReplaceInstUsesWith(I, V);
1321 
1322  if (Value *V =
1323  SimplifyFAddInst(LHS, RHS, I.getFastMathFlags(), DL, TLI, DT, AC))
1324  return ReplaceInstUsesWith(I, V);
1325 
1326  if (isa<Constant>(RHS)) {
1327  if (isa<PHINode>(LHS))
1328  if (Instruction *NV = FoldOpIntoPhi(I))
1329  return NV;
1330 
1331  if (SelectInst *SI = dyn_cast<SelectInst>(LHS))
1332  if (Instruction *NV = FoldOpIntoSelect(I, SI))
1333  return NV;
1334  }
1335 
1336  // -A + B --> B - A
1337  // -A + -B --> -(A + B)
1338  if (Value *LHSV = dyn_castFNegVal(LHS)) {
1339  Instruction *RI = BinaryOperator::CreateFSub(RHS, LHSV);
1340  RI->copyFastMathFlags(&I);
1341  return RI;
1342  }
1343 
1344  // A + -B --> A - B
1345  if (!isa<Constant>(RHS))
1346  if (Value *V = dyn_castFNegVal(RHS)) {
1347  Instruction *RI = BinaryOperator::CreateFSub(LHS, V);
1348  RI->copyFastMathFlags(&I);
1349  return RI;
1350  }
1351 
1352  // Check for (fadd double (sitofp x), y), see if we can merge this into an
1353  // integer add followed by a promotion.
1354  if (SIToFPInst *LHSConv = dyn_cast<SIToFPInst>(LHS)) {
1355  // (fadd double (sitofp x), fpcst) --> (sitofp (add int x, intcst))
1356  // ... if the constant fits in the integer value. This is useful for things
1357  // like (double)(x & 1234) + 4.0 -> (double)((X & 1234)+4) which no longer
1358  // requires a constant pool load, and generally allows the add to be better
1359  // instcombined.
1360  if (ConstantFP *CFP = dyn_cast<ConstantFP>(RHS)) {
1361  Constant *CI =
1362  ConstantExpr::getFPToSI(CFP, LHSConv->getOperand(0)->getType());
1363  if (LHSConv->hasOneUse() &&
1364  ConstantExpr::getSIToFP(CI, I.getType()) == CFP &&
1365  WillNotOverflowSignedAdd(LHSConv->getOperand(0), CI, I)) {
1366  // Insert the new integer add.
1367  Value *NewAdd = Builder->CreateNSWAdd(LHSConv->getOperand(0),
1368  CI, "addconv");
1369  return new SIToFPInst(NewAdd, I.getType());
1370  }
1371  }
1372 
1373  // (fadd double (sitofp x), (sitofp y)) --> (sitofp (add int x, y))
1374  if (SIToFPInst *RHSConv = dyn_cast<SIToFPInst>(RHS)) {
1375  // Only do this if x/y have the same type, if at last one of them has a
1376  // single use (so we don't increase the number of int->fp conversions),
1377  // and if the integer add will not overflow.
1378  if (LHSConv->getOperand(0)->getType() ==
1379  RHSConv->getOperand(0)->getType() &&
1380  (LHSConv->hasOneUse() || RHSConv->hasOneUse()) &&
1381  WillNotOverflowSignedAdd(LHSConv->getOperand(0),
1382  RHSConv->getOperand(0), I)) {
1383  // Insert the new integer add.
1384  Value *NewAdd = Builder->CreateNSWAdd(LHSConv->getOperand(0),
1385  RHSConv->getOperand(0),"addconv");
1386  return new SIToFPInst(NewAdd, I.getType());
1387  }
1388  }
1389  }
1390 
1391  // select C, 0, B + select C, A, 0 -> select C, A, B
1392  {
1393  Value *A1, *B1, *C1, *A2, *B2, *C2;
1394  if (match(LHS, m_Select(m_Value(C1), m_Value(A1), m_Value(B1))) &&
1395  match(RHS, m_Select(m_Value(C2), m_Value(A2), m_Value(B2)))) {
1396  if (C1 == C2) {
1397  Constant *Z1=nullptr, *Z2=nullptr;
1398  Value *A, *B, *C=C1;
1399  if (match(A1, m_AnyZero()) && match(B2, m_AnyZero())) {
1400  Z1 = dyn_cast<Constant>(A1); A = A2;
1401  Z2 = dyn_cast<Constant>(B2); B = B1;
1402  } else if (match(B1, m_AnyZero()) && match(A2, m_AnyZero())) {
1403  Z1 = dyn_cast<Constant>(B1); B = B2;
1404  Z2 = dyn_cast<Constant>(A2); A = A1;
1405  }
1406 
1407  if (Z1 && Z2 &&
1408  (I.hasNoSignedZeros() ||
1409  (Z1->isNegativeZeroValue() && Z2->isNegativeZeroValue()))) {
1410  return SelectInst::Create(C, A, B);
1411  }
1412  }
1413  }
1414  }
1415 
1416  if (I.hasUnsafeAlgebra()) {
1417  if (Value *V = FAddCombine(Builder).simplify(&I))
1418  return ReplaceInstUsesWith(I, V);
1419  }
1420 
1421  return Changed ? &I : nullptr;
1422 }
1423 
1424 
1425 /// Optimize pointer differences into the same array into a size. Consider:
1426 /// &A[10] - &A[0]: we should compile this to "10". LHS/RHS are the pointer
1427 /// operands to the ptrtoint instructions for the LHS/RHS of the subtract.
1428 ///
1430  Type *Ty) {
1431  // If LHS is a gep based on RHS or RHS is a gep based on LHS, we can optimize
1432  // this.
1433  bool Swapped = false;
1434  GEPOperator *GEP1 = nullptr, *GEP2 = nullptr;
1435 
1436  // For now we require one side to be the base pointer "A" or a constant
1437  // GEP derived from it.
1438  if (GEPOperator *LHSGEP = dyn_cast<GEPOperator>(LHS)) {
1439  // (gep X, ...) - X
1440  if (LHSGEP->getOperand(0) == RHS) {
1441  GEP1 = LHSGEP;
1442  Swapped = false;
1443  } else if (GEPOperator *RHSGEP = dyn_cast<GEPOperator>(RHS)) {
1444  // (gep X, ...) - (gep X, ...)
1445  if (LHSGEP->getOperand(0)->stripPointerCasts() ==
1446  RHSGEP->getOperand(0)->stripPointerCasts()) {
1447  GEP2 = RHSGEP;
1448  GEP1 = LHSGEP;
1449  Swapped = false;
1450  }
1451  }
1452  }
1453 
1454  if (GEPOperator *RHSGEP = dyn_cast<GEPOperator>(RHS)) {
1455  // X - (gep X, ...)
1456  if (RHSGEP->getOperand(0) == LHS) {
1457  GEP1 = RHSGEP;
1458  Swapped = true;
1459  } else if (GEPOperator *LHSGEP = dyn_cast<GEPOperator>(LHS)) {
1460  // (gep X, ...) - (gep X, ...)
1461  if (RHSGEP->getOperand(0)->stripPointerCasts() ==
1462  LHSGEP->getOperand(0)->stripPointerCasts()) {
1463  GEP2 = LHSGEP;
1464  GEP1 = RHSGEP;
1465  Swapped = true;
1466  }
1467  }
1468  }
1469 
1470  // Avoid duplicating the arithmetic if GEP2 has non-constant indices and
1471  // multiple users.
1472  if (!GEP1 ||
1473  (GEP2 && !GEP2->hasAllConstantIndices() && !GEP2->hasOneUse()))
1474  return nullptr;
1475 
1476  // Emit the offset of the GEP and an intptr_t.
1477  Value *Result = EmitGEPOffset(GEP1);
1478 
1479  // If we had a constant expression GEP on the other side offsetting the
1480  // pointer, subtract it from the offset we have.
1481  if (GEP2) {
1482  Value *Offset = EmitGEPOffset(GEP2);
1483  Result = Builder->CreateSub(Result, Offset);
1484  }
1485 
1486  // If we have p - gep(p, ...) then we have to negate the result.
1487  if (Swapped)
1488  Result = Builder->CreateNeg(Result, "diff.neg");
1489 
1490  return Builder->CreateIntCast(Result, Ty, true);
1491 }
1492 
1494  Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
1495 
1496  if (Value *V = SimplifyVectorOp(I))
1497  return ReplaceInstUsesWith(I, V);
1498 
1499  if (Value *V = SimplifySubInst(Op0, Op1, I.hasNoSignedWrap(),
1500  I.hasNoUnsignedWrap(), DL, TLI, DT, AC))
1501  return ReplaceInstUsesWith(I, V);
1502 
1503  // (A*B)-(A*C) -> A*(B-C) etc
1504  if (Value *V = SimplifyUsingDistributiveLaws(I))
1505  return ReplaceInstUsesWith(I, V);
1506 
1507  // If this is a 'B = x-(-A)', change to B = x+A.
1508  if (Value *V = dyn_castNegVal(Op1)) {
1510 
1511  if (const auto *BO = dyn_cast<BinaryOperator>(Op1)) {
1512  assert(BO->getOpcode() == Instruction::Sub &&
1513  "Expected a subtraction operator!");
1514  if (BO->hasNoSignedWrap() && I.hasNoSignedWrap())
1515  Res->setHasNoSignedWrap(true);
1516  } else {
1517  if (cast<Constant>(Op1)->isNotMinSignedValue() && I.hasNoSignedWrap())
1518  Res->setHasNoSignedWrap(true);
1519  }
1520 
1521  return Res;
1522  }
1523 
1524  if (I.getType()->isIntegerTy(1))
1525  return BinaryOperator::CreateXor(Op0, Op1);
1526 
1527  // Replace (-1 - A) with (~A).
1528  if (match(Op0, m_AllOnes()))
1529  return BinaryOperator::CreateNot(Op1);
1530 
1531  if (Constant *C = dyn_cast<Constant>(Op0)) {
1532  // C - ~X == X + (1+C)
1533  Value *X = nullptr;
1534  if (match(Op1, m_Not(m_Value(X))))
1535  return BinaryOperator::CreateAdd(X, AddOne(C));
1536 
1537  // Try to fold constant sub into select arguments.
1538  if (SelectInst *SI = dyn_cast<SelectInst>(Op1))
1539  if (Instruction *R = FoldOpIntoSelect(I, SI))
1540  return R;
1541 
1542  // C-(X+C2) --> (C-C2)-X
1543  Constant *C2;
1544  if (match(Op1, m_Add(m_Value(X), m_Constant(C2))))
1545  return BinaryOperator::CreateSub(ConstantExpr::getSub(C, C2), X);
1546 
1547  if (SimplifyDemandedInstructionBits(I))
1548  return &I;
1549 
1550  // Fold (sub 0, (zext bool to B)) --> (sext bool to B)
1551  if (C->isNullValue() && match(Op1, m_ZExt(m_Value(X))))
1552  if (X->getType()->getScalarType()->isIntegerTy(1))
1553  return CastInst::CreateSExtOrBitCast(X, Op1->getType());
1554 
1555  // Fold (sub 0, (sext bool to B)) --> (zext bool to B)
1556  if (C->isNullValue() && match(Op1, m_SExt(m_Value(X))))
1557  if (X->getType()->getScalarType()->isIntegerTy(1))
1558  return CastInst::CreateZExtOrBitCast(X, Op1->getType());
1559  }
1560 
1561  if (ConstantInt *C = dyn_cast<ConstantInt>(Op0)) {
1562  // -(X >>u 31) -> (X >>s 31)
1563  // -(X >>s 31) -> (X >>u 31)
1564  if (C->isZero()) {
1565  Value *X;
1566  ConstantInt *CI;
1567  if (match(Op1, m_LShr(m_Value(X), m_ConstantInt(CI))) &&
1568  // Verify we are shifting out everything but the sign bit.
1569  CI->getValue() == I.getType()->getPrimitiveSizeInBits() - 1)
1570  return BinaryOperator::CreateAShr(X, CI);
1571 
1572  if (match(Op1, m_AShr(m_Value(X), m_ConstantInt(CI))) &&
1573  // Verify we are shifting out everything but the sign bit.
1574  CI->getValue() == I.getType()->getPrimitiveSizeInBits() - 1)
1575  return BinaryOperator::CreateLShr(X, CI);
1576  }
1577 
1578  // Turn this into a xor if LHS is 2^n-1 and the remaining bits are known
1579  // zero.
1580  APInt IntVal = C->getValue();
1581  if ((IntVal + 1).isPowerOf2()) {
1582  unsigned BitWidth = I.getType()->getScalarSizeInBits();
1583  APInt KnownZero(BitWidth, 0);
1584  APInt KnownOne(BitWidth, 0);
1585  computeKnownBits(&I, KnownZero, KnownOne, 0, &I);
1586  if ((IntVal | KnownZero).isAllOnesValue()) {
1587  return BinaryOperator::CreateXor(Op1, C);
1588  }
1589  }
1590  }
1591 
1592 
1593  {
1594  Value *Y;
1595  // X-(X+Y) == -Y X-(Y+X) == -Y
1596  if (match(Op1, m_Add(m_Specific(Op0), m_Value(Y))) ||
1597  match(Op1, m_Add(m_Value(Y), m_Specific(Op0))))
1598  return BinaryOperator::CreateNeg(Y);
1599 
1600  // (X-Y)-X == -Y
1601  if (match(Op0, m_Sub(m_Specific(Op1), m_Value(Y))))
1602  return BinaryOperator::CreateNeg(Y);
1603  }
1604 
1605  // (sub (or A, B) (xor A, B)) --> (and A, B)
1606  {
1607  Value *A = nullptr, *B = nullptr;
1608  if (match(Op1, m_Xor(m_Value(A), m_Value(B))) &&
1609  (match(Op0, m_Or(m_Specific(A), m_Specific(B))) ||
1610  match(Op0, m_Or(m_Specific(B), m_Specific(A)))))
1611  return BinaryOperator::CreateAnd(A, B);
1612  }
1613 
1614  // (sub (select (a, c, b)), (select (a, d, b))) -> (select (a, (sub c, d), 0))
1615  // (sub (select (a, b, c)), (select (a, b, d))) -> (select (a, 0, (sub c, d)))
1616  if (auto *SI0 = dyn_cast<SelectInst>(Op0)) {
1617  if (auto *SI1 = dyn_cast<SelectInst>(Op1)) {
1618  if (SI0->getCondition() == SI1->getCondition()) {
1619  if (Value *V = SimplifySubInst(
1620  SI0->getFalseValue(), SI1->getFalseValue(), I.hasNoSignedWrap(),
1621  I.hasNoUnsignedWrap(), DL, TLI, DT, AC))
1622  return SelectInst::Create(
1623  SI0->getCondition(),
1624  Builder->CreateSub(SI0->getTrueValue(), SI1->getTrueValue(), "",
1625  /*HasNUW=*/I.hasNoUnsignedWrap(),
1626  /*HasNSW=*/I.hasNoSignedWrap()),
1627  V);
1628  if (Value *V = SimplifySubInst(SI0->getTrueValue(), SI1->getTrueValue(),
1629  I.hasNoSignedWrap(),
1630  I.hasNoUnsignedWrap(), DL, TLI, DT, AC))
1631  return SelectInst::Create(
1632  SI0->getCondition(), V,
1633  Builder->CreateSub(SI0->getFalseValue(), SI1->getFalseValue(), "",
1634  /*HasNUW=*/I.hasNoUnsignedWrap(),
1635  /*HasNSW=*/I.hasNoSignedWrap()));
1636  }
1637  }
1638  }
1639 
1640  if (Op0->hasOneUse()) {
1641  Value *Y = nullptr;
1642  // ((X | Y) - X) --> (~X & Y)
1643  if (match(Op0, m_Or(m_Value(Y), m_Specific(Op1))) ||
1644  match(Op0, m_Or(m_Specific(Op1), m_Value(Y))))
1645  return BinaryOperator::CreateAnd(
1646  Y, Builder->CreateNot(Op1, Op1->getName() + ".not"));
1647  }
1648 
1649  if (Op1->hasOneUse()) {
1650  Value *X = nullptr, *Y = nullptr, *Z = nullptr;
1651  Constant *C = nullptr;
1652  Constant *CI = nullptr;
1653 
1654  // (X - (Y - Z)) --> (X + (Z - Y)).
1655  if (match(Op1, m_Sub(m_Value(Y), m_Value(Z))))
1656  return BinaryOperator::CreateAdd(Op0,
1657  Builder->CreateSub(Z, Y, Op1->getName()));
1658 
1659  // (X - (X & Y)) --> (X & ~Y)
1660  //
1661  if (match(Op1, m_And(m_Value(Y), m_Specific(Op0))) ||
1662  match(Op1, m_And(m_Specific(Op0), m_Value(Y))))
1663  return BinaryOperator::CreateAnd(Op0,
1664  Builder->CreateNot(Y, Y->getName() + ".not"));
1665 
1666  // 0 - (X sdiv C) -> (X sdiv -C) provided the negation doesn't overflow.
1667  if (match(Op1, m_SDiv(m_Value(X), m_Constant(C))) && match(Op0, m_Zero()) &&
1668  C->isNotMinSignedValue() && !C->isOneValue())
1669  return BinaryOperator::CreateSDiv(X, ConstantExpr::getNeg(C));
1670 
1671  // 0 - (X << Y) -> (-X << Y) when X is freely negatable.
1672  if (match(Op1, m_Shl(m_Value(X), m_Value(Y))) && match(Op0, m_Zero()))
1673  if (Value *XNeg = dyn_castNegVal(X))
1674  return BinaryOperator::CreateShl(XNeg, Y);
1675 
1676  // X - A*-B -> X + A*B
1677  // X - -A*B -> X + A*B
1678  Value *A, *B;
1679  if (match(Op1, m_Mul(m_Value(A), m_Neg(m_Value(B)))) ||
1680  match(Op1, m_Mul(m_Neg(m_Value(A)), m_Value(B))))
1681  return BinaryOperator::CreateAdd(Op0, Builder->CreateMul(A, B));
1682 
1683  // X - A*CI -> X + A*-CI
1684  // X - CI*A -> X + A*-CI
1685  if (match(Op1, m_Mul(m_Value(A), m_Constant(CI))) ||
1686  match(Op1, m_Mul(m_Constant(CI), m_Value(A)))) {
1687  Value *NewMul = Builder->CreateMul(A, ConstantExpr::getNeg(CI));
1688  return BinaryOperator::CreateAdd(Op0, NewMul);
1689  }
1690  }
1691 
1692  // Optimize pointer differences into the same array into a size. Consider:
1693  // &A[10] - &A[0]: we should compile this to "10".
1694  Value *LHSOp, *RHSOp;
1695  if (match(Op0, m_PtrToInt(m_Value(LHSOp))) &&
1696  match(Op1, m_PtrToInt(m_Value(RHSOp))))
1697  if (Value *Res = OptimizePointerDifference(LHSOp, RHSOp, I.getType()))
1698  return ReplaceInstUsesWith(I, Res);
1699 
1700  // trunc(p)-trunc(q) -> trunc(p-q)
1701  if (match(Op0, m_Trunc(m_PtrToInt(m_Value(LHSOp)))) &&
1702  match(Op1, m_Trunc(m_PtrToInt(m_Value(RHSOp)))))
1703  if (Value *Res = OptimizePointerDifference(LHSOp, RHSOp, I.getType()))
1704  return ReplaceInstUsesWith(I, Res);
1705 
1706  bool Changed = false;
1707  if (!I.hasNoSignedWrap() && WillNotOverflowSignedSub(Op0, Op1, I)) {
1708  Changed = true;
1709  I.setHasNoSignedWrap(true);
1710  }
1711  if (!I.hasNoUnsignedWrap() && WillNotOverflowUnsignedSub(Op0, Op1, I)) {
1712  Changed = true;
1713  I.setHasNoUnsignedWrap(true);
1714  }
1715 
1716  return Changed ? &I : nullptr;
1717 }
1718 
1720  Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1);
1721 
1722  if (Value *V = SimplifyVectorOp(I))
1723  return ReplaceInstUsesWith(I, V);
1724 
1725  if (Value *V =
1726  SimplifyFSubInst(Op0, Op1, I.getFastMathFlags(), DL, TLI, DT, AC))
1727  return ReplaceInstUsesWith(I, V);
1728 
1729  // fsub nsz 0, X ==> fsub nsz -0.0, X
1730  if (I.getFastMathFlags().noSignedZeros() && match(Op0, m_Zero())) {
1731  // Subtraction from -0.0 is the canonical form of fneg.
1733  NewI->copyFastMathFlags(&I);
1734  return NewI;
1735  }
1736 
1737  if (isa<Constant>(Op0))
1738  if (SelectInst *SI = dyn_cast<SelectInst>(Op1))
1739  if (Instruction *NV = FoldOpIntoSelect(I, SI))
1740  return NV;
1741 
1742  // If this is a 'B = x-(-A)', change to B = x+A, potentially looking
1743  // through FP extensions/truncations along the way.
1744  if (Value *V = dyn_castFNegVal(Op1)) {
1745  Instruction *NewI = BinaryOperator::CreateFAdd(Op0, V);
1746  NewI->copyFastMathFlags(&I);
1747  return NewI;
1748  }
1749  if (FPTruncInst *FPTI = dyn_cast<FPTruncInst>(Op1)) {
1750  if (Value *V = dyn_castFNegVal(FPTI->getOperand(0))) {
1751  Value *NewTrunc = Builder->CreateFPTrunc(V, I.getType());
1752  Instruction *NewI = BinaryOperator::CreateFAdd(Op0, NewTrunc);
1753  NewI->copyFastMathFlags(&I);
1754  return NewI;
1755  }
1756  } else if (FPExtInst *FPEI = dyn_cast<FPExtInst>(Op1)) {
1757  if (Value *V = dyn_castFNegVal(FPEI->getOperand(0))) {
1758  Value *NewExt = Builder->CreateFPExt(V, I.getType());
1759  Instruction *NewI = BinaryOperator::CreateFAdd(Op0, NewExt);
1760  NewI->copyFastMathFlags(&I);
1761  return NewI;
1762  }
1763  }
1764 
1765  if (I.hasUnsafeAlgebra()) {
1766  if (Value *V = FAddCombine(Builder).simplify(&I))
1767  return ReplaceInstUsesWith(I, V);
1768  }
1769 
1770  return nullptr;
1771 }
Value * EmitGEPOffset(IRBuilderTy *Builder, const DataLayout &DL, User *GEP, bool NoAssumptions=false)
EmitGEPOffset - Given a getelementptr instruction/constantexpr, emit the code necessary to compute th...
Definition: Local.h:193
BinaryOp_match< LHS, RHS, Instruction::And > m_And(const LHS &L, const RHS &R)
Definition: PatternMatch.h:506
std::string & operator+=(std::string &buffer, StringRef string)
Definition: StringRef.h:557
void copyFastMathFlags(FastMathFlags FMF)
Convenience function for transferring all fast-math flag values to this instruction, which must be an operator which supports these flags.
class_match< Value > m_Value()
Match an arbitrary value and ignore it.
Definition: PatternMatch.h:64
void setHasNoSignedWrap(bool b=true)
Set or clear the nsw flag on this instruction, which must be an operator which supports this flag...
void setFastMathFlags(FastMathFlags FMF)
Convenience function for setting multiple fast-math flags on this instruction, which must be an opera...
BinaryOp_match< LHS, RHS, Instruction::Sub > m_Sub(const LHS &L, const RHS &R)
Definition: PatternMatch.h:446
static BinaryOperator * CreateNot(Value *Op, const Twine &Name="", Instruction *InsertBefore=nullptr)
match_zero m_Zero()
Match an arbitrary zero/null constant.
Definition: PatternMatch.h:137
This class represents zero extension of integer types.
BinaryOp_match< LHS, RHS, Instruction::Mul > m_Mul(const LHS &L, const RHS &R)
Definition: PatternMatch.h:458
bool isOneValue() const
Returns true if the value is one.
Definition: Constants.cpp:110
class_match< Constant > m_Constant()
Match an arbitrary Constant and ignore it.
Definition: PatternMatch.h:83
void computeKnownBits(Value *V, APInt &KnownZero, APInt &KnownOne, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr)
Determine which bits of V are known to be either zero or one and return them in the KnownZero/KnownOn...
BinaryOp_match< LHS, RHS, Instruction::AShr > m_AShr(const LHS &L, const RHS &R)
Definition: PatternMatch.h:536
bool haveNoCommonBitsSet(Value *LHS, Value *RHS, const DataLayout &DL, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr)
Returns true if LHS and RHS have no common bits set.
Instruction * visitFSub(BinaryOperator &I)
FastMathFlags getFastMathFlags() const
Convenience function for getting all the fast-math flags, which must be an operator which supports th...
F(f)
This class represents a sign extension of integer types.
unsigned getBitWidth() const
Get the number of bits in this IntegerType.
Definition: DerivedTypes.h:61
static Constant * getSub(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
Definition: Constants.cpp:2269
Value * SimplifyAddInst(Value *LHS, Value *RHS, bool isNSW, bool isNUW, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
SimplifyAddInst - Given operands for an Add, see if we can fold the result.
static bool checkRippleForAdd(const APInt &Op0KnownZero, const APInt &Op1KnownZero)
Value * CreateSub(Value *LHS, Value *RHS, const Twine &Name="", bool HasNUW=false, bool HasNSW=false)
Definition: IRBuilder.h:726
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:188
static Constant * getAdd(Constant *C1, Constant *C2, bool HasNUW=false, bool HasNSW=false)
Definition: Constants.cpp:2258
bool isNegativeZeroValue() const
isNegativeZeroValue - Return true if the value is what would be returned by getZeroValueForNegation.
Definition: Constants.cpp:45
bool match(Val *V, const Pattern &P)
Definition: PatternMatch.h:41
BinaryOp_match< LHS, RHS, Instruction::Xor > m_Xor(const LHS &L, const RHS &R)
Definition: PatternMatch.h:518
SelectInst - This class represents the LLVM 'select' instruction.
bool noSignedZeros() const
Definition: Operator.h:191
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"), clEnumValEnd))
const APInt & getValue() const
Return the constant as an APInt value reference.
Definition: Constants.h:106
void setHasNoUnsignedWrap(bool b=true)
Set or clear the nsw flag on this instruction, which must be an operator which supports this flag...
Value * SimplifyFSubInst(Value *LHS, Value *RHS, FastMathFlags FMF, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
Given operands for an FSub, see if we can fold the result.
CastClass_match< OpTy, Instruction::Trunc > m_Trunc(const OpTy &Op)
Matches Trunc.
Definition: PatternMatch.h:801
This provides a uniform API for creating instructions and inserting them into a basic block: either a...
Definition: IRBuilder.h:517
static Constant * AddOne(Constant *C)
Add one to a Constant.
Value * SimplifyFAddInst(Value *LHS, Value *RHS, FastMathFlags FMF, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
Given operands for an FAdd, see if we can fold the result.
static Constant * getSExt(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:1713
bool MaskedValueIsZero(Value *V, const APInt &Mask, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr)
MaskedValueIsZero - Return true if 'V & Mask' is known to be zero.
Windows NT (Windows on ARM)
not_match< LHS > m_Not(const LHS &L)
Definition: PatternMatch.h:854
BinaryOp_match< LHS, RHS, Instruction::Add > m_Add(const LHS &L, const RHS &R)
Definition: PatternMatch.h:434
Value * CreateAnd(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:878
static SelectInst * Create(Value *C, Value *S1, Value *S2, const Twine &NameStr="", Instruction *InsertBefore=nullptr)
Value * CreateOr(Value *LHS, Value *RHS, const Twine &Name="")
Definition: IRBuilder.h:894
CastClass_match< OpTy, Instruction::ZExt > m_ZExt(const OpTy &Op)
Matches ZExt.
Definition: PatternMatch.h:813
#define T
bool hasUnsafeAlgebra() const
Determine whether the unsafe-algebra flag is set.
class_match< ConstantInt > m_ConstantInt()
Match an arbitrary ConstantInt and ignore it.
Definition: PatternMatch.h:75
SelectClass_match< Cond, LHS, RHS > m_Select(const Cond &C, const LHS &L, const RHS &R)
Definition: PatternMatch.h:758
bool isZero() const
isZero - Return true if the value is positive or negative zero.
Definition: Constants.h:273
static BinaryOperator * CreateAdd(Value *S1, Value *S2, const Twine &Name, Instruction *InsertBefore, Value *FlagsOp)
LLVM_CONSTEXPR size_t array_lengthof(T(&)[N])
Find the length of an array.
Definition: STLExtras.h:247
static APInt getHighBitsSet(unsigned numBits, unsigned hiBitsSet)
Get a value with high bits set.
Definition: APInt.h:513
bool isNotMinSignedValue() const
Return true if the value is not the smallest signed value.
Definition: Constants.cpp:154
A self-contained host- and target-independent arbitrary-precision floating-point software implementat...
Definition: APFloat.h:122
OverflowResult computeOverflowForUnsignedAdd(Value *LHS, Value *RHS, const DataLayout &DL, AssumptionCache *AC, const Instruction *CxtI, const DominatorTree *DT)
Value * OptimizePointerDifference(Value *LHS, Value *RHS, Type *Ty)
Optimize pointer differences into the same array into a size.
#define P(N)
BinaryOp_match< LHS, RHS, Instruction::LShr > m_LShr(const LHS &L, const RHS &R)
Definition: PatternMatch.h:530
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
void setDebugLoc(DebugLoc Loc)
setDebugLoc - Set the debug location information for this instruction.
Definition: Instruction.h:227
BinaryOp_match< LHS, RHS, Instruction::SDiv > m_SDiv(const LHS &L, const RHS &R)
Definition: PatternMatch.h:476
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:45
BinaryOp_match< LHS, RHS, Instruction::Or > m_Or(const LHS &L, const RHS &R)
Definition: PatternMatch.h:512
bool isVectorTy() const
isVectorTy - True if this is an instance of VectorType.
Definition: Type.h:226
This is an important base class in LLVM.
Definition: Constant.h:41
const Value * getCondition() const
ConstantFP - Floating Point Values [float, double].
Definition: Constants.h:233
cst_pred_ty< is_all_ones > m_AllOnes()
Match an integer or vector with all bits set to true.
Definition: PatternMatch.h:252
specificval_ty m_Specific(const Value *V)
Match if we have a specific specified value.
Definition: PatternMatch.h:322
void setUnsafeAlgebra()
Definition: Operator.h:200
BinaryOp_match< LHS, RHS, Instruction::Shl > m_Shl(const LHS &L, const RHS &R)
Definition: PatternMatch.h:524
static GCMetadataPrinterRegistry::Add< ErlangGCPrinter > X("erlang","erlang-compatible garbage collector")
unsigned getBitWidth() const
Return the number of bits in the APInt.
Definition: APInt.h:1273
Value * getOperand(unsigned i) const
Definition: User.h:118
void changeSign()
Definition: APFloat.cpp:1623
Class to represent integer types.
Definition: DerivedTypes.h:37
unsigned countPopulation() const
Count the number of bits set.
Definition: APInt.h:1415
void ComputeSignBit(Value *V, bool &KnownZero, bool &KnownOne, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr)
ComputeSignBit - Determine whether the sign bit is known to be zero or one.
Instruction * visitFAdd(BinaryOperator &I)
NUW NUW NUW NUW Exact static Exact BinaryOperator * CreateNeg(Value *Op, const Twine &Name="", Instruction *InsertBefore=nullptr)
Helper functions to construct and inspect unary operations (NEG and NOT) via binary operators SUB and...
match_combine_or< match_zero, match_neg_zero > m_AnyZero()
Match an arbitrary zero/null constant.
Definition: PatternMatch.h:156
static CastInst * CreateZExtOrBitCast(Value *S, Type *Ty, const Twine &Name="", Instruction *InsertBefore=nullptr)
Create a ZExt or BitCast cast instruction.
bool hasNoSignedWrap() const
Determine whether the no signed wrap flag is set.
const Value * getTrueValue() const
bool isPowerOf2() const
Check if this APInt's value is a power of two greater than zero.
Definition: APInt.h:386
neg_match< LHS > m_Neg(const LHS &L)
Match an integer negate.
Definition: PatternMatch.h:877
CastClass_match< OpTy, Instruction::SExt > m_SExt(const OpTy &Op)
Matches SExt.
Definition: PatternMatch.h:807
unsigned countTrailingZeros() const
Count the number of trailing zero bits.
Definition: APInt.cpp:749
static Constant * getSIToFP(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:1776
static BinaryOperator * CreateFNeg(Value *Op, const Twine &Name="", Instruction *InsertBefore=nullptr)
roundingMode
IEEE-754R 4.3: Rounding-direction attributes.
Definition: APFloat.h:155
This is the shared class of boolean and integer constants.
Definition: Constants.h:47
opStatus add(const APFloat &, roundingMode)
Definition: APFloat.cpp:1676
unsigned getScalarSizeInBits() const LLVM_READONLY
getScalarSizeInBits - If this is a vector type, return the getPrimitiveSizeInBits value for the eleme...
Definition: Type.cpp:139
unsigned logBase2() const
Definition: APInt.h:1521
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:861
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:222
opStatus multiply(const APFloat &, roundingMode)
Definition: APFloat.cpp:1690
unsigned ComputeNumSignBits(Value *Op, const DataLayout &DL, unsigned Depth=0, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr, const DominatorTree *DT=nullptr)
ComputeNumSignBits - Return the number of times the sign bit of the register is replicated into the o...
static Constant * getTrunc(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:1699
static Constant * get(Type *Ty, uint64_t V, bool isSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
Definition: Constants.cpp:582
static Constant * get(Type *Ty, double V)
get() - This returns a ConstantFP, or a vector containing a splat of a ConstantFP, for the specified value in the specified type.
Definition: Constants.cpp:652
void swap(llvm::BitVector &LHS, llvm::BitVector &RHS)
Implement std::swap in terms of BitVector swap.
Definition: BitVector.h:576
Class for arbitrary precision integers.
Definition: APInt.h:73
bool isIntegerTy() const
isIntegerTy - True if this is an instance of IntegerType.
Definition: Type.h:193
CastClass_match< OpTy, Instruction::PtrToInt > m_PtrToInt(const OpTy &Op)
Matches PtrToInt.
Definition: PatternMatch.h:795
This union template exposes a suitably aligned and sized character array member which can hold elemen...
Definition: AlignOf.h:224
LLVM_ATTRIBUTE_UNUSED_RESULT std::enable_if< !is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:285
Value * SimplifySubInst(Value *LHS, Value *RHS, bool isNSW, bool isNUW, const DataLayout &DL, const TargetLibraryInfo *TLI=nullptr, const DominatorTree *DT=nullptr, AssumptionCache *AC=nullptr, const Instruction *CxtI=nullptr)
SimplifySubInst - Given operands for a Sub, see if we can fold the result.
const Type * getScalarType() const LLVM_READONLY
getScalarType - If this is a vector type, return the element type, otherwise return 'this'...
Definition: Type.cpp:51
static Constant * getNeg(Constant *C, bool HasNUW=false, bool HasNSW=false)
Definition: Constants.cpp:2239
static bool isZero(Value *V, const DataLayout &DL, DominatorTree *DT, AssumptionCache *AC)
Definition: Lint.cpp:697
Instruction * visitAdd(BinaryOperator &I)
void clearBit(unsigned bitPosition)
Set a given bit to 0.
Definition: APInt.cpp:597
#define I(x, y, z)
Definition: MD5.cpp:54
#define N
bool hasOneUse() const
Return true if there is exactly one user of this value.
Definition: Value.h:311
static Constant * getZeroValueForNegation(Type *Ty)
Floating point negation must be implemented with f(x) = -0.0 - x.
Definition: Constants.cpp:705
bool isSignBit() const
Check if the APInt's value is returned by getSignBit.
Definition: APInt.h:395
bool hasNoSignedZeros() const
Determine whether the no-signed-zeros flag is set.
const APFloat & getValueAPF() const
Definition: Constants.h:270
static CastInst * CreateSExtOrBitCast(Value *S, Type *Ty, const Twine &Name="", Instruction *InsertBefore=nullptr)
Create a SExt or BitCast cast instruction.
This class represents a cast from signed integer to floating point.
This class represents a truncation of floating point types.
unsigned getPrimitiveSizeInBits() const LLVM_READONLY
getPrimitiveSizeInBits - Return the basic size of this type if it is a primitive type.
Definition: Type.cpp:121
LLVM Value Representation.
Definition: Value.h:69
bool hasNoUnsignedWrap() const
Determine whether the no unsigned wrap flag is set.
This file provides internal interfaces used to implement the InstCombine.
unsigned getOpcode() const
getOpcode() returns a member of one of the enums like Instruction::Add.
Definition: Instruction.h:112
bool isZero() const
Returns true if and only if the float is plus or minus zero.
Definition: APFloat.h:414
cst_pred_ty< is_one > m_One()
Match an integer 1 or a vector with all elements equal to 1.
Definition: PatternMatch.h:244
static Constant * getFPToSI(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:1798
bool isInt(int64_t x)
isInt - Checks if an integer fits into the given bit width.
Definition: MathExtras.h:263
unsigned countLeadingZeros() const
The APInt version of the countLeadingZeros functions in MathExtras.h.
Definition: APInt.h:1361
const Value * getFalseValue() const
Convenience struct for specifying and reasoning about fast-math flags.
Definition: Operator.h:164
static GCMetadataPrinterRegistry::Add< OcamlGCMetadataPrinter > Y("ocaml","ocaml 3.10-compatible collector")
loop simplify
This class represents an extension of floating point types.
static Value * checkForNegativeOperand(BinaryOperator &I, InstCombiner::BuilderTy *Builder)
const fltSemantics & getSemantics() const
Definition: APFloat.h:435
opStatus subtract(const APFloat &, roundingMode)
Definition: APFloat.cpp:1683
Instruction * visitSub(BinaryOperator &I)
static Constant * SubOne(Constant *C)
Subtract one from a Constant.
bool isNormal() const
IEEE-754R isNormal: Returns true if and only if the current value is normal.
Definition: APFloat.h:405
static Constant * getXor(Constant *C1, Constant *C2)
Definition: Constants.cpp:2325