153a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner//===- InstCombineAddSub.cpp ----------------------------------------------===// 253a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner// 353a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner// The LLVM Compiler Infrastructure 453a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner// 553a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner// This file is distributed under the University of Illinois Open Source 653a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner// License. See LICENSE.TXT for details. 753a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner// 853a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner//===----------------------------------------------------------------------===// 953a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner// 1053a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner// This file implements the visit functions for add, fadd, sub, and fsub. 1153a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner// 1253a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner//===----------------------------------------------------------------------===// 1353a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 1453a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner#include "InstCombine.h" 1553a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner#include "llvm/Analysis/InstructionSimplify.h" 160b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/DataLayout.h" 1753a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner#include "llvm/Support/GetElementPtrTypeIterator.h" 1853a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner#include "llvm/Support/PatternMatch.h" 1953a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattnerusing namespace llvm; 2053a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattnerusing namespace PatternMatch; 2153a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 221a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yangnamespace { 231a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 241a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang /// Class representing coefficient of floating-point addend. 251a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang /// This class needs to be highly efficient, which is especially true for 261a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang /// the constructor. As of I write this comment, the cost of the default 271a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang /// constructor is merely 4-byte-store-zero (Assuming compiler is able to 281a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang /// perform write-merging). 291a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang /// 301a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang class FAddendCoef { 311a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang public: 321a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // The constructor has to initialize a APFloat, which is uncessary for 331a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // most addends which have coefficient either 1 or -1. So, the constructor 341a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // is expensive. In order to avoid the cost of the constructor, we should 351a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // reuse some instances whenever possible. The pre-created instances 361a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // FAddCombine::Add[0-5] embodies this idea. 371a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // 381a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang FAddendCoef() : IsFp(false), BufHasFpVal(false), IntVal(0) {} 391a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang ~FAddendCoef(); 401a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 411a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang void set(short C) { 421a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang assert(!insaneIntVal(C) && "Insane coefficient"); 431a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang IsFp = false; IntVal = C; 441a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang } 451a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 461a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang void set(const APFloat& C); 471a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 481a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang void negate(); 491a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 501a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang bool isZero() const { return isInt() ? !IntVal : getFpVal().isZero(); } 511a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Value *getValue(Type *) const; 521a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 531a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // If possible, don't define operator+/operator- etc because these 541a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // operators inevitably call FAddendCoef's constructor which is not cheap. 551a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang void operator=(const FAddendCoef &A); 561a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang void operator+=(const FAddendCoef &A); 571a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang void operator-=(const FAddendCoef &A); 581a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang void operator*=(const FAddendCoef &S); 591a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 601a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang bool isOne() const { return isInt() && IntVal == 1; } 611a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang bool isTwo() const { return isInt() && IntVal == 2; } 621a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang bool isMinusOne() const { return isInt() && IntVal == -1; } 631a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang bool isMinusTwo() const { return isInt() && IntVal == -2; } 641a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 651a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang private: 661a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang bool insaneIntVal(int V) { return V > 4 || V < -4; } 671a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang APFloat *getFpValPtr(void) 68d6b51d1dc158b82cab2e2a77b6c4b4fddb156952Shuxin Yang { return reinterpret_cast<APFloat*>(&FpValBuf.buffer[0]); } 694ee576fac3a84553c9342faea87ff0e13e8eb48dDavid Greene const APFloat *getFpValPtr(void) const 704ee576fac3a84553c9342faea87ff0e13e8eb48dDavid Greene { return reinterpret_cast<const APFloat*>(&FpValBuf.buffer[0]); } 711a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 721a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang const APFloat &getFpVal(void) const { 731a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang assert(IsFp && BufHasFpVal && "Incorret state"); 744ee576fac3a84553c9342faea87ff0e13e8eb48dDavid Greene return *getFpValPtr(); 751a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang } 761a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 771a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang APFloat &getFpVal(void) 781a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang { assert(IsFp && BufHasFpVal && "Incorret state"); return *getFpValPtr(); } 791a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 801a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang bool isInt() const { return !IsFp; } 811a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 821a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang private: 83d6b51d1dc158b82cab2e2a77b6c4b4fddb156952Shuxin Yang 841a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang bool IsFp; 851a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 861a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // True iff FpValBuf contains an instance of APFloat. 871a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang bool BufHasFpVal; 881a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 891a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // The integer coefficient of an individual addend is either 1 or -1, 901a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // and we try to simplify at most 4 addends from neighboring at most 911a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // two instructions. So the range of <IntVal> falls in [-4, 4]. APInt 921a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // is overkill of this end. 931a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang short IntVal; 94d6b51d1dc158b82cab2e2a77b6c4b4fddb156952Shuxin Yang 95d6b51d1dc158b82cab2e2a77b6c4b4fddb156952Shuxin Yang AlignedCharArrayUnion<APFloat> FpValBuf; 961a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang }; 971a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 981a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang /// FAddend is used to represent floating-point addend. An addend is 991a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang /// represented as <C, V>, where the V is a symbolic value, and C is a 1001a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang /// constant coefficient. A constant addend is represented as <C, 0>. 1011a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang /// 1021a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang class FAddend { 1031a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang public: 1041a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang FAddend() { Val = 0; } 1051a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 1061a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Value *getSymVal (void) const { return Val; } 1071a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang const FAddendCoef &getCoef(void) const { return Coeff; } 1081a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 1091a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang bool isConstant() const { return Val == 0; } 1101a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang bool isZero() const { return Coeff.isZero(); } 1111a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 1121a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang void set(short Coefficient, Value *V) { Coeff.set(Coefficient), Val = V; } 1131a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang void set(const APFloat& Coefficient, Value *V) 1141a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang { Coeff.set(Coefficient); Val = V; } 1151a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang void set(const ConstantFP* Coefficient, Value *V) 1161a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang { Coeff.set(Coefficient->getValueAPF()); Val = V; } 1171a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 1181a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang void negate() { Coeff.negate(); } 1191a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 1201a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang /// Drill down the U-D chain one step to find the definition of V, and 1211a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang /// try to break the definition into one or two addends. 1221a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang static unsigned drillValueDownOneStep(Value* V, FAddend &A0, FAddend &A1); 1231a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 1241a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang /// Similar to FAddend::drillDownOneStep() except that the value being 1251a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang /// splitted is the addend itself. 1261a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang unsigned drillAddendDownOneStep(FAddend &Addend0, FAddend &Addend1) const; 1271a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 1281a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang void operator+=(const FAddend &T) { 1291a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang assert((Val == T.Val) && "Symbolic-values disagree"); 1301a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Coeff += T.Coeff; 1311a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang } 1321a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 1331a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang private: 1341a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang void Scale(const FAddendCoef& ScaleAmt) { Coeff *= ScaleAmt; } 1351a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 1361a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // This addend has the value of "Coeff * Val". 1371a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Value *Val; 1381a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang FAddendCoef Coeff; 1391a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang }; 1401a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 1411a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang /// FAddCombine is the class for optimizing an unsafe fadd/fsub along 1421a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang /// with its neighboring at most two instructions. 1431a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang /// 1441a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang class FAddCombine { 1451a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang public: 1461a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang FAddCombine(InstCombiner::BuilderTy *B) : Builder(B), Instr(0) {} 1471a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Value *simplify(Instruction *FAdd); 1481a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 1491a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang private: 1501a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang typedef SmallVector<const FAddend*, 4> AddendVect; 1511a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 1521a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Value *simplifyFAdd(AddendVect& V, unsigned InstrQuota); 153a0c9939873c404f272b3e0abb102c335146764feShuxin Yang 154a0c9939873c404f272b3e0abb102c335146764feShuxin Yang Value *performFactorization(Instruction *I); 155a0c9939873c404f272b3e0abb102c335146764feShuxin Yang 1561a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang /// Convert given addend to a Value 1571a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Value *createAddendVal(const FAddend &A, bool& NeedNeg); 1581a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 1591a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang /// Return the number of instructions needed to emit the N-ary addition. 1601a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang unsigned calcInstrNumber(const AddendVect& Vect); 1611a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Value *createFSub(Value *Opnd0, Value *Opnd1); 1621a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Value *createFAdd(Value *Opnd0, Value *Opnd1); 1631a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Value *createFMul(Value *Opnd0, Value *Opnd1); 164a0c9939873c404f272b3e0abb102c335146764feShuxin Yang Value *createFDiv(Value *Opnd0, Value *Opnd1); 1651a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Value *createFNeg(Value *V); 1661a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Value *createNaryFAdd(const AddendVect& Opnds, unsigned InstrQuota); 1671a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang void createInstPostProc(Instruction *NewInst); 1681a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 1691a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang InstCombiner::BuilderTy *Builder; 1701a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Instruction *Instr; 1711a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 1721a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang private: 1731a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // Debugging stuff are clustered here. 1741a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang #ifndef NDEBUG 1751a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang unsigned CreateInstrNum; 1761a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang void initCreateInstNum() { CreateInstrNum = 0; } 1771a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang void incCreateInstNum() { CreateInstrNum++; } 1781a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang #else 1791a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang void initCreateInstNum() {} 1801a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang void incCreateInstNum() {} 1811a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang #endif 1821a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang }; 1831a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang} 1841a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 1851a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang//===----------------------------------------------------------------------===// 1861a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang// 1871a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang// Implementation of 1881a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang// {FAddendCoef, FAddend, FAddition, FAddCombine}. 1891a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang// 1901a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang//===----------------------------------------------------------------------===// 1911a3150098c137181576dc3e0960f8cd4abe9da1fShuxin YangFAddendCoef::~FAddendCoef() { 1921a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (BufHasFpVal) 1931a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang getFpValPtr()->~APFloat(); 1941a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang} 1951a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 1961a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yangvoid FAddendCoef::set(const APFloat& C) { 1971a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang APFloat *P = getFpValPtr(); 1981a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 1991a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (isInt()) { 2001a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // As the buffer is meanless byte stream, we cannot call 2011a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // APFloat::operator=(). 2021a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang new(P) APFloat(C); 2031a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang } else 2041a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang *P = C; 2051a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 2061a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang IsFp = BufHasFpVal = true; 2071a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang} 2081a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 2091a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yangvoid FAddendCoef::operator=(const FAddendCoef& That) { 2101a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (That.isInt()) 2111a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang set(That.IntVal); 2121a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang else 2131a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang set(That.getFpVal()); 2141a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang} 2151a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 2161a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yangvoid FAddendCoef::operator+=(const FAddendCoef &That) { 2171a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang enum APFloat::roundingMode RndMode = APFloat::rmNearestTiesToEven; 2181a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (isInt() == That.isInt()) { 2191a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (isInt()) 2201a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang IntVal += That.IntVal; 2211a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang else 2221a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang getFpVal().add(That.getFpVal(), RndMode); 2231a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang return; 2241a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang } 2251a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 2261a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (isInt()) { 2271a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang const APFloat &T = That.getFpVal(); 2281a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang set(T); 2291a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang getFpVal().add(APFloat(T.getSemantics(), IntVal), RndMode); 2301a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang return; 2311a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang } 2321a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 2331a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang APFloat &T = getFpVal(); 2341a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang T.add(APFloat(T.getSemantics(), That.IntVal), RndMode); 2351a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang} 2361a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 2371a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yangvoid FAddendCoef::operator-=(const FAddendCoef &That) { 2381a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang enum APFloat::roundingMode RndMode = APFloat::rmNearestTiesToEven; 2391a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (isInt() == That.isInt()) { 2401a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (isInt()) 2411a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang IntVal -= That.IntVal; 2421a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang else 2431a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang getFpVal().subtract(That.getFpVal(), RndMode); 2441a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang return; 2451a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang } 2461a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 2471a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (isInt()) { 2481a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang const APFloat &T = That.getFpVal(); 2491a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang set(T); 2501a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang getFpVal().subtract(APFloat(T.getSemantics(), IntVal), RndMode); 2511a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang return; 2521a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang } 2531a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 2541a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang APFloat &T = getFpVal(); 2551a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang T.subtract(APFloat(T.getSemantics(), IntVal), RndMode); 2561a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang} 2571a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 2581a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yangvoid FAddendCoef::operator*=(const FAddendCoef &That) { 2591a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (That.isOne()) 2601a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang return; 2611a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 2621a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (That.isMinusOne()) { 2631a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang negate(); 2641a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang return; 2651a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang } 2661a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 2671a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (isInt() && That.isInt()) { 2681a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang int Res = IntVal * (int)That.IntVal; 2691a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang assert(!insaneIntVal(Res) && "Insane int value"); 2701a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang IntVal = Res; 2711a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang return; 2721a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang } 2731a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 2741a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang const fltSemantics &Semantic = 2751a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang isInt() ? That.getFpVal().getSemantics() : getFpVal().getSemantics(); 2761a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 2771a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (isInt()) 2781a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang set(APFloat(Semantic, IntVal)); 2791a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang APFloat &F0 = getFpVal(); 2801a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 2811a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (That.isInt()) 2821a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang F0.multiply(APFloat(Semantic, That.IntVal), APFloat::rmNearestTiesToEven); 2831a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang else 2841a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang F0.multiply(That.getFpVal(), APFloat::rmNearestTiesToEven); 2851a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 2861a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang return; 2871a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang} 2881a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 2891a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yangvoid FAddendCoef::negate() { 2901a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (isInt()) 2911a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang IntVal = 0 - IntVal; 2921a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang else 2931a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang getFpVal().changeSign(); 2941a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang} 2951a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 2961a3150098c137181576dc3e0960f8cd4abe9da1fShuxin YangValue *FAddendCoef::getValue(Type *Ty) const { 2971a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang return isInt() ? 2981a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang ConstantFP::get(Ty, float(IntVal)) : 2991a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang ConstantFP::get(Ty->getContext(), getFpVal()); 3001a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang} 3011a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 3021a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang// The definition of <Val> Addends 3031a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang// ========================================= 3041a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang// A + B <1, A>, <1,B> 3051a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang// A - B <1, A>, <1,B> 3061a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang// 0 - B <-1, B> 3071a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang// C * A, <C, A> 3081a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang// A + C <1, A> <C, NULL> 3091a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang// 0 +/- 0 <0, NULL> (corner case) 3101a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang// 3111a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang// Legend: A and B are not constant, C is constant 3121a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang// 3131a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yangunsigned FAddend::drillValueDownOneStep 3141a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang (Value *Val, FAddend &Addend0, FAddend &Addend1) { 3151a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Instruction *I = 0; 3161a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (Val == 0 || !(I = dyn_cast<Instruction>(Val))) 3171a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang return 0; 3181a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 3191a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang unsigned Opcode = I->getOpcode(); 3201a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 3211a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (Opcode == Instruction::FAdd || Opcode == Instruction::FSub) { 3221a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang ConstantFP *C0, *C1; 3231a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Value *Opnd0 = I->getOperand(0); 3241a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Value *Opnd1 = I->getOperand(1); 3251a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if ((C0 = dyn_cast<ConstantFP>(Opnd0)) && C0->isZero()) 3261a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Opnd0 = 0; 3271a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 3281a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if ((C1 = dyn_cast<ConstantFP>(Opnd1)) && C1->isZero()) 3291a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Opnd1 = 0; 3301a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 3311a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (Opnd0) { 3321a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (!C0) 3331a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Addend0.set(1, Opnd0); 3341a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang else 3351a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Addend0.set(C0, 0); 3361a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang } 3371a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 3381a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (Opnd1) { 3391a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang FAddend &Addend = Opnd0 ? Addend1 : Addend0; 3401a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (!C1) 3411a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Addend.set(1, Opnd1); 3421a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang else 3431a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Addend.set(C1, 0); 3441a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (Opcode == Instruction::FSub) 3451a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Addend.negate(); 3461a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang } 3471a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 3481a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (Opnd0 || Opnd1) 3491a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang return Opnd0 && Opnd1 ? 2 : 1; 3501a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 3511a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // Both operands are zero. Weird! 3521a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Addend0.set(APFloat(C0->getValueAPF().getSemantics()), 0); 3531a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang return 1; 3541a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang } 3551a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 3561a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (I->getOpcode() == Instruction::FMul) { 3571a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Value *V0 = I->getOperand(0); 3581a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Value *V1 = I->getOperand(1); 3591a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (ConstantFP *C = dyn_cast<ConstantFP>(V0)) { 3601a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Addend0.set(C, V1); 3611a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang return 1; 3621a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang } 3631a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 3641a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (ConstantFP *C = dyn_cast<ConstantFP>(V1)) { 3651a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Addend0.set(C, V0); 3661a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang return 1; 3671a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang } 3681a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang } 3691a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 3701a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang return 0; 3711a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang} 3721a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 3731a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang// Try to break *this* addend into two addends. e.g. Suppose this addend is 3741a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang// <2.3, V>, and V = X + Y, by calling this function, we obtain two addends, 3751a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang// i.e. <2.3, X> and <2.3, Y>. 3761a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang// 3771a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yangunsigned FAddend::drillAddendDownOneStep 3781a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang (FAddend &Addend0, FAddend &Addend1) const { 3791a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (isConstant()) 3801a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang return 0; 3811a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 3821a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang unsigned BreakNum = FAddend::drillValueDownOneStep(Val, Addend0, Addend1); 3831a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (!BreakNum || Coeff.isOne()) 3841a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang return BreakNum; 3851a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 3861a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Addend0.Scale(Coeff); 3871a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 3881a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (BreakNum == 2) 3891a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Addend1.Scale(Coeff); 3901a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 3911a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang return BreakNum; 3921a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang} 3931a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 394a0c9939873c404f272b3e0abb102c335146764feShuxin Yang// Try to perform following optimization on the input instruction I. Return the 395a0c9939873c404f272b3e0abb102c335146764feShuxin Yang// simplified expression if was successful; otherwise, return 0. 396a0c9939873c404f272b3e0abb102c335146764feShuxin Yang// 397a0c9939873c404f272b3e0abb102c335146764feShuxin Yang// Instruction "I" is Simplified into 398a0c9939873c404f272b3e0abb102c335146764feShuxin Yang// ------------------------------------------------------- 399a0c9939873c404f272b3e0abb102c335146764feShuxin Yang// (x * y) +/- (x * z) x * (y +/- z) 400a0c9939873c404f272b3e0abb102c335146764feShuxin Yang// (y / x) +/- (z / x) (y +/- z) / x 401a0c9939873c404f272b3e0abb102c335146764feShuxin Yang// 402a0c9939873c404f272b3e0abb102c335146764feShuxin YangValue *FAddCombine::performFactorization(Instruction *I) { 403a0c9939873c404f272b3e0abb102c335146764feShuxin Yang assert((I->getOpcode() == Instruction::FAdd || 404a0c9939873c404f272b3e0abb102c335146764feShuxin Yang I->getOpcode() == Instruction::FSub) && "Expect add/sub"); 405a0c9939873c404f272b3e0abb102c335146764feShuxin Yang 406a0c9939873c404f272b3e0abb102c335146764feShuxin Yang Instruction *I0 = dyn_cast<Instruction>(I->getOperand(0)); 407a0c9939873c404f272b3e0abb102c335146764feShuxin Yang Instruction *I1 = dyn_cast<Instruction>(I->getOperand(1)); 408a0c9939873c404f272b3e0abb102c335146764feShuxin Yang 409a0c9939873c404f272b3e0abb102c335146764feShuxin Yang if (!I0 || !I1 || I0->getOpcode() != I1->getOpcode()) 410a0c9939873c404f272b3e0abb102c335146764feShuxin Yang return 0; 411a0c9939873c404f272b3e0abb102c335146764feShuxin Yang 412a0c9939873c404f272b3e0abb102c335146764feShuxin Yang bool isMpy = false; 413a0c9939873c404f272b3e0abb102c335146764feShuxin Yang if (I0->getOpcode() == Instruction::FMul) 414a0c9939873c404f272b3e0abb102c335146764feShuxin Yang isMpy = true; 415a0c9939873c404f272b3e0abb102c335146764feShuxin Yang else if (I0->getOpcode() != Instruction::FDiv) 416a0c9939873c404f272b3e0abb102c335146764feShuxin Yang return 0; 417a0c9939873c404f272b3e0abb102c335146764feShuxin Yang 418a0c9939873c404f272b3e0abb102c335146764feShuxin Yang Value *Opnd0_0 = I0->getOperand(0); 419a0c9939873c404f272b3e0abb102c335146764feShuxin Yang Value *Opnd0_1 = I0->getOperand(1); 420a0c9939873c404f272b3e0abb102c335146764feShuxin Yang Value *Opnd1_0 = I1->getOperand(0); 421a0c9939873c404f272b3e0abb102c335146764feShuxin Yang Value *Opnd1_1 = I1->getOperand(1); 422a0c9939873c404f272b3e0abb102c335146764feShuxin Yang 423a0c9939873c404f272b3e0abb102c335146764feShuxin Yang // Input Instr I Factor AddSub0 AddSub1 424a0c9939873c404f272b3e0abb102c335146764feShuxin Yang // ---------------------------------------------- 425a0c9939873c404f272b3e0abb102c335146764feShuxin Yang // (x*y) +/- (x*z) x y z 426a0c9939873c404f272b3e0abb102c335146764feShuxin Yang // (y/x) +/- (z/x) x y z 427a0c9939873c404f272b3e0abb102c335146764feShuxin Yang // 428a0c9939873c404f272b3e0abb102c335146764feShuxin Yang Value *Factor = 0; 429a0c9939873c404f272b3e0abb102c335146764feShuxin Yang Value *AddSub0 = 0, *AddSub1 = 0; 430a0c9939873c404f272b3e0abb102c335146764feShuxin Yang 431a0c9939873c404f272b3e0abb102c335146764feShuxin Yang if (isMpy) { 432a0c9939873c404f272b3e0abb102c335146764feShuxin Yang if (Opnd0_0 == Opnd1_0 || Opnd0_0 == Opnd1_1) 433a0c9939873c404f272b3e0abb102c335146764feShuxin Yang Factor = Opnd0_0; 434a0c9939873c404f272b3e0abb102c335146764feShuxin Yang else if (Opnd0_1 == Opnd1_0 || Opnd0_1 == Opnd1_1) 435a0c9939873c404f272b3e0abb102c335146764feShuxin Yang Factor = Opnd0_1; 436a0c9939873c404f272b3e0abb102c335146764feShuxin Yang 437a0c9939873c404f272b3e0abb102c335146764feShuxin Yang if (Factor) { 438a0c9939873c404f272b3e0abb102c335146764feShuxin Yang AddSub0 = (Factor == Opnd0_0) ? Opnd0_1 : Opnd0_0; 439a0c9939873c404f272b3e0abb102c335146764feShuxin Yang AddSub1 = (Factor == Opnd1_0) ? Opnd1_1 : Opnd1_0; 440a0c9939873c404f272b3e0abb102c335146764feShuxin Yang } 441a0c9939873c404f272b3e0abb102c335146764feShuxin Yang } else if (Opnd0_1 == Opnd1_1) { 442a0c9939873c404f272b3e0abb102c335146764feShuxin Yang Factor = Opnd0_1; 443a0c9939873c404f272b3e0abb102c335146764feShuxin Yang AddSub0 = Opnd0_0; 444a0c9939873c404f272b3e0abb102c335146764feShuxin Yang AddSub1 = Opnd1_0; 445a0c9939873c404f272b3e0abb102c335146764feShuxin Yang } 446a0c9939873c404f272b3e0abb102c335146764feShuxin Yang 447a0c9939873c404f272b3e0abb102c335146764feShuxin Yang if (!Factor) 448a0c9939873c404f272b3e0abb102c335146764feShuxin Yang return 0; 449a0c9939873c404f272b3e0abb102c335146764feShuxin Yang 450a0c9939873c404f272b3e0abb102c335146764feShuxin Yang // Create expression "NewAddSub = AddSub0 +/- AddsSub1" 451a0c9939873c404f272b3e0abb102c335146764feShuxin Yang Value *NewAddSub = (I->getOpcode() == Instruction::FAdd) ? 452a0c9939873c404f272b3e0abb102c335146764feShuxin Yang createFAdd(AddSub0, AddSub1) : 453a0c9939873c404f272b3e0abb102c335146764feShuxin Yang createFSub(AddSub0, AddSub1); 454a0c9939873c404f272b3e0abb102c335146764feShuxin Yang if (ConstantFP *CFP = dyn_cast<ConstantFP>(NewAddSub)) { 455a0c9939873c404f272b3e0abb102c335146764feShuxin Yang const APFloat &F = CFP->getValueAPF(); 456a0c9939873c404f272b3e0abb102c335146764feShuxin Yang if (!F.isNormal() || F.isDenormal()) 457a0c9939873c404f272b3e0abb102c335146764feShuxin Yang return 0; 458a0c9939873c404f272b3e0abb102c335146764feShuxin Yang } 459a0c9939873c404f272b3e0abb102c335146764feShuxin Yang 460a0c9939873c404f272b3e0abb102c335146764feShuxin Yang if (isMpy) 461a0c9939873c404f272b3e0abb102c335146764feShuxin Yang return createFMul(Factor, NewAddSub); 462a0c9939873c404f272b3e0abb102c335146764feShuxin Yang 463a0c9939873c404f272b3e0abb102c335146764feShuxin Yang return createFDiv(NewAddSub, Factor); 464a0c9939873c404f272b3e0abb102c335146764feShuxin Yang} 465a0c9939873c404f272b3e0abb102c335146764feShuxin Yang 4661a3150098c137181576dc3e0960f8cd4abe9da1fShuxin YangValue *FAddCombine::simplify(Instruction *I) { 4671a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang assert(I->hasUnsafeAlgebra() && "Should be in unsafe mode"); 4681a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 4691a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // Currently we are not able to handle vector type. 4701a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (I->getType()->isVectorTy()) 4711a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang return 0; 4721a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 4731a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang assert((I->getOpcode() == Instruction::FAdd || 4741a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang I->getOpcode() == Instruction::FSub) && "Expect add/sub"); 4751a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 4761a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // Save the instruction before calling other member-functions. 4771a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Instr = I; 4781a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 4791a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang FAddend Opnd0, Opnd1, Opnd0_0, Opnd0_1, Opnd1_0, Opnd1_1; 4801a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 4811a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang unsigned OpndNum = FAddend::drillValueDownOneStep(I, Opnd0, Opnd1); 4821a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 4831a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // Step 1: Expand the 1st addend into Opnd0_0 and Opnd0_1. 4841a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang unsigned Opnd0_ExpNum = 0; 4851a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang unsigned Opnd1_ExpNum = 0; 4861a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 4871a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (!Opnd0.isConstant()) 4881a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Opnd0_ExpNum = Opnd0.drillAddendDownOneStep(Opnd0_0, Opnd0_1); 4891a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 4901a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // Step 2: Expand the 2nd addend into Opnd1_0 and Opnd1_1. 4911a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (OpndNum == 2 && !Opnd1.isConstant()) 4921a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Opnd1_ExpNum = Opnd1.drillAddendDownOneStep(Opnd1_0, Opnd1_1); 4931a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 4941a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // Step 3: Try to optimize Opnd0_0 + Opnd0_1 + Opnd1_0 + Opnd1_1 4951a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (Opnd0_ExpNum && Opnd1_ExpNum) { 4961a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang AddendVect AllOpnds; 4971a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang AllOpnds.push_back(&Opnd0_0); 4981a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang AllOpnds.push_back(&Opnd1_0); 4991a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (Opnd0_ExpNum == 2) 5001a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang AllOpnds.push_back(&Opnd0_1); 5011a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (Opnd1_ExpNum == 2) 5021a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang AllOpnds.push_back(&Opnd1_1); 5031a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 5041a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // Compute instruction quota. We should save at least one instruction. 5051a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang unsigned InstQuota = 0; 5061a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 5071a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Value *V0 = I->getOperand(0); 5081a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Value *V1 = I->getOperand(1); 5091a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang InstQuota = ((!isa<Constant>(V0) && V0->hasOneUse()) && 5101a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang (!isa<Constant>(V1) && V1->hasOneUse())) ? 2 : 1; 5111a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 5121a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (Value *R = simplifyFAdd(AllOpnds, InstQuota)) 5131a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang return R; 5141a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang } 5151a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 5161a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (OpndNum != 2) { 5171a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // The input instruction is : "I=0.0 +/- V". If the "V" were able to be 5181a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // splitted into two addends, say "V = X - Y", the instruction would have 5191a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // been optimized into "I = Y - X" in the previous steps. 5201a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // 5211a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang const FAddendCoef &CE = Opnd0.getCoef(); 5221a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang return CE.isOne() ? Opnd0.getSymVal() : 0; 5231a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang } 5241a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 5251a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // step 4: Try to optimize Opnd0 + Opnd1_0 [+ Opnd1_1] 5261a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (Opnd1_ExpNum) { 5271a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang AddendVect AllOpnds; 5281a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang AllOpnds.push_back(&Opnd0); 5291a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang AllOpnds.push_back(&Opnd1_0); 5301a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (Opnd1_ExpNum == 2) 5311a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang AllOpnds.push_back(&Opnd1_1); 5321a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 5331a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (Value *R = simplifyFAdd(AllOpnds, 1)) 5341a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang return R; 5351a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang } 5361a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 5371a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // step 5: Try to optimize Opnd1 + Opnd0_0 [+ Opnd0_1] 5381a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (Opnd0_ExpNum) { 5391a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang AddendVect AllOpnds; 5401a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang AllOpnds.push_back(&Opnd1); 5411a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang AllOpnds.push_back(&Opnd0_0); 5421a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (Opnd0_ExpNum == 2) 5431a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang AllOpnds.push_back(&Opnd0_1); 5441a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 5451a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (Value *R = simplifyFAdd(AllOpnds, 1)) 5461a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang return R; 5471a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang } 5481a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 549a0c9939873c404f272b3e0abb102c335146764feShuxin Yang // step 6: Try factorization as the last resort, 550a0c9939873c404f272b3e0abb102c335146764feShuxin Yang return performFactorization(I); 5511a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang} 5521a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 5531a3150098c137181576dc3e0960f8cd4abe9da1fShuxin YangValue *FAddCombine::simplifyFAdd(AddendVect& Addends, unsigned InstrQuota) { 5541a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 5551a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang unsigned AddendNum = Addends.size(); 5561a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang assert(AddendNum <= 4 && "Too many addends"); 5571a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 5581a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // For saving intermediate results; 5591a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang unsigned NextTmpIdx = 0; 5601a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang FAddend TmpResult[3]; 5611a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 5621a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // Points to the constant addend of the resulting simplified expression. 5631a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // If the resulting expr has constant-addend, this constant-addend is 5641a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // desirable to reside at the top of the resulting expression tree. Placing 5651a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // constant close to supper-expr(s) will potentially reveal some optimization 5661a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // opportunities in super-expr(s). 5671a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // 5681a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang const FAddend *ConstAdd = 0; 5691a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 5701a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // Simplified addends are placed <SimpVect>. 5711a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang AddendVect SimpVect; 5721a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 5731a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // The outer loop works on one symbolic-value at a time. Suppose the input 5741a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // addends are : <a1, x>, <b1, y>, <a2, x>, <c1, z>, <b2, y>, ... 5751a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // The symbolic-values will be processed in this order: x, y, z. 5761a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // 5771a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang for (unsigned SymIdx = 0; SymIdx < AddendNum; SymIdx++) { 5781a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 5791a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang const FAddend *ThisAddend = Addends[SymIdx]; 5801a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (!ThisAddend) { 5811a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // This addend was processed before. 5821a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang continue; 5831a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang } 5841a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 5851a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Value *Val = ThisAddend->getSymVal(); 5861a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang unsigned StartIdx = SimpVect.size(); 5871a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang SimpVect.push_back(ThisAddend); 5881a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 5891a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // The inner loop collects addends sharing same symbolic-value, and these 5901a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // addends will be later on folded into a single addend. Following above 5911a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // example, if the symbolic value "y" is being processed, the inner loop 5921a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // will collect two addends "<b1,y>" and "<b2,Y>". These two addends will 5931a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // be later on folded into "<b1+b2, y>". 5941a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // 5951a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang for (unsigned SameSymIdx = SymIdx + 1; 5961a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang SameSymIdx < AddendNum; SameSymIdx++) { 5971a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang const FAddend *T = Addends[SameSymIdx]; 5981a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (T && T->getSymVal() == Val) { 5991a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // Set null such that next iteration of the outer loop will not process 6001a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // this addend again. 6011a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Addends[SameSymIdx] = 0; 6021a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang SimpVect.push_back(T); 6031a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang } 6041a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang } 6051a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 6061a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // If multiple addends share same symbolic value, fold them together. 6071a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (StartIdx + 1 != SimpVect.size()) { 6081a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang FAddend &R = TmpResult[NextTmpIdx ++]; 6091a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang R = *SimpVect[StartIdx]; 6101a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang for (unsigned Idx = StartIdx + 1; Idx < SimpVect.size(); Idx++) 6111a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang R += *SimpVect[Idx]; 6121a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 6131a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // Pop all addends being folded and push the resulting folded addend. 6141a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang SimpVect.resize(StartIdx); 6151a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (Val != 0) { 6161a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (!R.isZero()) { 6171a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang SimpVect.push_back(&R); 6181a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang } 6191a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang } else { 6201a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // Don't push constant addend at this time. It will be the last element 6211a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // of <SimpVect>. 6221a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang ConstAdd = &R; 6231a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang } 6241a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang } 6251a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang } 6261a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 6271a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang assert((NextTmpIdx <= sizeof(TmpResult)/sizeof(TmpResult[0]) + 1) && 6281a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang "out-of-bound access"); 6291a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 6301a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (ConstAdd) 6311a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang SimpVect.push_back(ConstAdd); 6321a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 6331a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Value *Result; 6341a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (!SimpVect.empty()) 6351a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Result = createNaryFAdd(SimpVect, InstrQuota); 6361a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang else { 6371a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // The addition is folded to 0.0. 6381a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Result = ConstantFP::get(Instr->getType(), 0.0); 6391a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang } 6401a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 6411a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang return Result; 6421a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang} 6431a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 6441a3150098c137181576dc3e0960f8cd4abe9da1fShuxin YangValue *FAddCombine::createNaryFAdd 6451a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang (const AddendVect &Opnds, unsigned InstrQuota) { 6461a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang assert(!Opnds.empty() && "Expect at least one addend"); 6471a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 6481a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // Step 1: Check if the # of instructions needed exceeds the quota. 6491a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // 6501a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang unsigned InstrNeeded = calcInstrNumber(Opnds); 6511a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (InstrNeeded > InstrQuota) 6521a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang return 0; 6531a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 6541a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang initCreateInstNum(); 6551a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 6561a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // step 2: Emit the N-ary addition. 6571a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // Note that at most three instructions are involved in Fadd-InstCombine: the 6581a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // addition in question, and at most two neighboring instructions. 6591a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // The resulting optimized addition should have at least one less instruction 6601a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // than the original addition expression tree. This implies that the resulting 6611a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // N-ary addition has at most two instructions, and we don't need to worry 6621a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // about tree-height when constructing the N-ary addition. 6631a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 6641a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Value *LastVal = 0; 6651a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang bool LastValNeedNeg = false; 6661a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 6671a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // Iterate the addends, creating fadd/fsub using adjacent two addends. 6681a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang for (AddendVect::const_iterator I = Opnds.begin(), E = Opnds.end(); 6691a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang I != E; I++) { 6701a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang bool NeedNeg; 6711a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Value *V = createAddendVal(**I, NeedNeg); 6721a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (!LastVal) { 6731a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang LastVal = V; 6741a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang LastValNeedNeg = NeedNeg; 6751a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang continue; 6761a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang } 6771a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 6781a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (LastValNeedNeg == NeedNeg) { 6791a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang LastVal = createFAdd(LastVal, V); 6801a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang continue; 6811a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang } 6821a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 6831a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (LastValNeedNeg) 6841a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang LastVal = createFSub(V, LastVal); 6851a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang else 6861a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang LastVal = createFSub(LastVal, V); 6871a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 6881a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang LastValNeedNeg = false; 6891a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang } 6901a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 6911a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (LastValNeedNeg) { 6921a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang LastVal = createFNeg(LastVal); 6931a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang } 6941a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 6951a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang #ifndef NDEBUG 6961a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang assert(CreateInstrNum == InstrNeeded && 6971a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang "Inconsistent in instruction numbers"); 6981a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang #endif 6991a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 7001a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang return LastVal; 7011a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang} 7021a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 7031a3150098c137181576dc3e0960f8cd4abe9da1fShuxin YangValue *FAddCombine::createFSub 7041a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang (Value *Opnd0, Value *Opnd1) { 7051a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Value *V = Builder->CreateFSub(Opnd0, Opnd1); 706a0c9939873c404f272b3e0abb102c335146764feShuxin Yang if (Instruction *I = dyn_cast<Instruction>(V)) 707a0c9939873c404f272b3e0abb102c335146764feShuxin Yang createInstPostProc(I); 7081a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang return V; 7091a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang} 7101a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 7111a3150098c137181576dc3e0960f8cd4abe9da1fShuxin YangValue *FAddCombine::createFNeg(Value *V) { 7121a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Value *Zero = cast<Value>(ConstantFP::get(V->getType(), 0.0)); 7131a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang return createFSub(Zero, V); 7141a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang} 7151a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 7161a3150098c137181576dc3e0960f8cd4abe9da1fShuxin YangValue *FAddCombine::createFAdd 7171a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang (Value *Opnd0, Value *Opnd1) { 7181a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Value *V = Builder->CreateFAdd(Opnd0, Opnd1); 719a0c9939873c404f272b3e0abb102c335146764feShuxin Yang if (Instruction *I = dyn_cast<Instruction>(V)) 720a0c9939873c404f272b3e0abb102c335146764feShuxin Yang createInstPostProc(I); 7211a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang return V; 7221a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang} 7231a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 7241a3150098c137181576dc3e0960f8cd4abe9da1fShuxin YangValue *FAddCombine::createFMul(Value *Opnd0, Value *Opnd1) { 7251a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Value *V = Builder->CreateFMul(Opnd0, Opnd1); 726a0c9939873c404f272b3e0abb102c335146764feShuxin Yang if (Instruction *I = dyn_cast<Instruction>(V)) 727a0c9939873c404f272b3e0abb102c335146764feShuxin Yang createInstPostProc(I); 728a0c9939873c404f272b3e0abb102c335146764feShuxin Yang return V; 729a0c9939873c404f272b3e0abb102c335146764feShuxin Yang} 730a0c9939873c404f272b3e0abb102c335146764feShuxin Yang 731a0c9939873c404f272b3e0abb102c335146764feShuxin YangValue *FAddCombine::createFDiv(Value *Opnd0, Value *Opnd1) { 732a0c9939873c404f272b3e0abb102c335146764feShuxin Yang Value *V = Builder->CreateFDiv(Opnd0, Opnd1); 733a0c9939873c404f272b3e0abb102c335146764feShuxin Yang if (Instruction *I = dyn_cast<Instruction>(V)) 734a0c9939873c404f272b3e0abb102c335146764feShuxin Yang createInstPostProc(I); 7351a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang return V; 7361a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang} 7371a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 7381a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yangvoid FAddCombine::createInstPostProc(Instruction *NewInstr) { 7391a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang NewInstr->setDebugLoc(Instr->getDebugLoc()); 7401a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 7411a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // Keep track of the number of instruction created. 7421a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang incCreateInstNum(); 7431a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 7441a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // Propagate fast-math flags 7451a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang NewInstr->setFastMathFlags(Instr->getFastMathFlags()); 7461a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang} 7471a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 7481a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang// Return the number of instruction needed to emit the N-ary addition. 7491a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang// NOTE: Keep this function in sync with createAddendVal(). 7501a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yangunsigned FAddCombine::calcInstrNumber(const AddendVect &Opnds) { 7511a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang unsigned OpndNum = Opnds.size(); 7521a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang unsigned InstrNeeded = OpndNum - 1; 7531a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 7541a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // The number of addends in the form of "(-1)*x". 7551a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang unsigned NegOpndNum = 0; 7561a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 7571a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // Adjust the number of instructions needed to emit the N-ary add. 7581a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang for (AddendVect::const_iterator I = Opnds.begin(), E = Opnds.end(); 7591a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang I != E; I++) { 7601a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang const FAddend *Opnd = *I; 7611a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (Opnd->isConstant()) 7621a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang continue; 7631a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 7641a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang const FAddendCoef &CE = Opnd->getCoef(); 7651a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (CE.isMinusOne() || CE.isMinusTwo()) 7661a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang NegOpndNum++; 7671a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 7681a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // Let the addend be "c * x". If "c == +/-1", the value of the addend 7691a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // is immediately available; otherwise, it needs exactly one instruction 7701a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang // to evaluate the value. 7711a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (!CE.isMinusOne() && !CE.isOne()) 7721a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang InstrNeeded++; 7731a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang } 7741a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (NegOpndNum == OpndNum) 7751a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang InstrNeeded++; 7761a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang return InstrNeeded; 7771a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang} 7781a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 7791a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang// Input Addend Value NeedNeg(output) 7801a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang// ================================================================ 7811a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang// Constant C C false 7821a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang// <+/-1, V> V coefficient is -1 7831a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang// <2/-2, V> "fadd V, V" coefficient is -2 7841a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang// <C, V> "fmul V, C" false 7851a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang// 7861a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang// NOTE: Keep this function in sync with FAddCombine::calcInstrNumber. 7871a3150098c137181576dc3e0960f8cd4abe9da1fShuxin YangValue *FAddCombine::createAddendVal 7881a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang (const FAddend &Opnd, bool &NeedNeg) { 7891a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang const FAddendCoef &Coeff = Opnd.getCoef(); 7901a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 7911a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (Opnd.isConstant()) { 7921a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang NeedNeg = false; 7931a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang return Coeff.getValue(Instr->getType()); 7941a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang } 7951a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 7961a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang Value *OpndVal = Opnd.getSymVal(); 7971a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 7981a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (Coeff.isMinusOne() || Coeff.isOne()) { 7991a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang NeedNeg = Coeff.isMinusOne(); 8001a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang return OpndVal; 8011a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang } 8021a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 8031a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (Coeff.isTwo() || Coeff.isMinusTwo()) { 8041a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang NeedNeg = Coeff.isMinusTwo(); 8051a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang return createFAdd(OpndVal, OpndVal); 8061a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang } 8071a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 8081a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang NeedNeg = false; 8091a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang return createFMul(OpndVal, Coeff.getValue(Instr->getType())); 8101a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang} 8111a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 81253a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner/// AddOne - Add one to a ConstantInt. 81353a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattnerstatic Constant *AddOne(Constant *C) { 81453a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner return ConstantExpr::getAdd(C, ConstantInt::get(C->getType(), 1)); 81553a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner} 8161a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 81753a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner/// SubOne - Subtract one from a ConstantInt. 81853a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattnerstatic Constant *SubOne(ConstantInt *C) { 81953a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner return ConstantInt::get(C->getContext(), C->getValue()-1); 82053a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner} 82153a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 82253a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 82353a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner// dyn_castFoldableMul - If this value is a multiply that can be folded into 82453a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner// other computations (because it has a constant operand), return the 82553a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner// non-constant operand of the multiply, and set CST to point to the multiplier. 82653a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner// Otherwise, return null. 82753a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner// 82853a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattnerstatic inline Value *dyn_castFoldableMul(Value *V, ConstantInt *&CST) { 829b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands if (!V->hasOneUse() || !V->getType()->isIntegerTy()) 8303168c7dd25193039b3dbf9ce6bb57c7da3e56f85Chris Lattner return 0; 8314d96e6f0d105e60b423a118c3c8c7c5ffffae8b2Michael Ilseman 8323168c7dd25193039b3dbf9ce6bb57c7da3e56f85Chris Lattner Instruction *I = dyn_cast<Instruction>(V); 8333168c7dd25193039b3dbf9ce6bb57c7da3e56f85Chris Lattner if (I == 0) return 0; 8344d96e6f0d105e60b423a118c3c8c7c5ffffae8b2Michael Ilseman 8353168c7dd25193039b3dbf9ce6bb57c7da3e56f85Chris Lattner if (I->getOpcode() == Instruction::Mul) 8363168c7dd25193039b3dbf9ce6bb57c7da3e56f85Chris Lattner if ((CST = dyn_cast<ConstantInt>(I->getOperand(1)))) 8373168c7dd25193039b3dbf9ce6bb57c7da3e56f85Chris Lattner return I->getOperand(0); 8383168c7dd25193039b3dbf9ce6bb57c7da3e56f85Chris Lattner if (I->getOpcode() == Instruction::Shl) 8393168c7dd25193039b3dbf9ce6bb57c7da3e56f85Chris Lattner if ((CST = dyn_cast<ConstantInt>(I->getOperand(1)))) { 8403168c7dd25193039b3dbf9ce6bb57c7da3e56f85Chris Lattner // The multiplier is really 1 << CST. 8413168c7dd25193039b3dbf9ce6bb57c7da3e56f85Chris Lattner uint32_t BitWidth = cast<IntegerType>(V->getType())->getBitWidth(); 8423168c7dd25193039b3dbf9ce6bb57c7da3e56f85Chris Lattner uint32_t CSTVal = CST->getLimitedValue(BitWidth); 8433168c7dd25193039b3dbf9ce6bb57c7da3e56f85Chris Lattner CST = ConstantInt::get(V->getType()->getContext(), 8443168c7dd25193039b3dbf9ce6bb57c7da3e56f85Chris Lattner APInt(BitWidth, 1).shl(CSTVal)); 8453168c7dd25193039b3dbf9ce6bb57c7da3e56f85Chris Lattner return I->getOperand(0); 84653a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 84753a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner return 0; 84853a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner} 84953a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 85053a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 85153a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner/// WillNotOverflowSignedAdd - Return true if we can prove that: 85253a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner/// (sext (add LHS, RHS)) === (add (sext LHS), (sext RHS)) 85353a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner/// This basically requires proving that the add in the original type would not 85453a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner/// overflow to change the sign bit or have a carry out. 85553a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattnerbool InstCombiner::WillNotOverflowSignedAdd(Value *LHS, Value *RHS) { 85653a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // There are different heuristics we can use for this. Here are some simple 85753a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // ones. 8584d96e6f0d105e60b423a118c3c8c7c5ffffae8b2Michael Ilseman 8594d96e6f0d105e60b423a118c3c8c7c5ffffae8b2Michael Ilseman // Add has the property that adding any two 2's complement numbers can only 86053a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // have one carry bit which can change a sign. As such, if LHS and RHS each 86153a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // have at least two sign bits, we know that the addition of the two values 86253a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // will sign extend fine. 86353a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (ComputeNumSignBits(LHS) > 1 && ComputeNumSignBits(RHS) > 1) 86453a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner return true; 8654d96e6f0d105e60b423a118c3c8c7c5ffffae8b2Michael Ilseman 8664d96e6f0d105e60b423a118c3c8c7c5ffffae8b2Michael Ilseman 86753a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // If one of the operands only has one non-zero bit, and if the other operand 86853a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // has a known-zero bit in a more significant place than it (not including the 86953a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // sign bit) the ripple may go up to and fill the zero, but won't change the 87053a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // sign. For example, (X & ~4) + 1. 8714d96e6f0d105e60b423a118c3c8c7c5ffffae8b2Michael Ilseman 87253a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // TODO: Implement. 8734d96e6f0d105e60b423a118c3c8c7c5ffffae8b2Michael Ilseman 87453a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner return false; 87553a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner} 87653a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 87753a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris LattnerInstruction *InstCombiner::visitAdd(BinaryOperator &I) { 878096aa79276b8527a3cbbb3691e40e729dea09523Duncan Sands bool Changed = SimplifyAssociativeOrCommutative(I); 87953a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner Value *LHS = I.getOperand(0), *RHS = I.getOperand(1); 88053a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 88153a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (Value *V = SimplifyAddInst(LHS, RHS, I.hasNoSignedWrap(), 88253a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner I.hasNoUnsignedWrap(), TD)) 88353a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner return ReplaceInstUsesWith(I, V); 88453a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 88537bf92b5238434b00fde79347ba5336e7554e562Duncan Sands // (A*B)+(A*C) -> A*(B+C) etc 88637bf92b5238434b00fde79347ba5336e7554e562Duncan Sands if (Value *V = SimplifyUsingDistributiveLaws(I)) 88737bf92b5238434b00fde79347ba5336e7554e562Duncan Sands return ReplaceInstUsesWith(I, V); 88837bf92b5238434b00fde79347ba5336e7554e562Duncan Sands 889b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) { 890b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner // X + (signbit) --> X ^ signbit 891b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner const APInt &Val = CI->getValue(); 892b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner if (Val.isSignBit()) 893b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner return BinaryOperator::CreateXor(LHS, RHS); 8944d96e6f0d105e60b423a118c3c8c7c5ffffae8b2Michael Ilseman 895b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner // See if SimplifyDemandedBits can simplify this. This handles stuff like 896b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner // (X & 254)+1 -> (X&254)|1 897b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner if (SimplifyDemandedInstructionBits(I)) 898b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner return &I; 899b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner 900b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner // zext(bool) + C -> bool ? C + 1 : C 901b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner if (ZExtInst *ZI = dyn_cast<ZExtInst>(LHS)) 902b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner if (ZI->getSrcTy()->isIntegerTy(1)) 903b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner return SelectInst::Create(ZI->getOperand(0), AddOne(CI), CI); 9044d96e6f0d105e60b423a118c3c8c7c5ffffae8b2Michael Ilseman 905b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner Value *XorLHS = 0; ConstantInt *XorRHS = 0; 906b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner if (match(LHS, m_Xor(m_Value(XorLHS), m_ConstantInt(XorRHS)))) { 90753a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner uint32_t TySizeBits = I.getType()->getScalarSizeInBits(); 908b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner const APInt &RHSVal = CI->getValue(); 909be7cfa6033d9f432a30f43870705bd57db0cbd5bEli Friedman unsigned ExtendAmt = 0; 910be7cfa6033d9f432a30f43870705bd57db0cbd5bEli Friedman // If we have ADD(XOR(AND(X, 0xFF), 0x80), 0xF..F80), it's a sext. 911be7cfa6033d9f432a30f43870705bd57db0cbd5bEli Friedman // If we have ADD(XOR(AND(X, 0xFF), 0xF..F80), 0x80), it's a sext. 912be7cfa6033d9f432a30f43870705bd57db0cbd5bEli Friedman if (XorRHS->getValue() == -RHSVal) { 913be7cfa6033d9f432a30f43870705bd57db0cbd5bEli Friedman if (RHSVal.isPowerOf2()) 914be7cfa6033d9f432a30f43870705bd57db0cbd5bEli Friedman ExtendAmt = TySizeBits - RHSVal.logBase2() - 1; 915be7cfa6033d9f432a30f43870705bd57db0cbd5bEli Friedman else if (XorRHS->getValue().isPowerOf2()) 916be7cfa6033d9f432a30f43870705bd57db0cbd5bEli Friedman ExtendAmt = TySizeBits - XorRHS->getValue().logBase2() - 1; 91753a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 9184d96e6f0d105e60b423a118c3c8c7c5ffffae8b2Michael Ilseman 919be7cfa6033d9f432a30f43870705bd57db0cbd5bEli Friedman if (ExtendAmt) { 920be7cfa6033d9f432a30f43870705bd57db0cbd5bEli Friedman APInt Mask = APInt::getHighBitsSet(TySizeBits, ExtendAmt); 921be7cfa6033d9f432a30f43870705bd57db0cbd5bEli Friedman if (!MaskedValueIsZero(XorLHS, Mask)) 922be7cfa6033d9f432a30f43870705bd57db0cbd5bEli Friedman ExtendAmt = 0; 923be7cfa6033d9f432a30f43870705bd57db0cbd5bEli Friedman } 9244d96e6f0d105e60b423a118c3c8c7c5ffffae8b2Michael Ilseman 925be7cfa6033d9f432a30f43870705bd57db0cbd5bEli Friedman if (ExtendAmt) { 926be7cfa6033d9f432a30f43870705bd57db0cbd5bEli Friedman Constant *ShAmt = ConstantInt::get(I.getType(), ExtendAmt); 927be7cfa6033d9f432a30f43870705bd57db0cbd5bEli Friedman Value *NewShl = Builder->CreateShl(XorLHS, ShAmt, "sext"); 928be7cfa6033d9f432a30f43870705bd57db0cbd5bEli Friedman return BinaryOperator::CreateAShr(NewShl, ShAmt); 92953a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 93049064ff7708bcd3b720ce79bc7629c2f3207b8d6Benjamin Kramer 93149064ff7708bcd3b720ce79bc7629c2f3207b8d6Benjamin Kramer // If this is a xor that was canonicalized from a sub, turn it back into 93249064ff7708bcd3b720ce79bc7629c2f3207b8d6Benjamin Kramer // a sub and fuse this add with it. 93349064ff7708bcd3b720ce79bc7629c2f3207b8d6Benjamin Kramer if (LHS->hasOneUse() && (XorRHS->getValue()+1).isPowerOf2()) { 93449064ff7708bcd3b720ce79bc7629c2f3207b8d6Benjamin Kramer IntegerType *IT = cast<IntegerType>(I.getType()); 93549064ff7708bcd3b720ce79bc7629c2f3207b8d6Benjamin Kramer APInt LHSKnownOne(IT->getBitWidth(), 0); 93649064ff7708bcd3b720ce79bc7629c2f3207b8d6Benjamin Kramer APInt LHSKnownZero(IT->getBitWidth(), 0); 93726c8dcc692fb2addd475446cfff24d6a4e958bcaRafael Espindola ComputeMaskedBits(XorLHS, LHSKnownZero, LHSKnownOne); 93849064ff7708bcd3b720ce79bc7629c2f3207b8d6Benjamin Kramer if ((XorRHS->getValue() | LHSKnownZero).isAllOnesValue()) 93949064ff7708bcd3b720ce79bc7629c2f3207b8d6Benjamin Kramer return BinaryOperator::CreateSub(ConstantExpr::getAdd(XorRHS, CI), 94049064ff7708bcd3b720ce79bc7629c2f3207b8d6Benjamin Kramer XorLHS); 94149064ff7708bcd3b720ce79bc7629c2f3207b8d6Benjamin Kramer } 94253a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 94353a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 94453a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 945b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner if (isa<Constant>(RHS) && isa<PHINode>(LHS)) 946b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner if (Instruction *NV = FoldOpIntoPhi(I)) 947b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner return NV; 948b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner 949b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands if (I.getType()->isIntegerTy(1)) 95053a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner return BinaryOperator::CreateXor(LHS, RHS); 95153a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 952b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner // X + X --> X << 1 953bd9f6bf5cd5499715e216415989c29f820a7561cChris Lattner if (LHS == RHS) { 95441429e3f1e4d72ee4f7d4df786b5b0c87405f5b0Chris Lattner BinaryOperator *New = 95541429e3f1e4d72ee4f7d4df786b5b0c87405f5b0Chris Lattner BinaryOperator::CreateShl(LHS, ConstantInt::get(I.getType(), 1)); 95641429e3f1e4d72ee4f7d4df786b5b0c87405f5b0Chris Lattner New->setHasNoSignedWrap(I.hasNoSignedWrap()); 95741429e3f1e4d72ee4f7d4df786b5b0c87405f5b0Chris Lattner New->setHasNoUnsignedWrap(I.hasNoUnsignedWrap()); 95841429e3f1e4d72ee4f7d4df786b5b0c87405f5b0Chris Lattner return New; 95941429e3f1e4d72ee4f7d4df786b5b0c87405f5b0Chris Lattner } 96053a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 96153a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // -A + B --> B - A 96253a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // -A + -B --> -(A + B) 96353a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (Value *LHSV = dyn_castNegVal(LHS)) { 9640f68fbb9e5a6ccc59c3c75581d4e594347ca4c92Nuno Lopes if (!isa<Constant>(RHS)) 9650f68fbb9e5a6ccc59c3c75581d4e594347ca4c92Nuno Lopes if (Value *RHSV = dyn_castNegVal(RHS)) { 9660f68fbb9e5a6ccc59c3c75581d4e594347ca4c92Nuno Lopes Value *NewAdd = Builder->CreateAdd(LHSV, RHSV, "sum"); 9670f68fbb9e5a6ccc59c3c75581d4e594347ca4c92Nuno Lopes return BinaryOperator::CreateNeg(NewAdd); 9680f68fbb9e5a6ccc59c3c75581d4e594347ca4c92Nuno Lopes } 9694d96e6f0d105e60b423a118c3c8c7c5ffffae8b2Michael Ilseman 97053a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner return BinaryOperator::CreateSub(RHS, LHSV); 97153a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 97253a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 97353a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // A + -B --> A - B 97453a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (!isa<Constant>(RHS)) 97553a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (Value *V = dyn_castNegVal(RHS)) 97653a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner return BinaryOperator::CreateSub(LHS, V); 97753a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 97853a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 97953a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner ConstantInt *C2; 98053a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (Value *X = dyn_castFoldableMul(LHS, C2)) { 98153a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (X == RHS) // X*C + X --> X * (C+1) 98253a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner return BinaryOperator::CreateMul(RHS, AddOne(C2)); 98353a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 98453a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // X*C1 + X*C2 --> X * (C1+C2) 98553a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner ConstantInt *C1; 98653a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (X == dyn_castFoldableMul(RHS, C1)) 98753a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner return BinaryOperator::CreateMul(X, ConstantExpr::getAdd(C1, C2)); 98853a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 98953a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 99053a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // X + X*C --> X * (C+1) 99153a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (dyn_castFoldableMul(RHS, C2) == LHS) 99253a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner return BinaryOperator::CreateMul(LHS, AddOne(C2)); 99353a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 99494c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // A+B --> A|B iff A and B have no bits set in common. 995db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (IntegerType *IT = dyn_cast<IntegerType>(I.getType())) { 99653a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner APInt LHSKnownOne(IT->getBitWidth(), 0); 99753a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner APInt LHSKnownZero(IT->getBitWidth(), 0); 99826c8dcc692fb2addd475446cfff24d6a4e958bcaRafael Espindola ComputeMaskedBits(LHS, LHSKnownZero, LHSKnownOne); 99953a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (LHSKnownZero != 0) { 100053a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner APInt RHSKnownOne(IT->getBitWidth(), 0); 100153a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner APInt RHSKnownZero(IT->getBitWidth(), 0); 100226c8dcc692fb2addd475446cfff24d6a4e958bcaRafael Espindola ComputeMaskedBits(RHS, RHSKnownZero, RHSKnownOne); 10034d96e6f0d105e60b423a118c3c8c7c5ffffae8b2Michael Ilseman 100453a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // No bits in common -> bitwise or. 100553a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if ((LHSKnownZero|RHSKnownZero).isAllOnesValue()) 100653a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner return BinaryOperator::CreateOr(LHS, RHS); 100753a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 100853a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 100953a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 101094c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // W*X + Y*Z --> W * (X+Z) iff W == Y 1011b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner { 101253a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner Value *W, *X, *Y, *Z; 101353a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (match(LHS, m_Mul(m_Value(W), m_Value(X))) && 101453a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner match(RHS, m_Mul(m_Value(Y), m_Value(Z)))) { 101553a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (W != Y) { 101653a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (W == Z) { 101753a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner std::swap(Y, Z); 101853a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } else if (Y == X) { 101953a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner std::swap(W, X); 102053a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } else if (X == Z) { 102153a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner std::swap(Y, Z); 102253a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner std::swap(W, X); 102353a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 102453a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 102553a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 102653a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (W == Y) { 102753a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner Value *NewAdd = Builder->CreateAdd(X, Z, LHS->getName()); 102853a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner return BinaryOperator::CreateMul(W, NewAdd); 102953a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 103053a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 103153a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 103253a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 103353a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (ConstantInt *CRHS = dyn_cast<ConstantInt>(RHS)) { 103453a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner Value *X = 0; 103553a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (match(LHS, m_Not(m_Value(X)))) // ~X + C --> (C-1) - X 103653a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner return BinaryOperator::CreateSub(SubOne(CRHS), X); 103753a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 103853a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // (X & FF00) + xx00 -> (X+xx00) & FF00 103953a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (LHS->hasOneUse() && 1040b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner match(LHS, m_And(m_Value(X), m_ConstantInt(C2))) && 1041b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner CRHS->getValue() == (CRHS->getValue() & C2->getValue())) { 1042b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner // See if all bits from the first bit set in the Add RHS up are included 1043b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner // in the mask. First, get the rightmost bit. 1044b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner const APInt &AddRHSV = CRHS->getValue(); 10454d96e6f0d105e60b423a118c3c8c7c5ffffae8b2Michael Ilseman 1046b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner // Form a mask of all bits from the lowest bit added through the top. 1047b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner APInt AddRHSHighBits(~((AddRHSV & -AddRHSV)-1)); 1048b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner 1049b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner // See if the and mask includes all of these bits. 1050b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner APInt AddRHSHighBitsAnd(AddRHSHighBits & C2->getValue()); 1051b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner 1052b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner if (AddRHSHighBits == AddRHSHighBitsAnd) { 1053b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner // Okay, the xform is safe. Insert the new add pronto. 1054b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner Value *NewAdd = Builder->CreateAdd(X, CRHS, LHS->getName()); 1055b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner return BinaryOperator::CreateAnd(NewAdd, C2); 105653a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 105753a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 105853a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 105953a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // Try to fold constant add into select arguments. 106053a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (SelectInst *SI = dyn_cast<SelectInst>(LHS)) 106153a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (Instruction *R = FoldOpIntoSelect(I, SI)) 106253a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner return R; 106353a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 106453a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 106553a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // add (select X 0 (sub n A)) A --> select X A n 106653a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner { 106753a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner SelectInst *SI = dyn_cast<SelectInst>(LHS); 106853a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner Value *A = RHS; 106953a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (!SI) { 107053a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner SI = dyn_cast<SelectInst>(RHS); 107153a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner A = LHS; 107253a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 107353a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (SI && SI->hasOneUse()) { 107453a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner Value *TV = SI->getTrueValue(); 107553a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner Value *FV = SI->getFalseValue(); 107653a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner Value *N; 107753a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 107853a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // Can we fold the add into the argument of the select? 107953a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // We check both true and false select arguments for a matching subtract. 1080b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner if (match(FV, m_Zero()) && match(TV, m_Sub(m_Value(N), m_Specific(A)))) 108153a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // Fold the add into the true select value. 108253a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner return SelectInst::Create(SI->getCondition(), N, A); 10834d96e6f0d105e60b423a118c3c8c7c5ffffae8b2Michael Ilseman 1084b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner if (match(TV, m_Zero()) && match(FV, m_Sub(m_Value(N), m_Specific(A)))) 108553a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // Fold the add into the false select value. 108653a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner return SelectInst::Create(SI->getCondition(), A, N); 108753a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 108853a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 108953a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 109053a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // Check for (add (sext x), y), see if we can merge this into an 109153a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // integer add followed by a sext. 109253a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (SExtInst *LHSConv = dyn_cast<SExtInst>(LHS)) { 109353a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // (add (sext x), cst) --> (sext (add x, cst')) 109453a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (ConstantInt *RHSC = dyn_cast<ConstantInt>(RHS)) { 10954d96e6f0d105e60b423a118c3c8c7c5ffffae8b2Michael Ilseman Constant *CI = 109653a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner ConstantExpr::getTrunc(RHSC, LHSConv->getOperand(0)->getType()); 109753a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (LHSConv->hasOneUse() && 109853a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner ConstantExpr::getSExt(CI, I.getType()) == RHSC && 109953a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner WillNotOverflowSignedAdd(LHSConv->getOperand(0), CI)) { 110053a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // Insert the new, smaller add. 11014d96e6f0d105e60b423a118c3c8c7c5ffffae8b2Michael Ilseman Value *NewAdd = Builder->CreateNSWAdd(LHSConv->getOperand(0), 110253a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner CI, "addconv"); 110353a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner return new SExtInst(NewAdd, I.getType()); 110453a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 110553a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 11064d96e6f0d105e60b423a118c3c8c7c5ffffae8b2Michael Ilseman 110753a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // (add (sext x), (sext y)) --> (sext (add int x, y)) 110853a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (SExtInst *RHSConv = dyn_cast<SExtInst>(RHS)) { 110953a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // Only do this if x/y have the same type, if at last one of them has a 111053a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // single use (so we don't increase the number of sexts), and if the 111153a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // integer add will not overflow. 111253a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (LHSConv->getOperand(0)->getType()==RHSConv->getOperand(0)->getType()&& 111353a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner (LHSConv->hasOneUse() || RHSConv->hasOneUse()) && 111453a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner WillNotOverflowSignedAdd(LHSConv->getOperand(0), 111553a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner RHSConv->getOperand(0))) { 111653a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // Insert the new integer add. 11174d96e6f0d105e60b423a118c3c8c7c5ffffae8b2Michael Ilseman Value *NewAdd = Builder->CreateNSWAdd(LHSConv->getOperand(0), 11183168c7dd25193039b3dbf9ce6bb57c7da3e56f85Chris Lattner RHSConv->getOperand(0), "addconv"); 111953a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner return new SExtInst(NewAdd, I.getType()); 112053a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 112153a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 112253a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 112353a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 1124c1fc5e4464788be072509eab7d66a73dc7a5f275Chad Rosier // Check for (x & y) + (x ^ y) 1125c1fc5e4464788be072509eab7d66a73dc7a5f275Chad Rosier { 1126c1fc5e4464788be072509eab7d66a73dc7a5f275Chad Rosier Value *A = 0, *B = 0; 1127c1fc5e4464788be072509eab7d66a73dc7a5f275Chad Rosier if (match(RHS, m_Xor(m_Value(A), m_Value(B))) && 1128c1fc5e4464788be072509eab7d66a73dc7a5f275Chad Rosier (match(LHS, m_And(m_Specific(A), m_Specific(B))) || 1129c1fc5e4464788be072509eab7d66a73dc7a5f275Chad Rosier match(LHS, m_And(m_Specific(B), m_Specific(A))))) 1130c1fc5e4464788be072509eab7d66a73dc7a5f275Chad Rosier return BinaryOperator::CreateOr(A, B); 1131c1fc5e4464788be072509eab7d66a73dc7a5f275Chad Rosier 1132c1fc5e4464788be072509eab7d66a73dc7a5f275Chad Rosier if (match(LHS, m_Xor(m_Value(A), m_Value(B))) && 1133c1fc5e4464788be072509eab7d66a73dc7a5f275Chad Rosier (match(RHS, m_And(m_Specific(A), m_Specific(B))) || 1134c1fc5e4464788be072509eab7d66a73dc7a5f275Chad Rosier match(RHS, m_And(m_Specific(B), m_Specific(A))))) 1135c1fc5e4464788be072509eab7d66a73dc7a5f275Chad Rosier return BinaryOperator::CreateOr(A, B); 1136c1fc5e4464788be072509eab7d66a73dc7a5f275Chad Rosier } 1137c1fc5e4464788be072509eab7d66a73dc7a5f275Chad Rosier 113853a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner return Changed ? &I : 0; 113953a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner} 114053a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 114153a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris LattnerInstruction *InstCombiner::visitFAdd(BinaryOperator &I) { 1142096aa79276b8527a3cbbb3691e40e729dea09523Duncan Sands bool Changed = SimplifyAssociativeOrCommutative(I); 114353a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner Value *LHS = I.getOperand(0), *RHS = I.getOperand(1); 114453a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 1145c244f381768e2e6ab9daa807adbee18de4756a07Michael Ilseman if (Value *V = SimplifyFAddInst(LHS, RHS, I.getFastMathFlags(), TD)) 1146c244f381768e2e6ab9daa807adbee18de4756a07Michael Ilseman return ReplaceInstUsesWith(I, V); 114753a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 114807acee7a09c4895904f827bf56cf15f6bf8ef9f6Michael Ilseman if (isa<Constant>(RHS) && isa<PHINode>(LHS)) 114907acee7a09c4895904f827bf56cf15f6bf8ef9f6Michael Ilseman if (Instruction *NV = FoldOpIntoPhi(I)) 115007acee7a09c4895904f827bf56cf15f6bf8ef9f6Michael Ilseman return NV; 115107acee7a09c4895904f827bf56cf15f6bf8ef9f6Michael Ilseman 115253a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // -A + B --> B - A 115353a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // -A + -B --> -(A + B) 115453a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (Value *LHSV = dyn_castFNegVal(LHS)) 115553a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner return BinaryOperator::CreateFSub(RHS, LHSV); 115653a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 115753a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // A + -B --> A - B 115853a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (!isa<Constant>(RHS)) 115953a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (Value *V = dyn_castFNegVal(RHS)) 116053a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner return BinaryOperator::CreateFSub(LHS, V); 116153a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 1162a9445e11c553855a6caacbbbf77a9b993ecc651eDan Gohman // Check for (fadd double (sitofp x), y), see if we can merge this into an 116353a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // integer add followed by a promotion. 116453a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (SIToFPInst *LHSConv = dyn_cast<SIToFPInst>(LHS)) { 1165a9445e11c553855a6caacbbbf77a9b993ecc651eDan Gohman // (fadd double (sitofp x), fpcst) --> (sitofp (add int x, intcst)) 116653a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // ... if the constant fits in the integer value. This is useful for things 116753a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // like (double)(x & 1234) + 4.0 -> (double)((X & 1234)+4) which no longer 116853a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // requires a constant pool load, and generally allows the add to be better 116953a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // instcombined. 117053a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (ConstantFP *CFP = dyn_cast<ConstantFP>(RHS)) { 11714d96e6f0d105e60b423a118c3c8c7c5ffffae8b2Michael Ilseman Constant *CI = 117253a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner ConstantExpr::getFPToSI(CFP, LHSConv->getOperand(0)->getType()); 117353a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (LHSConv->hasOneUse() && 117453a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner ConstantExpr::getSIToFP(CI, I.getType()) == CFP && 117553a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner WillNotOverflowSignedAdd(LHSConv->getOperand(0), CI)) { 117653a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // Insert the new integer add. 117753a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner Value *NewAdd = Builder->CreateNSWAdd(LHSConv->getOperand(0), 117853a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner CI, "addconv"); 117953a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner return new SIToFPInst(NewAdd, I.getType()); 118053a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 118153a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 11824d96e6f0d105e60b423a118c3c8c7c5ffffae8b2Michael Ilseman 1183a9445e11c553855a6caacbbbf77a9b993ecc651eDan Gohman // (fadd double (sitofp x), (sitofp y)) --> (sitofp (add int x, y)) 118453a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (SIToFPInst *RHSConv = dyn_cast<SIToFPInst>(RHS)) { 118553a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // Only do this if x/y have the same type, if at last one of them has a 118653a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // single use (so we don't increase the number of int->fp conversions), 118753a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // and if the integer add will not overflow. 118853a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (LHSConv->getOperand(0)->getType()==RHSConv->getOperand(0)->getType()&& 118953a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner (LHSConv->hasOneUse() || RHSConv->hasOneUse()) && 119053a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner WillNotOverflowSignedAdd(LHSConv->getOperand(0), 119153a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner RHSConv->getOperand(0))) { 119253a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // Insert the new integer add. 11934d96e6f0d105e60b423a118c3c8c7c5ffffae8b2Michael Ilseman Value *NewAdd = Builder->CreateNSWAdd(LHSConv->getOperand(0), 119453a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner RHSConv->getOperand(0),"addconv"); 119553a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner return new SIToFPInst(NewAdd, I.getType()); 119653a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 119753a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 119853a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 11994d96e6f0d105e60b423a118c3c8c7c5ffffae8b2Michael Ilseman 12001a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (I.hasUnsafeAlgebra()) { 12011a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (Value *V = FAddCombine(Builder).simplify(&I)) 12021a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang return ReplaceInstUsesWith(I, V); 12031a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang } 12041a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 120553a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner return Changed ? &I : 0; 120653a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner} 120753a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 120853a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 120953a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner/// Optimize pointer differences into the same array into a size. Consider: 121053a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner/// &A[10] - &A[0]: we should compile this to "10". LHS/RHS are the pointer 121153a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner/// operands to the ptrtoint instructions for the LHS/RHS of the subtract. 121253a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner/// 121353a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris LattnerValue *InstCombiner::OptimizePointerDifference(Value *LHS, Value *RHS, 1214db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty) { 121553a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner assert(TD && "Must have target data info for this"); 12164d96e6f0d105e60b423a118c3c8c7c5ffffae8b2Michael Ilseman 121753a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // If LHS is a gep based on RHS or RHS is a gep based on LHS, we can optimize 121853a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // this. 121953a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner bool Swapped = false; 1220d2348639e639573a7708de9ea98dc55bade048a6Benjamin Kramer GEPOperator *GEP1 = 0, *GEP2 = 0; 1221d2348639e639573a7708de9ea98dc55bade048a6Benjamin Kramer 122253a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // For now we require one side to be the base pointer "A" or a constant 1223d2348639e639573a7708de9ea98dc55bade048a6Benjamin Kramer // GEP derived from it. 1224d2348639e639573a7708de9ea98dc55bade048a6Benjamin Kramer if (GEPOperator *LHSGEP = dyn_cast<GEPOperator>(LHS)) { 122553a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // (gep X, ...) - X 122653a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (LHSGEP->getOperand(0) == RHS) { 1227d2348639e639573a7708de9ea98dc55bade048a6Benjamin Kramer GEP1 = LHSGEP; 122853a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner Swapped = false; 1229d2348639e639573a7708de9ea98dc55bade048a6Benjamin Kramer } else if (GEPOperator *RHSGEP = dyn_cast<GEPOperator>(RHS)) { 1230d2348639e639573a7708de9ea98dc55bade048a6Benjamin Kramer // (gep X, ...) - (gep X, ...) 1231d2348639e639573a7708de9ea98dc55bade048a6Benjamin Kramer if (LHSGEP->getOperand(0)->stripPointerCasts() == 1232d2348639e639573a7708de9ea98dc55bade048a6Benjamin Kramer RHSGEP->getOperand(0)->stripPointerCasts()) { 1233d2348639e639573a7708de9ea98dc55bade048a6Benjamin Kramer GEP2 = RHSGEP; 1234d2348639e639573a7708de9ea98dc55bade048a6Benjamin Kramer GEP1 = LHSGEP; 123553a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner Swapped = false; 123653a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 123753a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 123853a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 12394d96e6f0d105e60b423a118c3c8c7c5ffffae8b2Michael Ilseman 1240d2348639e639573a7708de9ea98dc55bade048a6Benjamin Kramer if (GEPOperator *RHSGEP = dyn_cast<GEPOperator>(RHS)) { 124153a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // X - (gep X, ...) 124253a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (RHSGEP->getOperand(0) == LHS) { 1243d2348639e639573a7708de9ea98dc55bade048a6Benjamin Kramer GEP1 = RHSGEP; 124453a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner Swapped = true; 1245d2348639e639573a7708de9ea98dc55bade048a6Benjamin Kramer } else if (GEPOperator *LHSGEP = dyn_cast<GEPOperator>(LHS)) { 1246d2348639e639573a7708de9ea98dc55bade048a6Benjamin Kramer // (gep X, ...) - (gep X, ...) 1247d2348639e639573a7708de9ea98dc55bade048a6Benjamin Kramer if (RHSGEP->getOperand(0)->stripPointerCasts() == 1248d2348639e639573a7708de9ea98dc55bade048a6Benjamin Kramer LHSGEP->getOperand(0)->stripPointerCasts()) { 1249d2348639e639573a7708de9ea98dc55bade048a6Benjamin Kramer GEP2 = LHSGEP; 1250d2348639e639573a7708de9ea98dc55bade048a6Benjamin Kramer GEP1 = RHSGEP; 125153a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner Swapped = true; 125253a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 125353a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 125453a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 12554d96e6f0d105e60b423a118c3c8c7c5ffffae8b2Michael Ilseman 1256d2348639e639573a7708de9ea98dc55bade048a6Benjamin Kramer // Avoid duplicating the arithmetic if GEP2 has non-constant indices and 1257d2348639e639573a7708de9ea98dc55bade048a6Benjamin Kramer // multiple users. 1258d2348639e639573a7708de9ea98dc55bade048a6Benjamin Kramer if (GEP1 == 0 || 1259d2348639e639573a7708de9ea98dc55bade048a6Benjamin Kramer (GEP2 != 0 && !GEP2->hasAllConstantIndices() && !GEP2->hasOneUse())) 126053a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner return 0; 12614d96e6f0d105e60b423a118c3c8c7c5ffffae8b2Michael Ilseman 126253a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // Emit the offset of the GEP and an intptr_t. 1263d2348639e639573a7708de9ea98dc55bade048a6Benjamin Kramer Value *Result = EmitGEPOffset(GEP1); 12644d96e6f0d105e60b423a118c3c8c7c5ffffae8b2Michael Ilseman 126553a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // If we had a constant expression GEP on the other side offsetting the 126653a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // pointer, subtract it from the offset we have. 1267d2348639e639573a7708de9ea98dc55bade048a6Benjamin Kramer if (GEP2) { 1268d2348639e639573a7708de9ea98dc55bade048a6Benjamin Kramer Value *Offset = EmitGEPOffset(GEP2); 1269d2348639e639573a7708de9ea98dc55bade048a6Benjamin Kramer Result = Builder->CreateSub(Result, Offset); 127053a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 127153a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 127253a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // If we have p - gep(p, ...) then we have to negate the result. 127353a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (Swapped) 127453a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner Result = Builder->CreateNeg(Result, "diff.neg"); 127553a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 127653a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner return Builder->CreateIntCast(Result, Ty, true); 127753a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner} 127853a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 127953a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 128053a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris LattnerInstruction *InstCombiner::visitSub(BinaryOperator &I) { 128153a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1); 128253a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 1283fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands if (Value *V = SimplifySubInst(Op0, Op1, I.hasNoSignedWrap(), 1284fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands I.hasNoUnsignedWrap(), TD)) 1285fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return ReplaceInstUsesWith(I, V); 128653a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 128737bf92b5238434b00fde79347ba5336e7554e562Duncan Sands // (A*B)-(A*C) -> A*(B-C) etc 128837bf92b5238434b00fde79347ba5336e7554e562Duncan Sands if (Value *V = SimplifyUsingDistributiveLaws(I)) 128937bf92b5238434b00fde79347ba5336e7554e562Duncan Sands return ReplaceInstUsesWith(I, V); 129037bf92b5238434b00fde79347ba5336e7554e562Duncan Sands 129153a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // If this is a 'B = x-(-A)', change to B = x+A. This preserves NSW/NUW. 129253a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (Value *V = dyn_castNegVal(Op1)) { 129353a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner BinaryOperator *Res = BinaryOperator::CreateAdd(Op0, V); 129453a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner Res->setHasNoSignedWrap(I.hasNoSignedWrap()); 129553a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner Res->setHasNoUnsignedWrap(I.hasNoUnsignedWrap()); 129653a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner return Res; 129753a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 129853a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 1299b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands if (I.getType()->isIntegerTy(1)) 130053a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner return BinaryOperator::CreateXor(Op0, Op1); 1301b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner 1302b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner // Replace (-1 - A) with (~A). 1303b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner if (match(Op0, m_AllOnes())) 1304b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner return BinaryOperator::CreateNot(Op1); 13054d96e6f0d105e60b423a118c3c8c7c5ffffae8b2Michael Ilseman 130653a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (ConstantInt *C = dyn_cast<ConstantInt>(Op0)) { 130753a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // C - ~X == X + (1+C) 130853a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner Value *X = 0; 130953a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (match(Op1, m_Not(m_Value(X)))) 131053a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner return BinaryOperator::CreateAdd(X, AddOne(C)); 131153a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 131253a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // -(X >>u 31) -> (X >>s 31) 131353a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // -(X >>s 31) -> (X >>u 31) 131453a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (C->isZero()) { 1315b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner Value *X; ConstantInt *CI; 1316b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner if (match(Op1, m_LShr(m_Value(X), m_ConstantInt(CI))) && 1317b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner // Verify we are shifting out everything but the sign bit. 1318b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner CI->getValue() == I.getType()->getPrimitiveSizeInBits()-1) 1319b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner return BinaryOperator::CreateAShr(X, CI); 1320b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner 1321b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner if (match(Op1, m_AShr(m_Value(X), m_ConstantInt(CI))) && 1322b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner // Verify we are shifting out everything but the sign bit. 1323b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner CI->getValue() == I.getType()->getPrimitiveSizeInBits()-1) 1324b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner return BinaryOperator::CreateLShr(X, CI); 132553a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 132653a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 132753a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // Try to fold constant sub into select arguments. 132853a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (SelectInst *SI = dyn_cast<SelectInst>(Op1)) 132953a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (Instruction *R = FoldOpIntoSelect(I, SI)) 133053a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner return R; 133153a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 1332b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner // C-(X+C2) --> (C-C2)-X 1333b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner ConstantInt *C2; 1334b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner if (match(Op1, m_Add(m_Value(X), m_ConstantInt(C2)))) 1335b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner return BinaryOperator::CreateSub(ConstantExpr::getSub(C, C2), X); 13361fdfae05b0a4356d1ed0633bf3d6cdc6eba2e173Benjamin Kramer 13371fdfae05b0a4356d1ed0633bf3d6cdc6eba2e173Benjamin Kramer if (SimplifyDemandedInstructionBits(I)) 13381fdfae05b0a4356d1ed0633bf3d6cdc6eba2e173Benjamin Kramer return &I; 13398e528100d210e225cee417229d94af91355118c0Paul Redmond 13408e528100d210e225cee417229d94af91355118c0Paul Redmond // Fold (sub 0, (zext bool to B)) --> (sext bool to B) 13418e528100d210e225cee417229d94af91355118c0Paul Redmond if (C->isZero() && match(Op1, m_ZExt(m_Value(X)))) 13428e528100d210e225cee417229d94af91355118c0Paul Redmond if (X->getType()->isIntegerTy(1)) 13438e528100d210e225cee417229d94af91355118c0Paul Redmond return CastInst::CreateSExtOrBitCast(X, Op1->getType()); 13448e528100d210e225cee417229d94af91355118c0Paul Redmond 13458e528100d210e225cee417229d94af91355118c0Paul Redmond // Fold (sub 0, (sext bool to B)) --> (zext bool to B) 13468e528100d210e225cee417229d94af91355118c0Paul Redmond if (C->isZero() && match(Op1, m_SExt(m_Value(X)))) 13478e528100d210e225cee417229d94af91355118c0Paul Redmond if (X->getType()->isIntegerTy(1)) 13488e528100d210e225cee417229d94af91355118c0Paul Redmond return CastInst::CreateZExtOrBitCast(X, Op1->getType()); 134953a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 135053a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 13514d96e6f0d105e60b423a118c3c8c7c5ffffae8b2Michael Ilseman 1352b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner { Value *Y; 1353b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner // X-(X+Y) == -Y X-(Y+X) == -Y 1354b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner if (match(Op1, m_Add(m_Specific(Op0), m_Value(Y))) || 1355b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner match(Op1, m_Add(m_Value(Y), m_Specific(Op0)))) 1356b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner return BinaryOperator::CreateNeg(Y); 13574d96e6f0d105e60b423a118c3c8c7c5ffffae8b2Michael Ilseman 1358b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner // (X-Y)-X == -Y 1359b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner if (match(Op0, m_Sub(m_Specific(Op1), m_Value(Y)))) 1360b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner return BinaryOperator::CreateNeg(Y); 1361b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner } 13624d96e6f0d105e60b423a118c3c8c7c5ffffae8b2Michael Ilseman 1363b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner if (Op1->hasOneUse()) { 1364b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner Value *X = 0, *Y = 0, *Z = 0; 1365b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner Constant *C = 0; 1366b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner ConstantInt *CI = 0; 1367b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner 1368b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner // (X - (Y - Z)) --> (X + (Z - Y)). 1369b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner if (match(Op1, m_Sub(m_Value(Y), m_Value(Z)))) 1370b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner return BinaryOperator::CreateAdd(Op0, 1371b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner Builder->CreateSub(Z, Y, Op1->getName())); 1372b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner 1373b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner // (X - (X & Y)) --> (X & ~Y) 1374b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner // 1375b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner if (match(Op1, m_And(m_Value(Y), m_Specific(Op0))) || 1376b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner match(Op1, m_And(m_Specific(Op0), m_Value(Y)))) 1377b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner return BinaryOperator::CreateAnd(Op0, 1378b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner Builder->CreateNot(Y, Y->getName() + ".not")); 13794d96e6f0d105e60b423a118c3c8c7c5ffffae8b2Michael Ilseman 1380b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner // 0 - (X sdiv C) -> (X sdiv -C) 1381b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner if (match(Op1, m_SDiv(m_Value(X), m_Constant(C))) && 1382b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner match(Op0, m_Zero())) 1383b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner return BinaryOperator::CreateSDiv(X, ConstantExpr::getNeg(C)); 1384b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner 1385b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner // 0 - (X << Y) -> (-X << Y) when X is freely negatable. 1386b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner if (match(Op1, m_Shl(m_Value(X), m_Value(Y))) && match(Op0, m_Zero())) 1387b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner if (Value *XNeg = dyn_castNegVal(X)) 1388b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner return BinaryOperator::CreateShl(XNeg, Y); 1389b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner 1390b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner // X - X*C --> X * (1-C) 1391b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner if (match(Op1, m_Mul(m_Specific(Op0), m_ConstantInt(CI)))) { 1392b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner Constant *CP1 = ConstantExpr::getSub(ConstantInt::get(I.getType(),1), CI); 1393b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner return BinaryOperator::CreateMul(Op0, CP1); 139453a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 139553a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 1396b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner // X - X<<C --> X * (1-(1<<C)) 1397b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner if (match(Op1, m_Shl(m_Specific(Op0), m_ConstantInt(CI)))) { 1398b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner Constant *One = ConstantInt::get(I.getType(), 1); 1399b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner C = ConstantExpr::getSub(One, ConstantExpr::getShl(One, CI)); 1400b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner return BinaryOperator::CreateMul(Op0, C); 140153a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 14024d96e6f0d105e60b423a118c3c8c7c5ffffae8b2Michael Ilseman 1403b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner // X - A*-B -> X + A*B 1404b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner // X - -A*B -> X + A*B 1405b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner Value *A, *B; 1406b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner if (match(Op1, m_Mul(m_Value(A), m_Neg(m_Value(B)))) || 1407b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner match(Op1, m_Mul(m_Neg(m_Value(A)), m_Value(B)))) 1408b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner return BinaryOperator::CreateAdd(Op0, Builder->CreateMul(A, B)); 14094d96e6f0d105e60b423a118c3c8c7c5ffffae8b2Michael Ilseman 1410b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner // X - A*CI -> X + A*-CI 1411b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner // X - CI*A -> X + A*-CI 1412b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner if (match(Op1, m_Mul(m_Value(A), m_ConstantInt(CI))) || 1413b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner match(Op1, m_Mul(m_ConstantInt(CI), m_Value(A)))) { 1414b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner Value *NewMul = Builder->CreateMul(A, ConstantExpr::getNeg(CI)); 1415b9b9044600a472d5f8750f43fd884e32e2afe4ccChris Lattner return BinaryOperator::CreateAdd(Op0, NewMul); 141653a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 141753a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 141853a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 141953a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner ConstantInt *C1; 142053a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (Value *X = dyn_castFoldableMul(Op0, C1)) { 142153a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (X == Op1) // X*C - X --> X * (C-1) 142253a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner return BinaryOperator::CreateMul(Op1, SubOne(C1)); 142353a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 142453a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner ConstantInt *C2; // X*C1 - X*C2 -> X * (C1-C2) 142553a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (X == dyn_castFoldableMul(Op1, C2)) 142653a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner return BinaryOperator::CreateMul(X, ConstantExpr::getSub(C1, C2)); 142753a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 14284d96e6f0d105e60b423a118c3c8c7c5ffffae8b2Michael Ilseman 142953a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // Optimize pointer differences into the same array into a size. Consider: 143053a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // &A[10] - &A[0]: we should compile this to "10". 143153a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (TD) { 143253a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner Value *LHSOp, *RHSOp; 143353a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (match(Op0, m_PtrToInt(m_Value(LHSOp))) && 143453a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner match(Op1, m_PtrToInt(m_Value(RHSOp)))) 143553a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (Value *Res = OptimizePointerDifference(LHSOp, RHSOp, I.getType())) 143653a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner return ReplaceInstUsesWith(I, Res); 14374d96e6f0d105e60b423a118c3c8c7c5ffffae8b2Michael Ilseman 143853a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // trunc(p)-trunc(q) -> trunc(p-q) 143953a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (match(Op0, m_Trunc(m_PtrToInt(m_Value(LHSOp)))) && 144053a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner match(Op1, m_Trunc(m_PtrToInt(m_Value(RHSOp))))) 144153a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (Value *Res = OptimizePointerDifference(LHSOp, RHSOp, I.getType())) 144253a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner return ReplaceInstUsesWith(I, Res); 144353a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner } 14444d96e6f0d105e60b423a118c3c8c7c5ffffae8b2Michael Ilseman 144553a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner return 0; 144653a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner} 144753a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 144853a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris LattnerInstruction *InstCombiner::visitFSub(BinaryOperator &I) { 144953a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1); 145053a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 1451c244f381768e2e6ab9daa807adbee18de4756a07Michael Ilseman if (Value *V = SimplifyFSubInst(Op0, Op1, I.getFastMathFlags(), TD)) 1452c244f381768e2e6ab9daa807adbee18de4756a07Michael Ilseman return ReplaceInstUsesWith(I, V); 1453c244f381768e2e6ab9daa807adbee18de4756a07Michael Ilseman 145453a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner // If this is a 'B = x-(-A)', change to B = x+A... 145553a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner if (Value *V = dyn_castFNegVal(Op1)) 145653a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner return BinaryOperator::CreateFAdd(Op0, V); 145753a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner 14581a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (I.hasUnsafeAlgebra()) { 14591a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang if (Value *V = FAddCombine(Builder).simplify(&I)) 14601a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang return ReplaceInstUsesWith(I, V); 14611a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang } 14621a3150098c137181576dc3e0960f8cd4abe9da1fShuxin Yang 146353a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner return 0; 146453a19b73b5d18794c314bf93f4f3f03e5a8af1f2Chris Lattner} 1465