]>
Commit | Line | Data |
---|---|---|
223e47cc LB |
1 | //===- Reassociate.cpp - Reassociate binary expressions -------------------===// |
2 | // | |
3 | // The LLVM Compiler Infrastructure | |
4 | // | |
5 | // This file is distributed under the University of Illinois Open Source | |
6 | // License. See LICENSE.TXT for details. | |
7 | // | |
8 | //===----------------------------------------------------------------------===// | |
9 | // | |
10 | // This pass reassociates commutative expressions in an order that is designed | |
11 | // to promote better constant propagation, GCSE, LICM, PRE, etc. | |
12 | // | |
13 | // For example: 4 + (x + 5) -> x + (4 + 5) | |
14 | // | |
15 | // In the implementation of this algorithm, constants are assigned rank = 0, | |
16 | // function arguments are rank = 1, and other values are assigned ranks | |
17 | // corresponding to the reverse post order traversal of current function | |
18 | // (starting at 2), which effectively gives values in deep loops higher rank | |
19 | // than values not in loops. | |
20 | // | |
21 | //===----------------------------------------------------------------------===// | |
22 | ||
223e47cc | 23 | #include "llvm/Transforms/Scalar.h" |
223e47cc LB |
24 | #include "llvm/ADT/DenseMap.h" |
25 | #include "llvm/ADT/PostOrderIterator.h" | |
26 | #include "llvm/ADT/STLExtras.h" | |
27 | #include "llvm/ADT/SetVector.h" | |
28 | #include "llvm/ADT/Statistic.h" | |
1a4d82fc | 29 | #include "llvm/IR/CFG.h" |
970d7e83 LB |
30 | #include "llvm/IR/Constants.h" |
31 | #include "llvm/IR/DerivedTypes.h" | |
32 | #include "llvm/IR/Function.h" | |
33 | #include "llvm/IR/IRBuilder.h" | |
34 | #include "llvm/IR/Instructions.h" | |
35 | #include "llvm/IR/IntrinsicInst.h" | |
1a4d82fc | 36 | #include "llvm/IR/ValueHandle.h" |
970d7e83 | 37 | #include "llvm/Pass.h" |
223e47cc | 38 | #include "llvm/Support/Debug.h" |
223e47cc | 39 | #include "llvm/Support/raw_ostream.h" |
970d7e83 | 40 | #include "llvm/Transforms/Utils/Local.h" |
223e47cc LB |
41 | #include <algorithm> |
42 | using namespace llvm; | |
43 | ||
1a4d82fc JJ |
44 | #define DEBUG_TYPE "reassociate" |
45 | ||
223e47cc LB |
46 | STATISTIC(NumChanged, "Number of insts reassociated"); |
47 | STATISTIC(NumAnnihil, "Number of expr tree annihilated"); | |
48 | STATISTIC(NumFactor , "Number of multiplies factored"); | |
49 | ||
50 | namespace { | |
51 | struct ValueEntry { | |
52 | unsigned Rank; | |
53 | Value *Op; | |
54 | ValueEntry(unsigned R, Value *O) : Rank(R), Op(O) {} | |
55 | }; | |
56 | inline bool operator<(const ValueEntry &LHS, const ValueEntry &RHS) { | |
57 | return LHS.Rank > RHS.Rank; // Sort so that highest rank goes to start. | |
58 | } | |
59 | } | |
60 | ||
61 | #ifndef NDEBUG | |
62 | /// PrintOps - Print out the expression identified in the Ops list. | |
63 | /// | |
64 | static void PrintOps(Instruction *I, const SmallVectorImpl<ValueEntry> &Ops) { | |
65 | Module *M = I->getParent()->getParent()->getParent(); | |
66 | dbgs() << Instruction::getOpcodeName(I->getOpcode()) << " " | |
67 | << *Ops[0].Op->getType() << '\t'; | |
68 | for (unsigned i = 0, e = Ops.size(); i != e; ++i) { | |
69 | dbgs() << "[ "; | |
1a4d82fc | 70 | Ops[i].Op->printAsOperand(dbgs(), false, M); |
223e47cc LB |
71 | dbgs() << ", #" << Ops[i].Rank << "] "; |
72 | } | |
73 | } | |
74 | #endif | |
75 | ||
76 | namespace { | |
77 | /// \brief Utility class representing a base and exponent pair which form one | |
78 | /// factor of some product. | |
79 | struct Factor { | |
80 | Value *Base; | |
81 | unsigned Power; | |
82 | ||
83 | Factor(Value *Base, unsigned Power) : Base(Base), Power(Power) {} | |
84 | ||
85 | /// \brief Sort factors by their Base. | |
86 | struct BaseSorter { | |
87 | bool operator()(const Factor &LHS, const Factor &RHS) { | |
88 | return LHS.Base < RHS.Base; | |
89 | } | |
90 | }; | |
91 | ||
92 | /// \brief Compare factors for equal bases. | |
93 | struct BaseEqual { | |
94 | bool operator()(const Factor &LHS, const Factor &RHS) { | |
95 | return LHS.Base == RHS.Base; | |
96 | } | |
97 | }; | |
98 | ||
99 | /// \brief Sort factors in descending order by their power. | |
100 | struct PowerDescendingSorter { | |
101 | bool operator()(const Factor &LHS, const Factor &RHS) { | |
102 | return LHS.Power > RHS.Power; | |
103 | } | |
104 | }; | |
105 | ||
106 | /// \brief Compare factors for equal powers. | |
107 | struct PowerEqual { | |
108 | bool operator()(const Factor &LHS, const Factor &RHS) { | |
109 | return LHS.Power == RHS.Power; | |
110 | } | |
111 | }; | |
112 | }; | |
1a4d82fc JJ |
113 | |
114 | /// Utility class representing a non-constant Xor-operand. We classify | |
115 | /// non-constant Xor-Operands into two categories: | |
116 | /// C1) The operand is in the form "X & C", where C is a constant and C != ~0 | |
117 | /// C2) | |
118 | /// C2.1) The operand is in the form of "X | C", where C is a non-zero | |
119 | /// constant. | |
120 | /// C2.2) Any operand E which doesn't fall into C1 and C2.1, we view this | |
121 | /// operand as "E | 0" | |
122 | class XorOpnd { | |
123 | public: | |
124 | XorOpnd(Value *V); | |
125 | ||
126 | bool isInvalid() const { return SymbolicPart == nullptr; } | |
127 | bool isOrExpr() const { return isOr; } | |
128 | Value *getValue() const { return OrigVal; } | |
129 | Value *getSymbolicPart() const { return SymbolicPart; } | |
130 | unsigned getSymbolicRank() const { return SymbolicRank; } | |
131 | const APInt &getConstPart() const { return ConstPart; } | |
132 | ||
133 | void Invalidate() { SymbolicPart = OrigVal = nullptr; } | |
134 | void setSymbolicRank(unsigned R) { SymbolicRank = R; } | |
135 | ||
136 | // Sort the XorOpnd-Pointer in ascending order of symbolic-value-rank. | |
137 | // The purpose is twofold: | |
138 | // 1) Cluster together the operands sharing the same symbolic-value. | |
139 | // 2) Operand having smaller symbolic-value-rank is permuted earlier, which | |
140 | // could potentially shorten crital path, and expose more loop-invariants. | |
141 | // Note that values' rank are basically defined in RPO order (FIXME). | |
142 | // So, if Rank(X) < Rank(Y) < Rank(Z), it means X is defined earlier | |
143 | // than Y which is defined earlier than Z. Permute "x | 1", "Y & 2", | |
144 | // "z" in the order of X-Y-Z is better than any other orders. | |
145 | struct PtrSortFunctor { | |
146 | bool operator()(XorOpnd * const &LHS, XorOpnd * const &RHS) { | |
147 | return LHS->getSymbolicRank() < RHS->getSymbolicRank(); | |
148 | } | |
149 | }; | |
150 | private: | |
151 | Value *OrigVal; | |
152 | Value *SymbolicPart; | |
153 | APInt ConstPart; | |
154 | unsigned SymbolicRank; | |
155 | bool isOr; | |
156 | }; | |
223e47cc LB |
157 | } |
158 | ||
159 | namespace { | |
160 | class Reassociate : public FunctionPass { | |
161 | DenseMap<BasicBlock*, unsigned> RankMap; | |
162 | DenseMap<AssertingVH<Value>, unsigned> ValueRankMap; | |
163 | SetVector<AssertingVH<Instruction> > RedoInsts; | |
164 | bool MadeChange; | |
165 | public: | |
166 | static char ID; // Pass identification, replacement for typeid | |
167 | Reassociate() : FunctionPass(ID) { | |
168 | initializeReassociatePass(*PassRegistry::getPassRegistry()); | |
169 | } | |
170 | ||
1a4d82fc | 171 | bool runOnFunction(Function &F) override; |
223e47cc | 172 | |
1a4d82fc | 173 | void getAnalysisUsage(AnalysisUsage &AU) const override { |
223e47cc LB |
174 | AU.setPreservesCFG(); |
175 | } | |
176 | private: | |
177 | void BuildRankMap(Function &F); | |
178 | unsigned getRank(Value *V); | |
85aaf69f | 179 | void canonicalizeOperands(Instruction *I); |
223e47cc LB |
180 | void ReassociateExpression(BinaryOperator *I); |
181 | void RewriteExprTree(BinaryOperator *I, SmallVectorImpl<ValueEntry> &Ops); | |
182 | Value *OptimizeExpression(BinaryOperator *I, | |
183 | SmallVectorImpl<ValueEntry> &Ops); | |
184 | Value *OptimizeAdd(Instruction *I, SmallVectorImpl<ValueEntry> &Ops); | |
1a4d82fc JJ |
185 | Value *OptimizeXor(Instruction *I, SmallVectorImpl<ValueEntry> &Ops); |
186 | bool CombineXorOpnd(Instruction *I, XorOpnd *Opnd1, APInt &ConstOpnd, | |
187 | Value *&Res); | |
188 | bool CombineXorOpnd(Instruction *I, XorOpnd *Opnd1, XorOpnd *Opnd2, | |
189 | APInt &ConstOpnd, Value *&Res); | |
223e47cc LB |
190 | bool collectMultiplyFactors(SmallVectorImpl<ValueEntry> &Ops, |
191 | SmallVectorImpl<Factor> &Factors); | |
192 | Value *buildMinimalMultiplyDAG(IRBuilder<> &Builder, | |
193 | SmallVectorImpl<Factor> &Factors); | |
194 | Value *OptimizeMul(BinaryOperator *I, SmallVectorImpl<ValueEntry> &Ops); | |
195 | Value *RemoveFactorFromExpression(Value *V, Value *Factor); | |
196 | void EraseInst(Instruction *I); | |
197 | void OptimizeInst(Instruction *I); | |
85aaf69f | 198 | Instruction *canonicalizeNegConstExpr(Instruction *I); |
223e47cc LB |
199 | }; |
200 | } | |
201 | ||
1a4d82fc JJ |
202 | XorOpnd::XorOpnd(Value *V) { |
203 | assert(!isa<ConstantInt>(V) && "No ConstantInt"); | |
204 | OrigVal = V; | |
205 | Instruction *I = dyn_cast<Instruction>(V); | |
206 | SymbolicRank = 0; | |
207 | ||
208 | if (I && (I->getOpcode() == Instruction::Or || | |
209 | I->getOpcode() == Instruction::And)) { | |
210 | Value *V0 = I->getOperand(0); | |
211 | Value *V1 = I->getOperand(1); | |
212 | if (isa<ConstantInt>(V0)) | |
213 | std::swap(V0, V1); | |
214 | ||
215 | if (ConstantInt *C = dyn_cast<ConstantInt>(V1)) { | |
216 | ConstPart = C->getValue(); | |
217 | SymbolicPart = V0; | |
218 | isOr = (I->getOpcode() == Instruction::Or); | |
219 | return; | |
220 | } | |
221 | } | |
222 | ||
223 | // view the operand as "V | 0" | |
224 | SymbolicPart = V; | |
225 | ConstPart = APInt::getNullValue(V->getType()->getIntegerBitWidth()); | |
226 | isOr = true; | |
227 | } | |
228 | ||
223e47cc LB |
229 | char Reassociate::ID = 0; |
230 | INITIALIZE_PASS(Reassociate, "reassociate", | |
231 | "Reassociate expressions", false, false) | |
232 | ||
233 | // Public interface to the Reassociate pass | |
234 | FunctionPass *llvm::createReassociatePass() { return new Reassociate(); } | |
235 | ||
236 | /// isReassociableOp - Return true if V is an instruction of the specified | |
237 | /// opcode and if it only has one use. | |
238 | static BinaryOperator *isReassociableOp(Value *V, unsigned Opcode) { | |
239 | if (V->hasOneUse() && isa<Instruction>(V) && | |
85aaf69f SL |
240 | cast<Instruction>(V)->getOpcode() == Opcode && |
241 | (!isa<FPMathOperator>(V) || | |
242 | cast<Instruction>(V)->hasUnsafeAlgebra())) | |
223e47cc | 243 | return cast<BinaryOperator>(V); |
1a4d82fc JJ |
244 | return nullptr; |
245 | } | |
246 | ||
247 | static BinaryOperator *isReassociableOp(Value *V, unsigned Opcode1, | |
248 | unsigned Opcode2) { | |
249 | if (V->hasOneUse() && isa<Instruction>(V) && | |
250 | (cast<Instruction>(V)->getOpcode() == Opcode1 || | |
85aaf69f SL |
251 | cast<Instruction>(V)->getOpcode() == Opcode2) && |
252 | (!isa<FPMathOperator>(V) || | |
253 | cast<Instruction>(V)->hasUnsafeAlgebra())) | |
1a4d82fc JJ |
254 | return cast<BinaryOperator>(V); |
255 | return nullptr; | |
223e47cc LB |
256 | } |
257 | ||
258 | static bool isUnmovableInstruction(Instruction *I) { | |
1a4d82fc JJ |
259 | switch (I->getOpcode()) { |
260 | case Instruction::PHI: | |
261 | case Instruction::LandingPad: | |
262 | case Instruction::Alloca: | |
263 | case Instruction::Load: | |
264 | case Instruction::Invoke: | |
265 | case Instruction::UDiv: | |
266 | case Instruction::SDiv: | |
267 | case Instruction::FDiv: | |
268 | case Instruction::URem: | |
269 | case Instruction::SRem: | |
270 | case Instruction::FRem: | |
223e47cc | 271 | return true; |
1a4d82fc JJ |
272 | case Instruction::Call: |
273 | return !isa<DbgInfoIntrinsic>(I); | |
274 | default: | |
275 | return false; | |
276 | } | |
223e47cc LB |
277 | } |
278 | ||
279 | void Reassociate::BuildRankMap(Function &F) { | |
280 | unsigned i = 2; | |
281 | ||
85aaf69f SL |
282 | // Assign distinct ranks to function arguments. |
283 | for (Function::arg_iterator I = F.arg_begin(), E = F.arg_end(); I != E; ++I) { | |
223e47cc | 284 | ValueRankMap[&*I] = ++i; |
85aaf69f SL |
285 | DEBUG(dbgs() << "Calculated Rank[" << I->getName() << "] = " << i << "\n"); |
286 | } | |
223e47cc LB |
287 | |
288 | ReversePostOrderTraversal<Function*> RPOT(&F); | |
289 | for (ReversePostOrderTraversal<Function*>::rpo_iterator I = RPOT.begin(), | |
290 | E = RPOT.end(); I != E; ++I) { | |
291 | BasicBlock *BB = *I; | |
292 | unsigned BBRank = RankMap[BB] = ++i << 16; | |
293 | ||
294 | // Walk the basic block, adding precomputed ranks for any instructions that | |
295 | // we cannot move. This ensures that the ranks for these instructions are | |
296 | // all different in the block. | |
297 | for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) | |
298 | if (isUnmovableInstruction(I)) | |
299 | ValueRankMap[&*I] = ++BBRank; | |
300 | } | |
301 | } | |
302 | ||
303 | unsigned Reassociate::getRank(Value *V) { | |
304 | Instruction *I = dyn_cast<Instruction>(V); | |
1a4d82fc | 305 | if (!I) { |
223e47cc LB |
306 | if (isa<Argument>(V)) return ValueRankMap[V]; // Function argument. |
307 | return 0; // Otherwise it's a global or constant, rank 0. | |
308 | } | |
309 | ||
310 | if (unsigned Rank = ValueRankMap[I]) | |
311 | return Rank; // Rank already known? | |
312 | ||
313 | // If this is an expression, return the 1+MAX(rank(LHS), rank(RHS)) so that | |
314 | // we can reassociate expressions for code motion! Since we do not recurse | |
315 | // for PHI nodes, we cannot have infinite recursion here, because there | |
316 | // cannot be loops in the value graph that do not go through PHI nodes. | |
317 | unsigned Rank = 0, MaxRank = RankMap[I->getParent()]; | |
318 | for (unsigned i = 0, e = I->getNumOperands(); | |
319 | i != e && Rank != MaxRank; ++i) | |
320 | Rank = std::max(Rank, getRank(I->getOperand(i))); | |
321 | ||
322 | // If this is a not or neg instruction, do not count it for rank. This | |
323 | // assures us that X and ~X will have the same rank. | |
1a4d82fc JJ |
324 | Type *Ty = V->getType(); |
325 | if ((!Ty->isIntegerTy() && !Ty->isFloatingPointTy()) || | |
326 | (!BinaryOperator::isNot(I) && !BinaryOperator::isNeg(I) && | |
327 | !BinaryOperator::isFNeg(I))) | |
223e47cc LB |
328 | ++Rank; |
329 | ||
85aaf69f | 330 | DEBUG(dbgs() << "Calculated Rank[" << V->getName() << "] = " << Rank << "\n"); |
223e47cc LB |
331 | |
332 | return ValueRankMap[I] = Rank; | |
333 | } | |
334 | ||
85aaf69f SL |
335 | // Canonicalize constants to RHS. Otherwise, sort the operands by rank. |
336 | void Reassociate::canonicalizeOperands(Instruction *I) { | |
337 | assert(isa<BinaryOperator>(I) && "Expected binary operator."); | |
338 | assert(I->isCommutative() && "Expected commutative operator."); | |
339 | ||
340 | Value *LHS = I->getOperand(0); | |
341 | Value *RHS = I->getOperand(1); | |
342 | unsigned LHSRank = getRank(LHS); | |
343 | unsigned RHSRank = getRank(RHS); | |
344 | ||
345 | if (isa<Constant>(RHS)) | |
346 | return; | |
347 | ||
348 | if (isa<Constant>(LHS) || RHSRank < LHSRank) | |
349 | cast<BinaryOperator>(I)->swapOperands(); | |
350 | } | |
351 | ||
1a4d82fc JJ |
352 | static BinaryOperator *CreateAdd(Value *S1, Value *S2, const Twine &Name, |
353 | Instruction *InsertBefore, Value *FlagsOp) { | |
354 | if (S1->getType()->isIntegerTy()) | |
355 | return BinaryOperator::CreateAdd(S1, S2, Name, InsertBefore); | |
356 | else { | |
357 | BinaryOperator *Res = | |
358 | BinaryOperator::CreateFAdd(S1, S2, Name, InsertBefore); | |
359 | Res->setFastMathFlags(cast<FPMathOperator>(FlagsOp)->getFastMathFlags()); | |
360 | return Res; | |
361 | } | |
362 | } | |
363 | ||
364 | static BinaryOperator *CreateMul(Value *S1, Value *S2, const Twine &Name, | |
365 | Instruction *InsertBefore, Value *FlagsOp) { | |
366 | if (S1->getType()->isIntegerTy()) | |
367 | return BinaryOperator::CreateMul(S1, S2, Name, InsertBefore); | |
368 | else { | |
369 | BinaryOperator *Res = | |
370 | BinaryOperator::CreateFMul(S1, S2, Name, InsertBefore); | |
371 | Res->setFastMathFlags(cast<FPMathOperator>(FlagsOp)->getFastMathFlags()); | |
372 | return Res; | |
373 | } | |
374 | } | |
375 | ||
376 | static BinaryOperator *CreateNeg(Value *S1, const Twine &Name, | |
377 | Instruction *InsertBefore, Value *FlagsOp) { | |
378 | if (S1->getType()->isIntegerTy()) | |
379 | return BinaryOperator::CreateNeg(S1, Name, InsertBefore); | |
380 | else { | |
381 | BinaryOperator *Res = BinaryOperator::CreateFNeg(S1, Name, InsertBefore); | |
382 | Res->setFastMathFlags(cast<FPMathOperator>(FlagsOp)->getFastMathFlags()); | |
383 | return Res; | |
384 | } | |
385 | } | |
386 | ||
223e47cc LB |
387 | /// LowerNegateToMultiply - Replace 0-X with X*-1. |
388 | /// | |
389 | static BinaryOperator *LowerNegateToMultiply(Instruction *Neg) { | |
1a4d82fc JJ |
390 | Type *Ty = Neg->getType(); |
391 | Constant *NegOne = Ty->isIntegerTy() ? ConstantInt::getAllOnesValue(Ty) | |
392 | : ConstantFP::get(Ty, -1.0); | |
223e47cc | 393 | |
1a4d82fc JJ |
394 | BinaryOperator *Res = CreateMul(Neg->getOperand(1), NegOne, "", Neg, Neg); |
395 | Neg->setOperand(1, Constant::getNullValue(Ty)); // Drop use of op. | |
223e47cc LB |
396 | Res->takeName(Neg); |
397 | Neg->replaceAllUsesWith(Res); | |
398 | Res->setDebugLoc(Neg->getDebugLoc()); | |
399 | return Res; | |
400 | } | |
401 | ||
402 | /// CarmichaelShift - Returns k such that lambda(2^Bitwidth) = 2^k, where lambda | |
403 | /// is the Carmichael function. This means that x^(2^k) === 1 mod 2^Bitwidth for | |
404 | /// every odd x, i.e. x^(2^k) = 1 for every odd x in Bitwidth-bit arithmetic. | |
405 | /// Note that 0 <= k < Bitwidth, and if Bitwidth > 3 then x^(2^k) = 0 for every | |
406 | /// even x in Bitwidth-bit arithmetic. | |
407 | static unsigned CarmichaelShift(unsigned Bitwidth) { | |
408 | if (Bitwidth < 3) | |
409 | return Bitwidth - 1; | |
410 | return Bitwidth - 2; | |
411 | } | |
412 | ||
413 | /// IncorporateWeight - Add the extra weight 'RHS' to the existing weight 'LHS', | |
414 | /// reducing the combined weight using any special properties of the operation. | |
415 | /// The existing weight LHS represents the computation X op X op ... op X where | |
416 | /// X occurs LHS times. The combined weight represents X op X op ... op X with | |
417 | /// X occurring LHS + RHS times. If op is "Xor" for example then the combined | |
418 | /// operation is equivalent to X if LHS + RHS is odd, or 0 if LHS + RHS is even; | |
419 | /// the routine returns 1 in LHS in the first case, and 0 in LHS in the second. | |
420 | static void IncorporateWeight(APInt &LHS, const APInt &RHS, unsigned Opcode) { | |
421 | // If we were working with infinite precision arithmetic then the combined | |
422 | // weight would be LHS + RHS. But we are using finite precision arithmetic, | |
423 | // and the APInt sum LHS + RHS may not be correct if it wraps (it is correct | |
424 | // for nilpotent operations and addition, but not for idempotent operations | |
425 | // and multiplication), so it is important to correctly reduce the combined | |
426 | // weight back into range if wrapping would be wrong. | |
427 | ||
428 | // If RHS is zero then the weight didn't change. | |
429 | if (RHS.isMinValue()) | |
430 | return; | |
431 | // If LHS is zero then the combined weight is RHS. | |
432 | if (LHS.isMinValue()) { | |
433 | LHS = RHS; | |
434 | return; | |
435 | } | |
436 | // From this point on we know that neither LHS nor RHS is zero. | |
437 | ||
438 | if (Instruction::isIdempotent(Opcode)) { | |
439 | // Idempotent means X op X === X, so any non-zero weight is equivalent to a | |
440 | // weight of 1. Keeping weights at zero or one also means that wrapping is | |
441 | // not a problem. | |
442 | assert(LHS == 1 && RHS == 1 && "Weights not reduced!"); | |
443 | return; // Return a weight of 1. | |
444 | } | |
445 | if (Instruction::isNilpotent(Opcode)) { | |
446 | // Nilpotent means X op X === 0, so reduce weights modulo 2. | |
447 | assert(LHS == 1 && RHS == 1 && "Weights not reduced!"); | |
448 | LHS = 0; // 1 + 1 === 0 modulo 2. | |
449 | return; | |
450 | } | |
1a4d82fc | 451 | if (Opcode == Instruction::Add || Opcode == Instruction::FAdd) { |
223e47cc LB |
452 | // TODO: Reduce the weight by exploiting nsw/nuw? |
453 | LHS += RHS; | |
454 | return; | |
455 | } | |
456 | ||
1a4d82fc JJ |
457 | assert((Opcode == Instruction::Mul || Opcode == Instruction::FMul) && |
458 | "Unknown associative operation!"); | |
223e47cc LB |
459 | unsigned Bitwidth = LHS.getBitWidth(); |
460 | // If CM is the Carmichael number then a weight W satisfying W >= CM+Bitwidth | |
461 | // can be replaced with W-CM. That's because x^W=x^(W-CM) for every Bitwidth | |
462 | // bit number x, since either x is odd in which case x^CM = 1, or x is even in | |
463 | // which case both x^W and x^(W - CM) are zero. By subtracting off multiples | |
464 | // of CM like this weights can always be reduced to the range [0, CM+Bitwidth) | |
465 | // which by a happy accident means that they can always be represented using | |
466 | // Bitwidth bits. | |
467 | // TODO: Reduce the weight by exploiting nsw/nuw? (Could do much better than | |
468 | // the Carmichael number). | |
469 | if (Bitwidth > 3) { | |
470 | /// CM - The value of Carmichael's lambda function. | |
471 | APInt CM = APInt::getOneBitSet(Bitwidth, CarmichaelShift(Bitwidth)); | |
472 | // Any weight W >= Threshold can be replaced with W - CM. | |
473 | APInt Threshold = CM + Bitwidth; | |
474 | assert(LHS.ult(Threshold) && RHS.ult(Threshold) && "Weights not reduced!"); | |
475 | // For Bitwidth 4 or more the following sum does not overflow. | |
476 | LHS += RHS; | |
477 | while (LHS.uge(Threshold)) | |
478 | LHS -= CM; | |
479 | } else { | |
480 | // To avoid problems with overflow do everything the same as above but using | |
481 | // a larger type. | |
482 | unsigned CM = 1U << CarmichaelShift(Bitwidth); | |
483 | unsigned Threshold = CM + Bitwidth; | |
484 | assert(LHS.getZExtValue() < Threshold && RHS.getZExtValue() < Threshold && | |
485 | "Weights not reduced!"); | |
486 | unsigned Total = LHS.getZExtValue() + RHS.getZExtValue(); | |
487 | while (Total >= Threshold) | |
488 | Total -= CM; | |
489 | LHS = Total; | |
490 | } | |
491 | } | |
492 | ||
223e47cc LB |
493 | typedef std::pair<Value*, APInt> RepeatedValue; |
494 | ||
495 | /// LinearizeExprTree - Given an associative binary expression, return the leaf | |
496 | /// nodes in Ops along with their weights (how many times the leaf occurs). The | |
497 | /// original expression is the same as | |
498 | /// (Ops[0].first op Ops[0].first op ... Ops[0].first) <- Ops[0].second times | |
499 | /// op | |
500 | /// (Ops[1].first op Ops[1].first op ... Ops[1].first) <- Ops[1].second times | |
501 | /// op | |
502 | /// ... | |
503 | /// op | |
504 | /// (Ops[N].first op Ops[N].first op ... Ops[N].first) <- Ops[N].second times | |
505 | /// | |
970d7e83 | 506 | /// Note that the values Ops[0].first, ..., Ops[N].first are all distinct. |
223e47cc LB |
507 | /// |
508 | /// This routine may modify the function, in which case it returns 'true'. The | |
509 | /// changes it makes may well be destructive, changing the value computed by 'I' | |
510 | /// to something completely different. Thus if the routine returns 'true' then | |
511 | /// you MUST either replace I with a new expression computed from the Ops array, | |
512 | /// or use RewriteExprTree to put the values back in. | |
513 | /// | |
514 | /// A leaf node is either not a binary operation of the same kind as the root | |
515 | /// node 'I' (i.e. is not a binary operator at all, or is, but with a different | |
516 | /// opcode), or is the same kind of binary operator but has a use which either | |
517 | /// does not belong to the expression, or does belong to the expression but is | |
518 | /// a leaf node. Every leaf node has at least one use that is a non-leaf node | |
519 | /// of the expression, while for non-leaf nodes (except for the root 'I') every | |
520 | /// use is a non-leaf node of the expression. | |
521 | /// | |
522 | /// For example: | |
523 | /// expression graph node names | |
524 | /// | |
525 | /// + | I | |
526 | /// / \ | | |
527 | /// + + | A, B | |
528 | /// / \ / \ | | |
529 | /// * + * | C, D, E | |
530 | /// / \ / \ / \ | | |
531 | /// + * | F, G | |
532 | /// | |
533 | /// The leaf nodes are C, E, F and G. The Ops array will contain (maybe not in | |
534 | /// that order) (C, 1), (E, 1), (F, 2), (G, 2). | |
535 | /// | |
536 | /// The expression is maximal: if some instruction is a binary operator of the | |
537 | /// same kind as 'I', and all of its uses are non-leaf nodes of the expression, | |
538 | /// then the instruction also belongs to the expression, is not a leaf node of | |
539 | /// it, and its operands also belong to the expression (but may be leaf nodes). | |
540 | /// | |
541 | /// NOTE: This routine will set operands of non-leaf non-root nodes to undef in | |
542 | /// order to ensure that every non-root node in the expression has *exactly one* | |
543 | /// use by a non-leaf node of the expression. This destruction means that the | |
544 | /// caller MUST either replace 'I' with a new expression or use something like | |
545 | /// RewriteExprTree to put the values back in if the routine indicates that it | |
546 | /// made a change by returning 'true'. | |
547 | /// | |
548 | /// In the above example either the right operand of A or the left operand of B | |
549 | /// will be replaced by undef. If it is B's operand then this gives: | |
550 | /// | |
551 | /// + | I | |
552 | /// / \ | | |
553 | /// + + | A, B - operand of B replaced with undef | |
554 | /// / \ \ | | |
555 | /// * + * | C, D, E | |
556 | /// / \ / \ / \ | | |
557 | /// + * | F, G | |
558 | /// | |
559 | /// Note that such undef operands can only be reached by passing through 'I'. | |
560 | /// For example, if you visit operands recursively starting from a leaf node | |
561 | /// then you will never see such an undef operand unless you get back to 'I', | |
562 | /// which requires passing through a phi node. | |
563 | /// | |
564 | /// Note that this routine may also mutate binary operators of the wrong type | |
565 | /// that have all uses inside the expression (i.e. only used by non-leaf nodes | |
566 | /// of the expression) if it can turn them into binary operators of the right | |
567 | /// type and thus make the expression bigger. | |
568 | ||
569 | static bool LinearizeExprTree(BinaryOperator *I, | |
570 | SmallVectorImpl<RepeatedValue> &Ops) { | |
571 | DEBUG(dbgs() << "LINEARIZE: " << *I << '\n'); | |
572 | unsigned Bitwidth = I->getType()->getScalarType()->getPrimitiveSizeInBits(); | |
573 | unsigned Opcode = I->getOpcode(); | |
1a4d82fc | 574 | assert(I->isAssociative() && I->isCommutative() && |
223e47cc | 575 | "Expected an associative and commutative operation!"); |
223e47cc LB |
576 | |
577 | // Visit all operands of the expression, keeping track of their weight (the | |
578 | // number of paths from the expression root to the operand, or if you like | |
579 | // the number of times that operand occurs in the linearized expression). | |
580 | // For example, if I = X + A, where X = A + B, then I, X and B have weight 1 | |
581 | // while A has weight two. | |
582 | ||
583 | // Worklist of non-leaf nodes (their operands are in the expression too) along | |
584 | // with their weights, representing a certain number of paths to the operator. | |
585 | // If an operator occurs in the worklist multiple times then we found multiple | |
586 | // ways to get to it. | |
587 | SmallVector<std::pair<BinaryOperator*, APInt>, 8> Worklist; // (Op, Weight) | |
588 | Worklist.push_back(std::make_pair(I, APInt(Bitwidth, 1))); | |
85aaf69f | 589 | bool Changed = false; |
223e47cc LB |
590 | |
591 | // Leaves of the expression are values that either aren't the right kind of | |
592 | // operation (eg: a constant, or a multiply in an add tree), or are, but have | |
593 | // some uses that are not inside the expression. For example, in I = X + X, | |
594 | // X = A + B, the value X has two uses (by I) that are in the expression. If | |
595 | // X has any other uses, for example in a return instruction, then we consider | |
596 | // X to be a leaf, and won't analyze it further. When we first visit a value, | |
597 | // if it has more than one use then at first we conservatively consider it to | |
598 | // be a leaf. Later, as the expression is explored, we may discover some more | |
599 | // uses of the value from inside the expression. If all uses turn out to be | |
600 | // from within the expression (and the value is a binary operator of the right | |
601 | // kind) then the value is no longer considered to be a leaf, and its operands | |
602 | // are explored. | |
603 | ||
604 | // Leaves - Keeps track of the set of putative leaves as well as the number of | |
605 | // paths to each leaf seen so far. | |
606 | typedef DenseMap<Value*, APInt> LeafMap; | |
607 | LeafMap Leaves; // Leaf -> Total weight so far. | |
608 | SmallVector<Value*, 8> LeafOrder; // Ensure deterministic leaf output order. | |
609 | ||
610 | #ifndef NDEBUG | |
611 | SmallPtrSet<Value*, 8> Visited; // For sanity checking the iteration scheme. | |
612 | #endif | |
613 | while (!Worklist.empty()) { | |
614 | std::pair<BinaryOperator*, APInt> P = Worklist.pop_back_val(); | |
615 | I = P.first; // We examine the operands of this binary operator. | |
616 | ||
617 | for (unsigned OpIdx = 0; OpIdx < 2; ++OpIdx) { // Visit operands. | |
618 | Value *Op = I->getOperand(OpIdx); | |
619 | APInt Weight = P.second; // Number of paths to this operand. | |
620 | DEBUG(dbgs() << "OPERAND: " << *Op << " (" << Weight << ")\n"); | |
621 | assert(!Op->use_empty() && "No uses, so how did we get to it?!"); | |
622 | ||
223e47cc LB |
623 | // If this is a binary operation of the right kind with only one use then |
624 | // add its operands to the expression. | |
625 | if (BinaryOperator *BO = isReassociableOp(Op, Opcode)) { | |
85aaf69f | 626 | assert(Visited.insert(Op).second && "Not first visit!"); |
223e47cc LB |
627 | DEBUG(dbgs() << "DIRECT ADD: " << *Op << " (" << Weight << ")\n"); |
628 | Worklist.push_back(std::make_pair(BO, Weight)); | |
629 | continue; | |
630 | } | |
631 | ||
632 | // Appears to be a leaf. Is the operand already in the set of leaves? | |
633 | LeafMap::iterator It = Leaves.find(Op); | |
634 | if (It == Leaves.end()) { | |
635 | // Not in the leaf map. Must be the first time we saw this operand. | |
85aaf69f | 636 | assert(Visited.insert(Op).second && "Not first visit!"); |
223e47cc LB |
637 | if (!Op->hasOneUse()) { |
638 | // This value has uses not accounted for by the expression, so it is | |
639 | // not safe to modify. Mark it as being a leaf. | |
640 | DEBUG(dbgs() << "ADD USES LEAF: " << *Op << " (" << Weight << ")\n"); | |
641 | LeafOrder.push_back(Op); | |
642 | Leaves[Op] = Weight; | |
643 | continue; | |
644 | } | |
645 | // No uses outside the expression, try morphing it. | |
646 | } else if (It != Leaves.end()) { | |
647 | // Already in the leaf map. | |
648 | assert(Visited.count(Op) && "In leaf map but not visited!"); | |
649 | ||
650 | // Update the number of paths to the leaf. | |
651 | IncorporateWeight(It->second, Weight, Opcode); | |
652 | ||
653 | #if 0 // TODO: Re-enable once PR13021 is fixed. | |
654 | // The leaf already has one use from inside the expression. As we want | |
655 | // exactly one such use, drop this new use of the leaf. | |
656 | assert(!Op->hasOneUse() && "Only one use, but we got here twice!"); | |
657 | I->setOperand(OpIdx, UndefValue::get(I->getType())); | |
85aaf69f | 658 | Changed = true; |
223e47cc LB |
659 | |
660 | // If the leaf is a binary operation of the right kind and we now see | |
661 | // that its multiple original uses were in fact all by nodes belonging | |
662 | // to the expression, then no longer consider it to be a leaf and add | |
663 | // its operands to the expression. | |
664 | if (BinaryOperator *BO = isReassociableOp(Op, Opcode)) { | |
665 | DEBUG(dbgs() << "UNLEAF: " << *Op << " (" << It->second << ")\n"); | |
666 | Worklist.push_back(std::make_pair(BO, It->second)); | |
667 | Leaves.erase(It); | |
668 | continue; | |
669 | } | |
670 | #endif | |
671 | ||
672 | // If we still have uses that are not accounted for by the expression | |
673 | // then it is not safe to modify the value. | |
674 | if (!Op->hasOneUse()) | |
675 | continue; | |
676 | ||
677 | // No uses outside the expression, try morphing it. | |
678 | Weight = It->second; | |
679 | Leaves.erase(It); // Since the value may be morphed below. | |
680 | } | |
681 | ||
682 | // At this point we have a value which, first of all, is not a binary | |
683 | // expression of the right kind, and secondly, is only used inside the | |
684 | // expression. This means that it can safely be modified. See if we | |
685 | // can usefully morph it into an expression of the right kind. | |
686 | assert((!isa<Instruction>(Op) || | |
85aaf69f SL |
687 | cast<Instruction>(Op)->getOpcode() != Opcode |
688 | || (isa<FPMathOperator>(Op) && | |
689 | !cast<Instruction>(Op)->hasUnsafeAlgebra())) && | |
223e47cc LB |
690 | "Should have been handled above!"); |
691 | assert(Op->hasOneUse() && "Has uses outside the expression tree!"); | |
692 | ||
693 | // If this is a multiply expression, turn any internal negations into | |
694 | // multiplies by -1 so they can be reassociated. | |
1a4d82fc JJ |
695 | if (BinaryOperator *BO = dyn_cast<BinaryOperator>(Op)) |
696 | if ((Opcode == Instruction::Mul && BinaryOperator::isNeg(BO)) || | |
697 | (Opcode == Instruction::FMul && BinaryOperator::isFNeg(BO))) { | |
698 | DEBUG(dbgs() << "MORPH LEAF: " << *Op << " (" << Weight << ") TO "); | |
699 | BO = LowerNegateToMultiply(BO); | |
700 | DEBUG(dbgs() << *BO << '\n'); | |
701 | Worklist.push_back(std::make_pair(BO, Weight)); | |
85aaf69f | 702 | Changed = true; |
1a4d82fc JJ |
703 | continue; |
704 | } | |
223e47cc LB |
705 | |
706 | // Failed to morph into an expression of the right type. This really is | |
707 | // a leaf. | |
708 | DEBUG(dbgs() << "ADD LEAF: " << *Op << " (" << Weight << ")\n"); | |
709 | assert(!isReassociableOp(Op, Opcode) && "Value was morphed?"); | |
710 | LeafOrder.push_back(Op); | |
711 | Leaves[Op] = Weight; | |
712 | } | |
713 | } | |
714 | ||
715 | // The leaves, repeated according to their weights, represent the linearized | |
716 | // form of the expression. | |
223e47cc LB |
717 | for (unsigned i = 0, e = LeafOrder.size(); i != e; ++i) { |
718 | Value *V = LeafOrder[i]; | |
719 | LeafMap::iterator It = Leaves.find(V); | |
720 | if (It == Leaves.end()) | |
721 | // Node initially thought to be a leaf wasn't. | |
722 | continue; | |
723 | assert(!isReassociableOp(V, Opcode) && "Shouldn't be a leaf!"); | |
724 | APInt Weight = It->second; | |
725 | if (Weight.isMinValue()) | |
726 | // Leaf already output or weight reduction eliminated it. | |
727 | continue; | |
728 | // Ensure the leaf is only output once. | |
729 | It->second = 0; | |
223e47cc LB |
730 | Ops.push_back(std::make_pair(V, Weight)); |
731 | } | |
732 | ||
223e47cc LB |
733 | // For nilpotent operations or addition there may be no operands, for example |
734 | // because the expression was "X xor X" or consisted of 2^Bitwidth additions: | |
735 | // in both cases the weight reduces to 0 causing the value to be skipped. | |
736 | if (Ops.empty()) { | |
970d7e83 | 737 | Constant *Identity = ConstantExpr::getBinOpIdentity(Opcode, I->getType()); |
223e47cc LB |
738 | assert(Identity && "Associative operation without identity!"); |
739 | Ops.push_back(std::make_pair(Identity, APInt(Bitwidth, 1))); | |
740 | } | |
741 | ||
85aaf69f | 742 | return Changed; |
223e47cc LB |
743 | } |
744 | ||
745 | // RewriteExprTree - Now that the operands for this expression tree are | |
746 | // linearized and optimized, emit them in-order. | |
747 | void Reassociate::RewriteExprTree(BinaryOperator *I, | |
748 | SmallVectorImpl<ValueEntry> &Ops) { | |
749 | assert(Ops.size() > 1 && "Single values should be used directly!"); | |
750 | ||
970d7e83 LB |
751 | // Since our optimizations should never increase the number of operations, the |
752 | // new expression can usually be written reusing the existing binary operators | |
223e47cc LB |
753 | // from the original expression tree, without creating any new instructions, |
754 | // though the rewritten expression may have a completely different topology. | |
755 | // We take care to not change anything if the new expression will be the same | |
756 | // as the original. If more than trivial changes (like commuting operands) | |
757 | // were made then we are obliged to clear out any optional subclass data like | |
758 | // nsw flags. | |
759 | ||
760 | /// NodesToRewrite - Nodes from the original expression available for writing | |
761 | /// the new expression into. | |
762 | SmallVector<BinaryOperator*, 8> NodesToRewrite; | |
763 | unsigned Opcode = I->getOpcode(); | |
764 | BinaryOperator *Op = I; | |
765 | ||
970d7e83 LB |
766 | /// NotRewritable - The operands being written will be the leaves of the new |
767 | /// expression and must not be used as inner nodes (via NodesToRewrite) by | |
768 | /// mistake. Inner nodes are always reassociable, and usually leaves are not | |
769 | /// (if they were they would have been incorporated into the expression and so | |
770 | /// would not be leaves), so most of the time there is no danger of this. But | |
771 | /// in rare cases a leaf may become reassociable if an optimization kills uses | |
772 | /// of it, or it may momentarily become reassociable during rewriting (below) | |
773 | /// due it being removed as an operand of one of its uses. Ensure that misuse | |
774 | /// of leaf nodes as inner nodes cannot occur by remembering all of the future | |
775 | /// leaves and refusing to reuse any of them as inner nodes. | |
776 | SmallPtrSet<Value*, 8> NotRewritable; | |
777 | for (unsigned i = 0, e = Ops.size(); i != e; ++i) | |
778 | NotRewritable.insert(Ops[i].Op); | |
779 | ||
223e47cc LB |
780 | // ExpressionChanged - Non-null if the rewritten expression differs from the |
781 | // original in some non-trivial way, requiring the clearing of optional flags. | |
782 | // Flags are cleared from the operator in ExpressionChanged up to I inclusive. | |
1a4d82fc | 783 | BinaryOperator *ExpressionChanged = nullptr; |
223e47cc LB |
784 | for (unsigned i = 0; ; ++i) { |
785 | // The last operation (which comes earliest in the IR) is special as both | |
786 | // operands will come from Ops, rather than just one with the other being | |
787 | // a subexpression. | |
788 | if (i+2 == Ops.size()) { | |
789 | Value *NewLHS = Ops[i].Op; | |
790 | Value *NewRHS = Ops[i+1].Op; | |
791 | Value *OldLHS = Op->getOperand(0); | |
792 | Value *OldRHS = Op->getOperand(1); | |
793 | ||
794 | if (NewLHS == OldLHS && NewRHS == OldRHS) | |
795 | // Nothing changed, leave it alone. | |
796 | break; | |
797 | ||
798 | if (NewLHS == OldRHS && NewRHS == OldLHS) { | |
799 | // The order of the operands was reversed. Swap them. | |
800 | DEBUG(dbgs() << "RA: " << *Op << '\n'); | |
801 | Op->swapOperands(); | |
802 | DEBUG(dbgs() << "TO: " << *Op << '\n'); | |
803 | MadeChange = true; | |
804 | ++NumChanged; | |
805 | break; | |
806 | } | |
807 | ||
808 | // The new operation differs non-trivially from the original. Overwrite | |
809 | // the old operands with the new ones. | |
810 | DEBUG(dbgs() << "RA: " << *Op << '\n'); | |
811 | if (NewLHS != OldLHS) { | |
970d7e83 LB |
812 | BinaryOperator *BO = isReassociableOp(OldLHS, Opcode); |
813 | if (BO && !NotRewritable.count(BO)) | |
223e47cc LB |
814 | NodesToRewrite.push_back(BO); |
815 | Op->setOperand(0, NewLHS); | |
816 | } | |
817 | if (NewRHS != OldRHS) { | |
970d7e83 LB |
818 | BinaryOperator *BO = isReassociableOp(OldRHS, Opcode); |
819 | if (BO && !NotRewritable.count(BO)) | |
223e47cc LB |
820 | NodesToRewrite.push_back(BO); |
821 | Op->setOperand(1, NewRHS); | |
822 | } | |
823 | DEBUG(dbgs() << "TO: " << *Op << '\n'); | |
824 | ||
825 | ExpressionChanged = Op; | |
826 | MadeChange = true; | |
827 | ++NumChanged; | |
828 | ||
829 | break; | |
830 | } | |
831 | ||
832 | // Not the last operation. The left-hand side will be a sub-expression | |
833 | // while the right-hand side will be the current element of Ops. | |
834 | Value *NewRHS = Ops[i].Op; | |
835 | if (NewRHS != Op->getOperand(1)) { | |
836 | DEBUG(dbgs() << "RA: " << *Op << '\n'); | |
837 | if (NewRHS == Op->getOperand(0)) { | |
838 | // The new right-hand side was already present as the left operand. If | |
839 | // we are lucky then swapping the operands will sort out both of them. | |
840 | Op->swapOperands(); | |
841 | } else { | |
842 | // Overwrite with the new right-hand side. | |
970d7e83 LB |
843 | BinaryOperator *BO = isReassociableOp(Op->getOperand(1), Opcode); |
844 | if (BO && !NotRewritable.count(BO)) | |
223e47cc LB |
845 | NodesToRewrite.push_back(BO); |
846 | Op->setOperand(1, NewRHS); | |
847 | ExpressionChanged = Op; | |
848 | } | |
849 | DEBUG(dbgs() << "TO: " << *Op << '\n'); | |
850 | MadeChange = true; | |
851 | ++NumChanged; | |
852 | } | |
853 | ||
854 | // Now deal with the left-hand side. If this is already an operation node | |
855 | // from the original expression then just rewrite the rest of the expression | |
856 | // into it. | |
970d7e83 LB |
857 | BinaryOperator *BO = isReassociableOp(Op->getOperand(0), Opcode); |
858 | if (BO && !NotRewritable.count(BO)) { | |
223e47cc LB |
859 | Op = BO; |
860 | continue; | |
861 | } | |
862 | ||
863 | // Otherwise, grab a spare node from the original expression and use that as | |
864 | // the left-hand side. If there are no nodes left then the optimizers made | |
865 | // an expression with more nodes than the original! This usually means that | |
866 | // they did something stupid but it might mean that the problem was just too | |
867 | // hard (finding the mimimal number of multiplications needed to realize a | |
868 | // multiplication expression is NP-complete). Whatever the reason, smart or | |
869 | // stupid, create a new node if there are none left. | |
870 | BinaryOperator *NewOp; | |
871 | if (NodesToRewrite.empty()) { | |
872 | Constant *Undef = UndefValue::get(I->getType()); | |
873 | NewOp = BinaryOperator::Create(Instruction::BinaryOps(Opcode), | |
874 | Undef, Undef, "", I); | |
1a4d82fc JJ |
875 | if (NewOp->getType()->isFloatingPointTy()) |
876 | NewOp->setFastMathFlags(I->getFastMathFlags()); | |
223e47cc LB |
877 | } else { |
878 | NewOp = NodesToRewrite.pop_back_val(); | |
879 | } | |
880 | ||
881 | DEBUG(dbgs() << "RA: " << *Op << '\n'); | |
882 | Op->setOperand(0, NewOp); | |
883 | DEBUG(dbgs() << "TO: " << *Op << '\n'); | |
884 | ExpressionChanged = Op; | |
885 | MadeChange = true; | |
886 | ++NumChanged; | |
887 | Op = NewOp; | |
888 | } | |
889 | ||
890 | // If the expression changed non-trivially then clear out all subclass data | |
891 | // starting from the operator specified in ExpressionChanged, and compactify | |
892 | // the operators to just before the expression root to guarantee that the | |
893 | // expression tree is dominated by all of Ops. | |
894 | if (ExpressionChanged) | |
895 | do { | |
1a4d82fc JJ |
896 | // Preserve FastMathFlags. |
897 | if (isa<FPMathOperator>(I)) { | |
898 | FastMathFlags Flags = I->getFastMathFlags(); | |
899 | ExpressionChanged->clearSubclassOptionalData(); | |
900 | ExpressionChanged->setFastMathFlags(Flags); | |
901 | } else | |
902 | ExpressionChanged->clearSubclassOptionalData(); | |
903 | ||
223e47cc LB |
904 | if (ExpressionChanged == I) |
905 | break; | |
906 | ExpressionChanged->moveBefore(I); | |
1a4d82fc | 907 | ExpressionChanged = cast<BinaryOperator>(*ExpressionChanged->user_begin()); |
223e47cc LB |
908 | } while (1); |
909 | ||
910 | // Throw away any left over nodes from the original expression. | |
911 | for (unsigned i = 0, e = NodesToRewrite.size(); i != e; ++i) | |
912 | RedoInsts.insert(NodesToRewrite[i]); | |
913 | } | |
914 | ||
915 | /// NegateValue - Insert instructions before the instruction pointed to by BI, | |
916 | /// that computes the negative version of the value specified. The negative | |
917 | /// version of the value is returned, and BI is left pointing at the instruction | |
918 | /// that should be processed next by the reassociation pass. | |
919 | static Value *NegateValue(Value *V, Instruction *BI) { | |
1a4d82fc JJ |
920 | if (ConstantFP *C = dyn_cast<ConstantFP>(V)) |
921 | return ConstantExpr::getFNeg(C); | |
223e47cc LB |
922 | if (Constant *C = dyn_cast<Constant>(V)) |
923 | return ConstantExpr::getNeg(C); | |
924 | ||
925 | // We are trying to expose opportunity for reassociation. One of the things | |
926 | // that we want to do to achieve this is to push a negation as deep into an | |
927 | // expression chain as possible, to expose the add instructions. In practice, | |
928 | // this means that we turn this: | |
929 | // X = -(A+12+C+D) into X = -A + -12 + -C + -D = -12 + -A + -C + -D | |
930 | // so that later, a: Y = 12+X could get reassociated with the -12 to eliminate | |
931 | // the constants. We assume that instcombine will clean up the mess later if | |
932 | // we introduce tons of unnecessary negation instructions. | |
933 | // | |
1a4d82fc JJ |
934 | if (BinaryOperator *I = |
935 | isReassociableOp(V, Instruction::Add, Instruction::FAdd)) { | |
223e47cc LB |
936 | // Push the negates through the add. |
937 | I->setOperand(0, NegateValue(I->getOperand(0), BI)); | |
938 | I->setOperand(1, NegateValue(I->getOperand(1), BI)); | |
939 | ||
940 | // We must move the add instruction here, because the neg instructions do | |
941 | // not dominate the old add instruction in general. By moving it, we are | |
942 | // assured that the neg instructions we just inserted dominate the | |
943 | // instruction we are about to insert after them. | |
944 | // | |
945 | I->moveBefore(BI); | |
946 | I->setName(I->getName()+".neg"); | |
947 | return I; | |
948 | } | |
949 | ||
950 | // Okay, we need to materialize a negated version of V with an instruction. | |
951 | // Scan the use lists of V to see if we have one already. | |
1a4d82fc JJ |
952 | for (User *U : V->users()) { |
953 | if (!BinaryOperator::isNeg(U) && !BinaryOperator::isFNeg(U)) | |
954 | continue; | |
223e47cc LB |
955 | |
956 | // We found one! Now we have to make sure that the definition dominates | |
957 | // this use. We do this by moving it to the entry block (if it is a | |
958 | // non-instruction value) or right after the definition. These negates will | |
959 | // be zapped by reassociate later, so we don't need much finesse here. | |
960 | BinaryOperator *TheNeg = cast<BinaryOperator>(U); | |
961 | ||
962 | // Verify that the negate is in this function, V might be a constant expr. | |
963 | if (TheNeg->getParent()->getParent() != BI->getParent()->getParent()) | |
964 | continue; | |
965 | ||
966 | BasicBlock::iterator InsertPt; | |
967 | if (Instruction *InstInput = dyn_cast<Instruction>(V)) { | |
968 | if (InvokeInst *II = dyn_cast<InvokeInst>(InstInput)) { | |
969 | InsertPt = II->getNormalDest()->begin(); | |
970 | } else { | |
971 | InsertPt = InstInput; | |
972 | ++InsertPt; | |
973 | } | |
974 | while (isa<PHINode>(InsertPt)) ++InsertPt; | |
975 | } else { | |
976 | InsertPt = TheNeg->getParent()->getParent()->getEntryBlock().begin(); | |
977 | } | |
978 | TheNeg->moveBefore(InsertPt); | |
979 | return TheNeg; | |
980 | } | |
981 | ||
982 | // Insert a 'neg' instruction that subtracts the value from zero to get the | |
983 | // negation. | |
1a4d82fc | 984 | return CreateNeg(V, V->getName() + ".neg", BI, BI); |
223e47cc LB |
985 | } |
986 | ||
987 | /// ShouldBreakUpSubtract - Return true if we should break up this subtract of | |
988 | /// X-Y into (X + -Y). | |
989 | static bool ShouldBreakUpSubtract(Instruction *Sub) { | |
990 | // If this is a negation, we can't split it up! | |
1a4d82fc | 991 | if (BinaryOperator::isNeg(Sub) || BinaryOperator::isFNeg(Sub)) |
223e47cc LB |
992 | return false; |
993 | ||
85aaf69f SL |
994 | // Don't breakup X - undef. |
995 | if (isa<UndefValue>(Sub->getOperand(1))) | |
996 | return false; | |
997 | ||
223e47cc LB |
998 | // Don't bother to break this up unless either the LHS is an associable add or |
999 | // subtract or if this is only used by one. | |
1a4d82fc JJ |
1000 | Value *V0 = Sub->getOperand(0); |
1001 | if (isReassociableOp(V0, Instruction::Add, Instruction::FAdd) || | |
1002 | isReassociableOp(V0, Instruction::Sub, Instruction::FSub)) | |
223e47cc | 1003 | return true; |
1a4d82fc JJ |
1004 | Value *V1 = Sub->getOperand(1); |
1005 | if (isReassociableOp(V1, Instruction::Add, Instruction::FAdd) || | |
1006 | isReassociableOp(V1, Instruction::Sub, Instruction::FSub)) | |
223e47cc | 1007 | return true; |
1a4d82fc | 1008 | Value *VB = Sub->user_back(); |
223e47cc | 1009 | if (Sub->hasOneUse() && |
1a4d82fc JJ |
1010 | (isReassociableOp(VB, Instruction::Add, Instruction::FAdd) || |
1011 | isReassociableOp(VB, Instruction::Sub, Instruction::FSub))) | |
223e47cc LB |
1012 | return true; |
1013 | ||
1014 | return false; | |
1015 | } | |
1016 | ||
1017 | /// BreakUpSubtract - If we have (X-Y), and if either X is an add, or if this is | |
1018 | /// only used by an add, transform this into (X+(0-Y)) to promote better | |
1019 | /// reassociation. | |
1020 | static BinaryOperator *BreakUpSubtract(Instruction *Sub) { | |
1021 | // Convert a subtract into an add and a neg instruction. This allows sub | |
1022 | // instructions to be commuted with other add instructions. | |
1023 | // | |
1024 | // Calculate the negative value of Operand 1 of the sub instruction, | |
1025 | // and set it as the RHS of the add instruction we just made. | |
1026 | // | |
1027 | Value *NegVal = NegateValue(Sub->getOperand(1), Sub); | |
1a4d82fc | 1028 | BinaryOperator *New = CreateAdd(Sub->getOperand(0), NegVal, "", Sub, Sub); |
223e47cc LB |
1029 | Sub->setOperand(0, Constant::getNullValue(Sub->getType())); // Drop use of op. |
1030 | Sub->setOperand(1, Constant::getNullValue(Sub->getType())); // Drop use of op. | |
1031 | New->takeName(Sub); | |
1032 | ||
1033 | // Everyone now refers to the add instruction. | |
1034 | Sub->replaceAllUsesWith(New); | |
1035 | New->setDebugLoc(Sub->getDebugLoc()); | |
1036 | ||
1037 | DEBUG(dbgs() << "Negated: " << *New << '\n'); | |
1038 | return New; | |
1039 | } | |
1040 | ||
1041 | /// ConvertShiftToMul - If this is a shift of a reassociable multiply or is used | |
1042 | /// by one, change this into a multiply by a constant to assist with further | |
1043 | /// reassociation. | |
1044 | static BinaryOperator *ConvertShiftToMul(Instruction *Shl) { | |
1045 | Constant *MulCst = ConstantInt::get(Shl->getType(), 1); | |
1046 | MulCst = ConstantExpr::getShl(MulCst, cast<Constant>(Shl->getOperand(1))); | |
1047 | ||
1048 | BinaryOperator *Mul = | |
1049 | BinaryOperator::CreateMul(Shl->getOperand(0), MulCst, "", Shl); | |
1050 | Shl->setOperand(0, UndefValue::get(Shl->getType())); // Drop use of op. | |
1051 | Mul->takeName(Shl); | |
85aaf69f SL |
1052 | |
1053 | // Everyone now refers to the mul instruction. | |
223e47cc LB |
1054 | Shl->replaceAllUsesWith(Mul); |
1055 | Mul->setDebugLoc(Shl->getDebugLoc()); | |
85aaf69f SL |
1056 | |
1057 | // We can safely preserve the nuw flag in all cases. It's also safe to turn a | |
1058 | // nuw nsw shl into a nuw nsw mul. However, nsw in isolation requires special | |
1059 | // handling. | |
1060 | bool NSW = cast<BinaryOperator>(Shl)->hasNoSignedWrap(); | |
1061 | bool NUW = cast<BinaryOperator>(Shl)->hasNoUnsignedWrap(); | |
1062 | if (NSW && NUW) | |
1063 | Mul->setHasNoSignedWrap(true); | |
1064 | Mul->setHasNoUnsignedWrap(NUW); | |
223e47cc LB |
1065 | return Mul; |
1066 | } | |
1067 | ||
1068 | /// FindInOperandList - Scan backwards and forwards among values with the same | |
1069 | /// rank as element i to see if X exists. If X does not exist, return i. This | |
1070 | /// is useful when scanning for 'x' when we see '-x' because they both get the | |
1071 | /// same rank. | |
1072 | static unsigned FindInOperandList(SmallVectorImpl<ValueEntry> &Ops, unsigned i, | |
1073 | Value *X) { | |
1074 | unsigned XRank = Ops[i].Rank; | |
1075 | unsigned e = Ops.size(); | |
85aaf69f | 1076 | for (unsigned j = i+1; j != e && Ops[j].Rank == XRank; ++j) { |
223e47cc LB |
1077 | if (Ops[j].Op == X) |
1078 | return j; | |
85aaf69f SL |
1079 | if (Instruction *I1 = dyn_cast<Instruction>(Ops[j].Op)) |
1080 | if (Instruction *I2 = dyn_cast<Instruction>(X)) | |
1081 | if (I1->isIdenticalTo(I2)) | |
1082 | return j; | |
1083 | } | |
223e47cc | 1084 | // Scan backwards. |
85aaf69f | 1085 | for (unsigned j = i-1; j != ~0U && Ops[j].Rank == XRank; --j) { |
223e47cc LB |
1086 | if (Ops[j].Op == X) |
1087 | return j; | |
85aaf69f SL |
1088 | if (Instruction *I1 = dyn_cast<Instruction>(Ops[j].Op)) |
1089 | if (Instruction *I2 = dyn_cast<Instruction>(X)) | |
1090 | if (I1->isIdenticalTo(I2)) | |
1091 | return j; | |
1092 | } | |
223e47cc LB |
1093 | return i; |
1094 | } | |
1095 | ||
1096 | /// EmitAddTreeOfValues - Emit a tree of add instructions, summing Ops together | |
1097 | /// and returning the result. Insert the tree before I. | |
1098 | static Value *EmitAddTreeOfValues(Instruction *I, | |
1099 | SmallVectorImpl<WeakVH> &Ops){ | |
1100 | if (Ops.size() == 1) return Ops.back(); | |
1101 | ||
1102 | Value *V1 = Ops.back(); | |
1103 | Ops.pop_back(); | |
1104 | Value *V2 = EmitAddTreeOfValues(I, Ops); | |
1a4d82fc | 1105 | return CreateAdd(V2, V1, "tmp", I, I); |
223e47cc LB |
1106 | } |
1107 | ||
1108 | /// RemoveFactorFromExpression - If V is an expression tree that is a | |
1109 | /// multiplication sequence, and if this sequence contains a multiply by Factor, | |
1110 | /// remove Factor from the tree and return the new tree. | |
1111 | Value *Reassociate::RemoveFactorFromExpression(Value *V, Value *Factor) { | |
1a4d82fc JJ |
1112 | BinaryOperator *BO = isReassociableOp(V, Instruction::Mul, Instruction::FMul); |
1113 | if (!BO) | |
1114 | return nullptr; | |
223e47cc LB |
1115 | |
1116 | SmallVector<RepeatedValue, 8> Tree; | |
1117 | MadeChange |= LinearizeExprTree(BO, Tree); | |
1118 | SmallVector<ValueEntry, 8> Factors; | |
1119 | Factors.reserve(Tree.size()); | |
1120 | for (unsigned i = 0, e = Tree.size(); i != e; ++i) { | |
1121 | RepeatedValue E = Tree[i]; | |
1122 | Factors.append(E.second.getZExtValue(), | |
1123 | ValueEntry(getRank(E.first), E.first)); | |
1124 | } | |
1125 | ||
1126 | bool FoundFactor = false; | |
1127 | bool NeedsNegate = false; | |
1128 | for (unsigned i = 0, e = Factors.size(); i != e; ++i) { | |
1129 | if (Factors[i].Op == Factor) { | |
1130 | FoundFactor = true; | |
1131 | Factors.erase(Factors.begin()+i); | |
1132 | break; | |
1133 | } | |
1134 | ||
1135 | // If this is a negative version of this factor, remove it. | |
1a4d82fc | 1136 | if (ConstantInt *FC1 = dyn_cast<ConstantInt>(Factor)) { |
223e47cc LB |
1137 | if (ConstantInt *FC2 = dyn_cast<ConstantInt>(Factors[i].Op)) |
1138 | if (FC1->getValue() == -FC2->getValue()) { | |
1139 | FoundFactor = NeedsNegate = true; | |
1140 | Factors.erase(Factors.begin()+i); | |
1141 | break; | |
1142 | } | |
1a4d82fc JJ |
1143 | } else if (ConstantFP *FC1 = dyn_cast<ConstantFP>(Factor)) { |
1144 | if (ConstantFP *FC2 = dyn_cast<ConstantFP>(Factors[i].Op)) { | |
1145 | APFloat F1(FC1->getValueAPF()); | |
1146 | APFloat F2(FC2->getValueAPF()); | |
1147 | F2.changeSign(); | |
1148 | if (F1.compare(F2) == APFloat::cmpEqual) { | |
1149 | FoundFactor = NeedsNegate = true; | |
1150 | Factors.erase(Factors.begin() + i); | |
1151 | break; | |
1152 | } | |
1153 | } | |
1154 | } | |
223e47cc LB |
1155 | } |
1156 | ||
1157 | if (!FoundFactor) { | |
1158 | // Make sure to restore the operands to the expression tree. | |
1159 | RewriteExprTree(BO, Factors); | |
1a4d82fc | 1160 | return nullptr; |
223e47cc LB |
1161 | } |
1162 | ||
1163 | BasicBlock::iterator InsertPt = BO; ++InsertPt; | |
1164 | ||
1165 | // If this was just a single multiply, remove the multiply and return the only | |
1166 | // remaining operand. | |
1167 | if (Factors.size() == 1) { | |
1168 | RedoInsts.insert(BO); | |
1169 | V = Factors[0].Op; | |
1170 | } else { | |
1171 | RewriteExprTree(BO, Factors); | |
1172 | V = BO; | |
1173 | } | |
1174 | ||
1175 | if (NeedsNegate) | |
1a4d82fc | 1176 | V = CreateNeg(V, "neg", InsertPt, BO); |
223e47cc LB |
1177 | |
1178 | return V; | |
1179 | } | |
1180 | ||
1181 | /// FindSingleUseMultiplyFactors - If V is a single-use multiply, recursively | |
1182 | /// add its operands as factors, otherwise add V to the list of factors. | |
1183 | /// | |
1184 | /// Ops is the top-level list of add operands we're trying to factor. | |
1185 | static void FindSingleUseMultiplyFactors(Value *V, | |
1186 | SmallVectorImpl<Value*> &Factors, | |
1187 | const SmallVectorImpl<ValueEntry> &Ops) { | |
1a4d82fc | 1188 | BinaryOperator *BO = isReassociableOp(V, Instruction::Mul, Instruction::FMul); |
223e47cc LB |
1189 | if (!BO) { |
1190 | Factors.push_back(V); | |
1191 | return; | |
1192 | } | |
1193 | ||
1194 | // Otherwise, add the LHS and RHS to the list of factors. | |
1195 | FindSingleUseMultiplyFactors(BO->getOperand(1), Factors, Ops); | |
1196 | FindSingleUseMultiplyFactors(BO->getOperand(0), Factors, Ops); | |
1197 | } | |
1198 | ||
1199 | /// OptimizeAndOrXor - Optimize a series of operands to an 'and', 'or', or 'xor' | |
1200 | /// instruction. This optimizes based on identities. If it can be reduced to | |
1201 | /// a single Value, it is returned, otherwise the Ops list is mutated as | |
1202 | /// necessary. | |
1203 | static Value *OptimizeAndOrXor(unsigned Opcode, | |
1204 | SmallVectorImpl<ValueEntry> &Ops) { | |
1205 | // Scan the operand lists looking for X and ~X pairs, along with X,X pairs. | |
1206 | // If we find any, we can simplify the expression. X&~X == 0, X|~X == -1. | |
1207 | for (unsigned i = 0, e = Ops.size(); i != e; ++i) { | |
1208 | // First, check for X and ~X in the operand list. | |
1209 | assert(i < Ops.size()); | |
1210 | if (BinaryOperator::isNot(Ops[i].Op)) { // Cannot occur for ^. | |
1211 | Value *X = BinaryOperator::getNotArgument(Ops[i].Op); | |
1212 | unsigned FoundX = FindInOperandList(Ops, i, X); | |
1213 | if (FoundX != i) { | |
1214 | if (Opcode == Instruction::And) // ...&X&~X = 0 | |
1215 | return Constant::getNullValue(X->getType()); | |
1216 | ||
1217 | if (Opcode == Instruction::Or) // ...|X|~X = -1 | |
1218 | return Constant::getAllOnesValue(X->getType()); | |
1219 | } | |
1220 | } | |
1221 | ||
1222 | // Next, check for duplicate pairs of values, which we assume are next to | |
1223 | // each other, due to our sorting criteria. | |
1224 | assert(i < Ops.size()); | |
1225 | if (i+1 != Ops.size() && Ops[i+1].Op == Ops[i].Op) { | |
1226 | if (Opcode == Instruction::And || Opcode == Instruction::Or) { | |
1227 | // Drop duplicate values for And and Or. | |
1228 | Ops.erase(Ops.begin()+i); | |
1229 | --i; --e; | |
1230 | ++NumAnnihil; | |
1231 | continue; | |
1232 | } | |
1233 | ||
1234 | // Drop pairs of values for Xor. | |
1235 | assert(Opcode == Instruction::Xor); | |
1236 | if (e == 2) | |
1237 | return Constant::getNullValue(Ops[0].Op->getType()); | |
1238 | ||
1239 | // Y ^ X^X -> Y | |
1240 | Ops.erase(Ops.begin()+i, Ops.begin()+i+2); | |
1241 | i -= 1; e -= 2; | |
1242 | ++NumAnnihil; | |
1243 | } | |
1244 | } | |
1a4d82fc JJ |
1245 | return nullptr; |
1246 | } | |
1247 | ||
1248 | /// Helper funciton of CombineXorOpnd(). It creates a bitwise-and | |
1249 | /// instruction with the given two operands, and return the resulting | |
1250 | /// instruction. There are two special cases: 1) if the constant operand is 0, | |
1251 | /// it will return NULL. 2) if the constant is ~0, the symbolic operand will | |
1252 | /// be returned. | |
1253 | static Value *createAndInstr(Instruction *InsertBefore, Value *Opnd, | |
1254 | const APInt &ConstOpnd) { | |
1255 | if (ConstOpnd != 0) { | |
1256 | if (!ConstOpnd.isAllOnesValue()) { | |
1257 | LLVMContext &Ctx = Opnd->getType()->getContext(); | |
1258 | Instruction *I; | |
1259 | I = BinaryOperator::CreateAnd(Opnd, ConstantInt::get(Ctx, ConstOpnd), | |
1260 | "and.ra", InsertBefore); | |
1261 | I->setDebugLoc(InsertBefore->getDebugLoc()); | |
1262 | return I; | |
1263 | } | |
1264 | return Opnd; | |
1265 | } | |
1266 | return nullptr; | |
1267 | } | |
1268 | ||
1269 | // Helper function of OptimizeXor(). It tries to simplify "Opnd1 ^ ConstOpnd" | |
1270 | // into "R ^ C", where C would be 0, and R is a symbolic value. | |
1271 | // | |
1272 | // If it was successful, true is returned, and the "R" and "C" is returned | |
1273 | // via "Res" and "ConstOpnd", respectively; otherwise, false is returned, | |
1274 | // and both "Res" and "ConstOpnd" remain unchanged. | |
1275 | // | |
1276 | bool Reassociate::CombineXorOpnd(Instruction *I, XorOpnd *Opnd1, | |
1277 | APInt &ConstOpnd, Value *&Res) { | |
1278 | // Xor-Rule 1: (x | c1) ^ c2 = (x | c1) ^ (c1 ^ c1) ^ c2 | |
1279 | // = ((x | c1) ^ c1) ^ (c1 ^ c2) | |
1280 | // = (x & ~c1) ^ (c1 ^ c2) | |
1281 | // It is useful only when c1 == c2. | |
1282 | if (Opnd1->isOrExpr() && Opnd1->getConstPart() != 0) { | |
1283 | if (!Opnd1->getValue()->hasOneUse()) | |
1284 | return false; | |
1285 | ||
1286 | const APInt &C1 = Opnd1->getConstPart(); | |
1287 | if (C1 != ConstOpnd) | |
1288 | return false; | |
1289 | ||
1290 | Value *X = Opnd1->getSymbolicPart(); | |
1291 | Res = createAndInstr(I, X, ~C1); | |
1292 | // ConstOpnd was C2, now C1 ^ C2. | |
1293 | ConstOpnd ^= C1; | |
1294 | ||
1295 | if (Instruction *T = dyn_cast<Instruction>(Opnd1->getValue())) | |
1296 | RedoInsts.insert(T); | |
1297 | return true; | |
1298 | } | |
1299 | return false; | |
1300 | } | |
1301 | ||
1302 | ||
1303 | // Helper function of OptimizeXor(). It tries to simplify | |
1304 | // "Opnd1 ^ Opnd2 ^ ConstOpnd" into "R ^ C", where C would be 0, and R is a | |
1305 | // symbolic value. | |
1306 | // | |
1307 | // If it was successful, true is returned, and the "R" and "C" is returned | |
1308 | // via "Res" and "ConstOpnd", respectively (If the entire expression is | |
1309 | // evaluated to a constant, the Res is set to NULL); otherwise, false is | |
1310 | // returned, and both "Res" and "ConstOpnd" remain unchanged. | |
1311 | bool Reassociate::CombineXorOpnd(Instruction *I, XorOpnd *Opnd1, XorOpnd *Opnd2, | |
1312 | APInt &ConstOpnd, Value *&Res) { | |
1313 | Value *X = Opnd1->getSymbolicPart(); | |
1314 | if (X != Opnd2->getSymbolicPart()) | |
1315 | return false; | |
1316 | ||
1317 | // This many instruction become dead.(At least "Opnd1 ^ Opnd2" will die.) | |
1318 | int DeadInstNum = 1; | |
1319 | if (Opnd1->getValue()->hasOneUse()) | |
1320 | DeadInstNum++; | |
1321 | if (Opnd2->getValue()->hasOneUse()) | |
1322 | DeadInstNum++; | |
1323 | ||
1324 | // Xor-Rule 2: | |
1325 | // (x | c1) ^ (x & c2) | |
1326 | // = (x|c1) ^ (x&c2) ^ (c1 ^ c1) = ((x|c1) ^ c1) ^ (x & c2) ^ c1 | |
1327 | // = (x & ~c1) ^ (x & c2) ^ c1 // Xor-Rule 1 | |
1328 | // = (x & c3) ^ c1, where c3 = ~c1 ^ c2 // Xor-rule 3 | |
1329 | // | |
1330 | if (Opnd1->isOrExpr() != Opnd2->isOrExpr()) { | |
1331 | if (Opnd2->isOrExpr()) | |
1332 | std::swap(Opnd1, Opnd2); | |
1333 | ||
1334 | const APInt &C1 = Opnd1->getConstPart(); | |
1335 | const APInt &C2 = Opnd2->getConstPart(); | |
1336 | APInt C3((~C1) ^ C2); | |
1337 | ||
1338 | // Do not increase code size! | |
1339 | if (C3 != 0 && !C3.isAllOnesValue()) { | |
1340 | int NewInstNum = ConstOpnd != 0 ? 1 : 2; | |
1341 | if (NewInstNum > DeadInstNum) | |
1342 | return false; | |
1343 | } | |
1344 | ||
1345 | Res = createAndInstr(I, X, C3); | |
1346 | ConstOpnd ^= C1; | |
1347 | ||
1348 | } else if (Opnd1->isOrExpr()) { | |
1349 | // Xor-Rule 3: (x | c1) ^ (x | c2) = (x & c3) ^ c3 where c3 = c1 ^ c2 | |
1350 | // | |
1351 | const APInt &C1 = Opnd1->getConstPart(); | |
1352 | const APInt &C2 = Opnd2->getConstPart(); | |
1353 | APInt C3 = C1 ^ C2; | |
1354 | ||
1355 | // Do not increase code size | |
1356 | if (C3 != 0 && !C3.isAllOnesValue()) { | |
1357 | int NewInstNum = ConstOpnd != 0 ? 1 : 2; | |
1358 | if (NewInstNum > DeadInstNum) | |
1359 | return false; | |
1360 | } | |
1361 | ||
1362 | Res = createAndInstr(I, X, C3); | |
1363 | ConstOpnd ^= C3; | |
1364 | } else { | |
1365 | // Xor-Rule 4: (x & c1) ^ (x & c2) = (x & (c1^c2)) | |
1366 | // | |
1367 | const APInt &C1 = Opnd1->getConstPart(); | |
1368 | const APInt &C2 = Opnd2->getConstPart(); | |
1369 | APInt C3 = C1 ^ C2; | |
1370 | Res = createAndInstr(I, X, C3); | |
1371 | } | |
1372 | ||
1373 | // Put the original operands in the Redo list; hope they will be deleted | |
1374 | // as dead code. | |
1375 | if (Instruction *T = dyn_cast<Instruction>(Opnd1->getValue())) | |
1376 | RedoInsts.insert(T); | |
1377 | if (Instruction *T = dyn_cast<Instruction>(Opnd2->getValue())) | |
1378 | RedoInsts.insert(T); | |
1379 | ||
1380 | return true; | |
1381 | } | |
1382 | ||
1383 | /// Optimize a series of operands to an 'xor' instruction. If it can be reduced | |
1384 | /// to a single Value, it is returned, otherwise the Ops list is mutated as | |
1385 | /// necessary. | |
1386 | Value *Reassociate::OptimizeXor(Instruction *I, | |
1387 | SmallVectorImpl<ValueEntry> &Ops) { | |
1388 | if (Value *V = OptimizeAndOrXor(Instruction::Xor, Ops)) | |
1389 | return V; | |
1390 | ||
1391 | if (Ops.size() == 1) | |
1392 | return nullptr; | |
1393 | ||
1394 | SmallVector<XorOpnd, 8> Opnds; | |
1395 | SmallVector<XorOpnd*, 8> OpndPtrs; | |
1396 | Type *Ty = Ops[0].Op->getType(); | |
1397 | APInt ConstOpnd(Ty->getIntegerBitWidth(), 0); | |
1398 | ||
1399 | // Step 1: Convert ValueEntry to XorOpnd | |
1400 | for (unsigned i = 0, e = Ops.size(); i != e; ++i) { | |
1401 | Value *V = Ops[i].Op; | |
1402 | if (!isa<ConstantInt>(V)) { | |
1403 | XorOpnd O(V); | |
1404 | O.setSymbolicRank(getRank(O.getSymbolicPart())); | |
1405 | Opnds.push_back(O); | |
1406 | } else | |
1407 | ConstOpnd ^= cast<ConstantInt>(V)->getValue(); | |
1408 | } | |
1409 | ||
1410 | // NOTE: From this point on, do *NOT* add/delete element to/from "Opnds". | |
1411 | // It would otherwise invalidate the "Opnds"'s iterator, and hence invalidate | |
1412 | // the "OpndPtrs" as well. For the similar reason, do not fuse this loop | |
1413 | // with the previous loop --- the iterator of the "Opnds" may be invalidated | |
1414 | // when new elements are added to the vector. | |
1415 | for (unsigned i = 0, e = Opnds.size(); i != e; ++i) | |
1416 | OpndPtrs.push_back(&Opnds[i]); | |
1417 | ||
1418 | // Step 2: Sort the Xor-Operands in a way such that the operands containing | |
1419 | // the same symbolic value cluster together. For instance, the input operand | |
1420 | // sequence ("x | 123", "y & 456", "x & 789") will be sorted into: | |
1421 | // ("x | 123", "x & 789", "y & 456"). | |
1422 | std::stable_sort(OpndPtrs.begin(), OpndPtrs.end(), XorOpnd::PtrSortFunctor()); | |
1423 | ||
1424 | // Step 3: Combine adjacent operands | |
1425 | XorOpnd *PrevOpnd = nullptr; | |
1426 | bool Changed = false; | |
1427 | for (unsigned i = 0, e = Opnds.size(); i < e; i++) { | |
1428 | XorOpnd *CurrOpnd = OpndPtrs[i]; | |
1429 | // The combined value | |
1430 | Value *CV; | |
1431 | ||
1432 | // Step 3.1: Try simplifying "CurrOpnd ^ ConstOpnd" | |
1433 | if (ConstOpnd != 0 && CombineXorOpnd(I, CurrOpnd, ConstOpnd, CV)) { | |
1434 | Changed = true; | |
1435 | if (CV) | |
1436 | *CurrOpnd = XorOpnd(CV); | |
1437 | else { | |
1438 | CurrOpnd->Invalidate(); | |
1439 | continue; | |
1440 | } | |
1441 | } | |
1442 | ||
1443 | if (!PrevOpnd || CurrOpnd->getSymbolicPart() != PrevOpnd->getSymbolicPart()) { | |
1444 | PrevOpnd = CurrOpnd; | |
1445 | continue; | |
1446 | } | |
1447 | ||
1448 | // step 3.2: When previous and current operands share the same symbolic | |
1449 | // value, try to simplify "PrevOpnd ^ CurrOpnd ^ ConstOpnd" | |
1450 | // | |
1451 | if (CombineXorOpnd(I, CurrOpnd, PrevOpnd, ConstOpnd, CV)) { | |
1452 | // Remove previous operand | |
1453 | PrevOpnd->Invalidate(); | |
1454 | if (CV) { | |
1455 | *CurrOpnd = XorOpnd(CV); | |
1456 | PrevOpnd = CurrOpnd; | |
1457 | } else { | |
1458 | CurrOpnd->Invalidate(); | |
1459 | PrevOpnd = nullptr; | |
1460 | } | |
1461 | Changed = true; | |
1462 | } | |
1463 | } | |
1464 | ||
1465 | // Step 4: Reassemble the Ops | |
1466 | if (Changed) { | |
1467 | Ops.clear(); | |
1468 | for (unsigned int i = 0, e = Opnds.size(); i < e; i++) { | |
1469 | XorOpnd &O = Opnds[i]; | |
1470 | if (O.isInvalid()) | |
1471 | continue; | |
1472 | ValueEntry VE(getRank(O.getValue()), O.getValue()); | |
1473 | Ops.push_back(VE); | |
1474 | } | |
1475 | if (ConstOpnd != 0) { | |
1476 | Value *C = ConstantInt::get(Ty->getContext(), ConstOpnd); | |
1477 | ValueEntry VE(getRank(C), C); | |
1478 | Ops.push_back(VE); | |
1479 | } | |
1480 | int Sz = Ops.size(); | |
1481 | if (Sz == 1) | |
1482 | return Ops.back().Op; | |
1483 | else if (Sz == 0) { | |
1484 | assert(ConstOpnd == 0); | |
1485 | return ConstantInt::get(Ty->getContext(), ConstOpnd); | |
1486 | } | |
1487 | } | |
1488 | ||
1489 | return nullptr; | |
223e47cc LB |
1490 | } |
1491 | ||
1492 | /// OptimizeAdd - Optimize a series of operands to an 'add' instruction. This | |
1493 | /// optimizes based on identities. If it can be reduced to a single Value, it | |
1494 | /// is returned, otherwise the Ops list is mutated as necessary. | |
1495 | Value *Reassociate::OptimizeAdd(Instruction *I, | |
1496 | SmallVectorImpl<ValueEntry> &Ops) { | |
1497 | // Scan the operand lists looking for X and -X pairs. If we find any, we | |
1a4d82fc JJ |
1498 | // can simplify expressions like X+-X == 0 and X+~X ==-1. While we're at it, |
1499 | // scan for any | |
223e47cc | 1500 | // duplicates. We want to canonicalize Y+Y+Y+Z -> 3*Y+Z. |
1a4d82fc | 1501 | |
223e47cc LB |
1502 | for (unsigned i = 0, e = Ops.size(); i != e; ++i) { |
1503 | Value *TheOp = Ops[i].Op; | |
1504 | // Check to see if we've seen this operand before. If so, we factor all | |
1505 | // instances of the operand together. Due to our sorting criteria, we know | |
1506 | // that these need to be next to each other in the vector. | |
1507 | if (i+1 != Ops.size() && Ops[i+1].Op == TheOp) { | |
1508 | // Rescan the list, remove all instances of this operand from the expr. | |
1509 | unsigned NumFound = 0; | |
1510 | do { | |
1511 | Ops.erase(Ops.begin()+i); | |
1512 | ++NumFound; | |
1513 | } while (i != Ops.size() && Ops[i].Op == TheOp); | |
1514 | ||
85aaf69f | 1515 | DEBUG(dbgs() << "\nFACTORING [" << NumFound << "]: " << *TheOp << '\n'); |
223e47cc LB |
1516 | ++NumFactor; |
1517 | ||
1518 | // Insert a new multiply. | |
1a4d82fc JJ |
1519 | Type *Ty = TheOp->getType(); |
1520 | Constant *C = Ty->isIntegerTy() ? ConstantInt::get(Ty, NumFound) | |
1521 | : ConstantFP::get(Ty, NumFound); | |
1522 | Instruction *Mul = CreateMul(TheOp, C, "factor", I, I); | |
223e47cc LB |
1523 | |
1524 | // Now that we have inserted a multiply, optimize it. This allows us to | |
1525 | // handle cases that require multiple factoring steps, such as this: | |
1526 | // (X*2) + (X*2) + (X*2) -> (X*2)*3 -> X*6 | |
1a4d82fc | 1527 | RedoInsts.insert(Mul); |
223e47cc LB |
1528 | |
1529 | // If every add operand was a duplicate, return the multiply. | |
1530 | if (Ops.empty()) | |
1531 | return Mul; | |
1532 | ||
1533 | // Otherwise, we had some input that didn't have the dupe, such as | |
1534 | // "A + A + B" -> "A*2 + B". Add the new multiply to the list of | |
1535 | // things being added by this operation. | |
1536 | Ops.insert(Ops.begin(), ValueEntry(getRank(Mul), Mul)); | |
1537 | ||
1538 | --i; | |
1539 | e = Ops.size(); | |
1540 | continue; | |
1541 | } | |
1542 | ||
1a4d82fc JJ |
1543 | // Check for X and -X or X and ~X in the operand list. |
1544 | if (!BinaryOperator::isNeg(TheOp) && !BinaryOperator::isFNeg(TheOp) && | |
1545 | !BinaryOperator::isNot(TheOp)) | |
223e47cc LB |
1546 | continue; |
1547 | ||
1a4d82fc JJ |
1548 | Value *X = nullptr; |
1549 | if (BinaryOperator::isNeg(TheOp) || BinaryOperator::isFNeg(TheOp)) | |
1550 | X = BinaryOperator::getNegArgument(TheOp); | |
1551 | else if (BinaryOperator::isNot(TheOp)) | |
1552 | X = BinaryOperator::getNotArgument(TheOp); | |
1553 | ||
223e47cc LB |
1554 | unsigned FoundX = FindInOperandList(Ops, i, X); |
1555 | if (FoundX == i) | |
1556 | continue; | |
1557 | ||
1558 | // Remove X and -X from the operand list. | |
1a4d82fc JJ |
1559 | if (Ops.size() == 2 && |
1560 | (BinaryOperator::isNeg(TheOp) || BinaryOperator::isFNeg(TheOp))) | |
223e47cc LB |
1561 | return Constant::getNullValue(X->getType()); |
1562 | ||
1a4d82fc JJ |
1563 | // Remove X and ~X from the operand list. |
1564 | if (Ops.size() == 2 && BinaryOperator::isNot(TheOp)) | |
1565 | return Constant::getAllOnesValue(X->getType()); | |
1566 | ||
223e47cc LB |
1567 | Ops.erase(Ops.begin()+i); |
1568 | if (i < FoundX) | |
1569 | --FoundX; | |
1570 | else | |
1571 | --i; // Need to back up an extra one. | |
1572 | Ops.erase(Ops.begin()+FoundX); | |
1573 | ++NumAnnihil; | |
1574 | --i; // Revisit element. | |
1575 | e -= 2; // Removed two elements. | |
1a4d82fc JJ |
1576 | |
1577 | // if X and ~X we append -1 to the operand list. | |
1578 | if (BinaryOperator::isNot(TheOp)) { | |
1579 | Value *V = Constant::getAllOnesValue(X->getType()); | |
1580 | Ops.insert(Ops.end(), ValueEntry(getRank(V), V)); | |
1581 | e += 1; | |
1582 | } | |
223e47cc LB |
1583 | } |
1584 | ||
1585 | // Scan the operand list, checking to see if there are any common factors | |
1586 | // between operands. Consider something like A*A+A*B*C+D. We would like to | |
1587 | // reassociate this to A*(A+B*C)+D, which reduces the number of multiplies. | |
1588 | // To efficiently find this, we count the number of times a factor occurs | |
1589 | // for any ADD operands that are MULs. | |
1590 | DenseMap<Value*, unsigned> FactorOccurrences; | |
1591 | ||
1592 | // Keep track of each multiply we see, to avoid triggering on (X*4)+(X*4) | |
1593 | // where they are actually the same multiply. | |
1594 | unsigned MaxOcc = 0; | |
1a4d82fc | 1595 | Value *MaxOccVal = nullptr; |
223e47cc | 1596 | for (unsigned i = 0, e = Ops.size(); i != e; ++i) { |
1a4d82fc JJ |
1597 | BinaryOperator *BOp = |
1598 | isReassociableOp(Ops[i].Op, Instruction::Mul, Instruction::FMul); | |
223e47cc LB |
1599 | if (!BOp) |
1600 | continue; | |
1601 | ||
1602 | // Compute all of the factors of this added value. | |
1603 | SmallVector<Value*, 8> Factors; | |
1604 | FindSingleUseMultiplyFactors(BOp, Factors, Ops); | |
1605 | assert(Factors.size() > 1 && "Bad linearize!"); | |
1606 | ||
1607 | // Add one to FactorOccurrences for each unique factor in this op. | |
1608 | SmallPtrSet<Value*, 8> Duplicates; | |
1609 | for (unsigned i = 0, e = Factors.size(); i != e; ++i) { | |
1610 | Value *Factor = Factors[i]; | |
85aaf69f | 1611 | if (!Duplicates.insert(Factor).second) |
1a4d82fc | 1612 | continue; |
223e47cc LB |
1613 | |
1614 | unsigned Occ = ++FactorOccurrences[Factor]; | |
1a4d82fc JJ |
1615 | if (Occ > MaxOcc) { |
1616 | MaxOcc = Occ; | |
1617 | MaxOccVal = Factor; | |
1618 | } | |
223e47cc LB |
1619 | |
1620 | // If Factor is a negative constant, add the negated value as a factor | |
1621 | // because we can percolate the negate out. Watch for minint, which | |
1622 | // cannot be positivified. | |
1a4d82fc | 1623 | if (ConstantInt *CI = dyn_cast<ConstantInt>(Factor)) { |
223e47cc LB |
1624 | if (CI->isNegative() && !CI->isMinValue(true)) { |
1625 | Factor = ConstantInt::get(CI->getContext(), -CI->getValue()); | |
1626 | assert(!Duplicates.count(Factor) && | |
1627 | "Shouldn't have two constant factors, missed a canonicalize"); | |
223e47cc | 1628 | unsigned Occ = ++FactorOccurrences[Factor]; |
1a4d82fc JJ |
1629 | if (Occ > MaxOcc) { |
1630 | MaxOcc = Occ; | |
1631 | MaxOccVal = Factor; | |
1632 | } | |
1633 | } | |
1634 | } else if (ConstantFP *CF = dyn_cast<ConstantFP>(Factor)) { | |
1635 | if (CF->isNegative()) { | |
1636 | APFloat F(CF->getValueAPF()); | |
1637 | F.changeSign(); | |
1638 | Factor = ConstantFP::get(CF->getContext(), F); | |
1639 | assert(!Duplicates.count(Factor) && | |
1640 | "Shouldn't have two constant factors, missed a canonicalize"); | |
1641 | unsigned Occ = ++FactorOccurrences[Factor]; | |
1642 | if (Occ > MaxOcc) { | |
1643 | MaxOcc = Occ; | |
1644 | MaxOccVal = Factor; | |
1645 | } | |
223e47cc | 1646 | } |
1a4d82fc | 1647 | } |
223e47cc LB |
1648 | } |
1649 | } | |
1650 | ||
1651 | // If any factor occurred more than one time, we can pull it out. | |
1652 | if (MaxOcc > 1) { | |
85aaf69f | 1653 | DEBUG(dbgs() << "\nFACTORING [" << MaxOcc << "]: " << *MaxOccVal << '\n'); |
223e47cc LB |
1654 | ++NumFactor; |
1655 | ||
1656 | // Create a new instruction that uses the MaxOccVal twice. If we don't do | |
1657 | // this, we could otherwise run into situations where removing a factor | |
1658 | // from an expression will drop a use of maxocc, and this can cause | |
1659 | // RemoveFactorFromExpression on successive values to behave differently. | |
1a4d82fc JJ |
1660 | Instruction *DummyInst = |
1661 | I->getType()->isIntegerTy() | |
1662 | ? BinaryOperator::CreateAdd(MaxOccVal, MaxOccVal) | |
1663 | : BinaryOperator::CreateFAdd(MaxOccVal, MaxOccVal); | |
1664 | ||
223e47cc LB |
1665 | SmallVector<WeakVH, 4> NewMulOps; |
1666 | for (unsigned i = 0; i != Ops.size(); ++i) { | |
1667 | // Only try to remove factors from expressions we're allowed to. | |
1a4d82fc JJ |
1668 | BinaryOperator *BOp = |
1669 | isReassociableOp(Ops[i].Op, Instruction::Mul, Instruction::FMul); | |
223e47cc LB |
1670 | if (!BOp) |
1671 | continue; | |
1672 | ||
1673 | if (Value *V = RemoveFactorFromExpression(Ops[i].Op, MaxOccVal)) { | |
1674 | // The factorized operand may occur several times. Convert them all in | |
1675 | // one fell swoop. | |
1676 | for (unsigned j = Ops.size(); j != i;) { | |
1677 | --j; | |
1678 | if (Ops[j].Op == Ops[i].Op) { | |
1679 | NewMulOps.push_back(V); | |
1680 | Ops.erase(Ops.begin()+j); | |
1681 | } | |
1682 | } | |
1683 | --i; | |
1684 | } | |
1685 | } | |
1686 | ||
1687 | // No need for extra uses anymore. | |
1688 | delete DummyInst; | |
1689 | ||
1690 | unsigned NumAddedValues = NewMulOps.size(); | |
1691 | Value *V = EmitAddTreeOfValues(I, NewMulOps); | |
1692 | ||
1693 | // Now that we have inserted the add tree, optimize it. This allows us to | |
1694 | // handle cases that require multiple factoring steps, such as this: | |
1695 | // A*A*B + A*A*C --> A*(A*B+A*C) --> A*(A*(B+C)) | |
1696 | assert(NumAddedValues > 1 && "Each occurrence should contribute a value"); | |
1697 | (void)NumAddedValues; | |
1698 | if (Instruction *VI = dyn_cast<Instruction>(V)) | |
1699 | RedoInsts.insert(VI); | |
1700 | ||
1701 | // Create the multiply. | |
1a4d82fc | 1702 | Instruction *V2 = CreateMul(V, MaxOccVal, "tmp", I, I); |
223e47cc LB |
1703 | |
1704 | // Rerun associate on the multiply in case the inner expression turned into | |
1705 | // a multiply. We want to make sure that we keep things in canonical form. | |
1706 | RedoInsts.insert(V2); | |
1707 | ||
1708 | // If every add operand included the factor (e.g. "A*B + A*C"), then the | |
1709 | // entire result expression is just the multiply "A*(B+C)". | |
1710 | if (Ops.empty()) | |
1711 | return V2; | |
1712 | ||
1713 | // Otherwise, we had some input that didn't have the factor, such as | |
1714 | // "A*B + A*C + D" -> "A*(B+C) + D". Add the new multiply to the list of | |
1715 | // things being added by this operation. | |
1716 | Ops.insert(Ops.begin(), ValueEntry(getRank(V2), V2)); | |
1717 | } | |
1718 | ||
1a4d82fc | 1719 | return nullptr; |
223e47cc LB |
1720 | } |
1721 | ||
1722 | /// \brief Build up a vector of value/power pairs factoring a product. | |
1723 | /// | |
1724 | /// Given a series of multiplication operands, build a vector of factors and | |
1725 | /// the powers each is raised to when forming the final product. Sort them in | |
1726 | /// the order of descending power. | |
1727 | /// | |
1728 | /// (x*x) -> [(x, 2)] | |
1729 | /// ((x*x)*x) -> [(x, 3)] | |
1730 | /// ((((x*y)*x)*y)*x) -> [(x, 3), (y, 2)] | |
1731 | /// | |
1732 | /// \returns Whether any factors have a power greater than one. | |
1733 | bool Reassociate::collectMultiplyFactors(SmallVectorImpl<ValueEntry> &Ops, | |
1734 | SmallVectorImpl<Factor> &Factors) { | |
1735 | // FIXME: Have Ops be (ValueEntry, Multiplicity) pairs, simplifying this. | |
1736 | // Compute the sum of powers of simplifiable factors. | |
1737 | unsigned FactorPowerSum = 0; | |
1738 | for (unsigned Idx = 1, Size = Ops.size(); Idx < Size; ++Idx) { | |
1739 | Value *Op = Ops[Idx-1].Op; | |
1740 | ||
1741 | // Count the number of occurrences of this value. | |
1742 | unsigned Count = 1; | |
1743 | for (; Idx < Size && Ops[Idx].Op == Op; ++Idx) | |
1744 | ++Count; | |
1745 | // Track for simplification all factors which occur 2 or more times. | |
1746 | if (Count > 1) | |
1747 | FactorPowerSum += Count; | |
1748 | } | |
1749 | ||
1750 | // We can only simplify factors if the sum of the powers of our simplifiable | |
1751 | // factors is 4 or higher. When that is the case, we will *always* have | |
1752 | // a simplification. This is an important invariant to prevent cyclicly | |
1753 | // trying to simplify already minimal formations. | |
1754 | if (FactorPowerSum < 4) | |
1755 | return false; | |
1756 | ||
1757 | // Now gather the simplifiable factors, removing them from Ops. | |
1758 | FactorPowerSum = 0; | |
1759 | for (unsigned Idx = 1; Idx < Ops.size(); ++Idx) { | |
1760 | Value *Op = Ops[Idx-1].Op; | |
1761 | ||
1762 | // Count the number of occurrences of this value. | |
1763 | unsigned Count = 1; | |
1764 | for (; Idx < Ops.size() && Ops[Idx].Op == Op; ++Idx) | |
1765 | ++Count; | |
1766 | if (Count == 1) | |
1767 | continue; | |
1768 | // Move an even number of occurrences to Factors. | |
1769 | Count &= ~1U; | |
1770 | Idx -= Count; | |
1771 | FactorPowerSum += Count; | |
1772 | Factors.push_back(Factor(Op, Count)); | |
1773 | Ops.erase(Ops.begin()+Idx, Ops.begin()+Idx+Count); | |
1774 | } | |
1775 | ||
1776 | // None of the adjustments above should have reduced the sum of factor powers | |
1777 | // below our mininum of '4'. | |
1778 | assert(FactorPowerSum >= 4); | |
1779 | ||
1a4d82fc | 1780 | std::stable_sort(Factors.begin(), Factors.end(), Factor::PowerDescendingSorter()); |
223e47cc LB |
1781 | return true; |
1782 | } | |
1783 | ||
1784 | /// \brief Build a tree of multiplies, computing the product of Ops. | |
1785 | static Value *buildMultiplyTree(IRBuilder<> &Builder, | |
1786 | SmallVectorImpl<Value*> &Ops) { | |
1787 | if (Ops.size() == 1) | |
1788 | return Ops.back(); | |
1789 | ||
1790 | Value *LHS = Ops.pop_back_val(); | |
1791 | do { | |
1a4d82fc JJ |
1792 | if (LHS->getType()->isIntegerTy()) |
1793 | LHS = Builder.CreateMul(LHS, Ops.pop_back_val()); | |
1794 | else | |
1795 | LHS = Builder.CreateFMul(LHS, Ops.pop_back_val()); | |
223e47cc LB |
1796 | } while (!Ops.empty()); |
1797 | ||
1798 | return LHS; | |
1799 | } | |
1800 | ||
1801 | /// \brief Build a minimal multiplication DAG for (a^x)*(b^y)*(c^z)*... | |
1802 | /// | |
1803 | /// Given a vector of values raised to various powers, where no two values are | |
1804 | /// equal and the powers are sorted in decreasing order, compute the minimal | |
1805 | /// DAG of multiplies to compute the final product, and return that product | |
1806 | /// value. | |
1807 | Value *Reassociate::buildMinimalMultiplyDAG(IRBuilder<> &Builder, | |
1808 | SmallVectorImpl<Factor> &Factors) { | |
1809 | assert(Factors[0].Power); | |
1810 | SmallVector<Value *, 4> OuterProduct; | |
1811 | for (unsigned LastIdx = 0, Idx = 1, Size = Factors.size(); | |
1812 | Idx < Size && Factors[Idx].Power > 0; ++Idx) { | |
1813 | if (Factors[Idx].Power != Factors[LastIdx].Power) { | |
1814 | LastIdx = Idx; | |
1815 | continue; | |
1816 | } | |
1817 | ||
1818 | // We want to multiply across all the factors with the same power so that | |
1819 | // we can raise them to that power as a single entity. Build a mini tree | |
1820 | // for that. | |
1821 | SmallVector<Value *, 4> InnerProduct; | |
1822 | InnerProduct.push_back(Factors[LastIdx].Base); | |
1823 | do { | |
1824 | InnerProduct.push_back(Factors[Idx].Base); | |
1825 | ++Idx; | |
1826 | } while (Idx < Size && Factors[Idx].Power == Factors[LastIdx].Power); | |
1827 | ||
1828 | // Reset the base value of the first factor to the new expression tree. | |
1829 | // We'll remove all the factors with the same power in a second pass. | |
1830 | Value *M = Factors[LastIdx].Base = buildMultiplyTree(Builder, InnerProduct); | |
1831 | if (Instruction *MI = dyn_cast<Instruction>(M)) | |
1832 | RedoInsts.insert(MI); | |
1833 | ||
1834 | LastIdx = Idx; | |
1835 | } | |
1836 | // Unique factors with equal powers -- we've folded them into the first one's | |
1837 | // base. | |
1838 | Factors.erase(std::unique(Factors.begin(), Factors.end(), | |
1839 | Factor::PowerEqual()), | |
1840 | Factors.end()); | |
1841 | ||
1842 | // Iteratively collect the base of each factor with an add power into the | |
1843 | // outer product, and halve each power in preparation for squaring the | |
1844 | // expression. | |
1845 | for (unsigned Idx = 0, Size = Factors.size(); Idx != Size; ++Idx) { | |
1846 | if (Factors[Idx].Power & 1) | |
1847 | OuterProduct.push_back(Factors[Idx].Base); | |
1848 | Factors[Idx].Power >>= 1; | |
1849 | } | |
1850 | if (Factors[0].Power) { | |
1851 | Value *SquareRoot = buildMinimalMultiplyDAG(Builder, Factors); | |
1852 | OuterProduct.push_back(SquareRoot); | |
1853 | OuterProduct.push_back(SquareRoot); | |
1854 | } | |
1855 | if (OuterProduct.size() == 1) | |
1856 | return OuterProduct.front(); | |
1857 | ||
1858 | Value *V = buildMultiplyTree(Builder, OuterProduct); | |
1859 | return V; | |
1860 | } | |
1861 | ||
1862 | Value *Reassociate::OptimizeMul(BinaryOperator *I, | |
1863 | SmallVectorImpl<ValueEntry> &Ops) { | |
1864 | // We can only optimize the multiplies when there is a chain of more than | |
1865 | // three, such that a balanced tree might require fewer total multiplies. | |
1866 | if (Ops.size() < 4) | |
1a4d82fc | 1867 | return nullptr; |
223e47cc LB |
1868 | |
1869 | // Try to turn linear trees of multiplies without other uses of the | |
1870 | // intermediate stages into minimal multiply DAGs with perfect sub-expression | |
1871 | // re-use. | |
1872 | SmallVector<Factor, 4> Factors; | |
1873 | if (!collectMultiplyFactors(Ops, Factors)) | |
1a4d82fc | 1874 | return nullptr; // All distinct factors, so nothing left for us to do. |
223e47cc LB |
1875 | |
1876 | IRBuilder<> Builder(I); | |
1877 | Value *V = buildMinimalMultiplyDAG(Builder, Factors); | |
1878 | if (Ops.empty()) | |
1879 | return V; | |
1880 | ||
1881 | ValueEntry NewEntry = ValueEntry(getRank(V), V); | |
1882 | Ops.insert(std::lower_bound(Ops.begin(), Ops.end(), NewEntry), NewEntry); | |
1a4d82fc | 1883 | return nullptr; |
223e47cc LB |
1884 | } |
1885 | ||
1886 | Value *Reassociate::OptimizeExpression(BinaryOperator *I, | |
1887 | SmallVectorImpl<ValueEntry> &Ops) { | |
1888 | // Now that we have the linearized expression tree, try to optimize it. | |
1889 | // Start by folding any constants that we found. | |
1a4d82fc | 1890 | Constant *Cst = nullptr; |
223e47cc | 1891 | unsigned Opcode = I->getOpcode(); |
970d7e83 LB |
1892 | while (!Ops.empty() && isa<Constant>(Ops.back().Op)) { |
1893 | Constant *C = cast<Constant>(Ops.pop_back_val().Op); | |
1894 | Cst = Cst ? ConstantExpr::get(Opcode, C, Cst) : C; | |
1895 | } | |
1896 | // If there was nothing but constants then we are done. | |
1897 | if (Ops.empty()) | |
1898 | return Cst; | |
1899 | ||
1900 | // Put the combined constant back at the end of the operand list, except if | |
1901 | // there is no point. For example, an add of 0 gets dropped here, while a | |
1902 | // multiplication by zero turns the whole expression into zero. | |
1903 | if (Cst && Cst != ConstantExpr::getBinOpIdentity(Opcode, I->getType())) { | |
1904 | if (Cst == ConstantExpr::getBinOpAbsorber(Opcode, I->getType())) | |
1905 | return Cst; | |
1906 | Ops.push_back(ValueEntry(0, Cst)); | |
1907 | } | |
1908 | ||
1909 | if (Ops.size() == 1) return Ops[0].Op; | |
223e47cc LB |
1910 | |
1911 | // Handle destructive annihilation due to identities between elements in the | |
1912 | // argument list here. | |
1913 | unsigned NumOps = Ops.size(); | |
1914 | switch (Opcode) { | |
1915 | default: break; | |
1916 | case Instruction::And: | |
1917 | case Instruction::Or: | |
223e47cc LB |
1918 | if (Value *Result = OptimizeAndOrXor(Opcode, Ops)) |
1919 | return Result; | |
1920 | break; | |
1921 | ||
1a4d82fc JJ |
1922 | case Instruction::Xor: |
1923 | if (Value *Result = OptimizeXor(I, Ops)) | |
1924 | return Result; | |
1925 | break; | |
1926 | ||
223e47cc | 1927 | case Instruction::Add: |
1a4d82fc | 1928 | case Instruction::FAdd: |
223e47cc LB |
1929 | if (Value *Result = OptimizeAdd(I, Ops)) |
1930 | return Result; | |
1931 | break; | |
1932 | ||
1933 | case Instruction::Mul: | |
1a4d82fc | 1934 | case Instruction::FMul: |
223e47cc LB |
1935 | if (Value *Result = OptimizeMul(I, Ops)) |
1936 | return Result; | |
1937 | break; | |
1938 | } | |
1939 | ||
1940 | if (Ops.size() != NumOps) | |
1941 | return OptimizeExpression(I, Ops); | |
1a4d82fc | 1942 | return nullptr; |
223e47cc LB |
1943 | } |
1944 | ||
1945 | /// EraseInst - Zap the given instruction, adding interesting operands to the | |
1946 | /// work list. | |
1947 | void Reassociate::EraseInst(Instruction *I) { | |
1948 | assert(isInstructionTriviallyDead(I) && "Trivially dead instructions only!"); | |
1949 | SmallVector<Value*, 8> Ops(I->op_begin(), I->op_end()); | |
1950 | // Erase the dead instruction. | |
1951 | ValueRankMap.erase(I); | |
1952 | RedoInsts.remove(I); | |
1953 | I->eraseFromParent(); | |
1954 | // Optimize its operands. | |
1955 | SmallPtrSet<Instruction *, 8> Visited; // Detect self-referential nodes. | |
1956 | for (unsigned i = 0, e = Ops.size(); i != e; ++i) | |
1957 | if (Instruction *Op = dyn_cast<Instruction>(Ops[i])) { | |
1958 | // If this is a node in an expression tree, climb to the expression root | |
1959 | // and add that since that's where optimization actually happens. | |
1960 | unsigned Opcode = Op->getOpcode(); | |
1a4d82fc | 1961 | while (Op->hasOneUse() && Op->user_back()->getOpcode() == Opcode && |
85aaf69f | 1962 | Visited.insert(Op).second) |
1a4d82fc | 1963 | Op = Op->user_back(); |
223e47cc LB |
1964 | RedoInsts.insert(Op); |
1965 | } | |
1966 | } | |
1967 | ||
85aaf69f SL |
1968 | // Canonicalize expressions of the following form: |
1969 | // x + (-Constant * y) -> x - (Constant * y) | |
1970 | // x - (-Constant * y) -> x + (Constant * y) | |
1971 | Instruction *Reassociate::canonicalizeNegConstExpr(Instruction *I) { | |
1972 | if (!I->hasOneUse() || I->getType()->isVectorTy()) | |
1973 | return nullptr; | |
1974 | ||
1975 | // Must be a mul, fmul, or fdiv instruction. | |
1976 | unsigned Opcode = I->getOpcode(); | |
1977 | if (Opcode != Instruction::Mul && Opcode != Instruction::FMul && | |
1978 | Opcode != Instruction::FDiv) | |
1979 | return nullptr; | |
1980 | ||
1981 | // Must have at least one constant operand. | |
1982 | Constant *C0 = dyn_cast<Constant>(I->getOperand(0)); | |
1983 | Constant *C1 = dyn_cast<Constant>(I->getOperand(1)); | |
1984 | if (!C0 && !C1) | |
1985 | return nullptr; | |
1986 | ||
1987 | // Must be a negative ConstantInt or ConstantFP. | |
1988 | Constant *C = C0 ? C0 : C1; | |
1989 | unsigned ConstIdx = C0 ? 0 : 1; | |
1990 | if (auto *CI = dyn_cast<ConstantInt>(C)) { | |
1991 | if (!CI->isNegative()) | |
1992 | return nullptr; | |
1993 | } else if (auto *CF = dyn_cast<ConstantFP>(C)) { | |
1994 | if (!CF->isNegative()) | |
1995 | return nullptr; | |
1996 | } else | |
1997 | return nullptr; | |
1998 | ||
1999 | // User must be a binary operator with one or more uses. | |
2000 | Instruction *User = I->user_back(); | |
2001 | if (!isa<BinaryOperator>(User) || !User->getNumUses()) | |
2002 | return nullptr; | |
2003 | ||
2004 | unsigned UserOpcode = User->getOpcode(); | |
2005 | if (UserOpcode != Instruction::Add && UserOpcode != Instruction::FAdd && | |
2006 | UserOpcode != Instruction::Sub && UserOpcode != Instruction::FSub) | |
2007 | return nullptr; | |
2008 | ||
2009 | // Subtraction is not commutative. Explicitly, the following transform is | |
2010 | // not valid: (-Constant * y) - x -> x + (Constant * y) | |
2011 | if (!User->isCommutative() && User->getOperand(1) != I) | |
2012 | return nullptr; | |
2013 | ||
1a4d82fc | 2014 | // Change the sign of the constant. |
85aaf69f SL |
2015 | if (ConstantInt *CI = dyn_cast<ConstantInt>(C)) |
2016 | I->setOperand(ConstIdx, ConstantInt::get(CI->getContext(), -CI->getValue())); | |
2017 | else { | |
2018 | ConstantFP *CF = cast<ConstantFP>(C); | |
2019 | APFloat Val = CF->getValueAPF(); | |
2020 | Val.changeSign(); | |
2021 | I->setOperand(ConstIdx, ConstantFP::get(CF->getContext(), Val)); | |
2022 | } | |
2023 | ||
2024 | // Canonicalize I to RHS to simplify the next bit of logic. E.g., | |
2025 | // ((-Const*y) + x) -> (x + (-Const*y)). | |
2026 | if (User->getOperand(0) == I && User->isCommutative()) | |
2027 | cast<BinaryOperator>(User)->swapOperands(); | |
2028 | ||
2029 | Value *Op0 = User->getOperand(0); | |
2030 | Value *Op1 = User->getOperand(1); | |
2031 | BinaryOperator *NI; | |
2032 | switch(UserOpcode) { | |
2033 | default: | |
2034 | llvm_unreachable("Unexpected Opcode!"); | |
2035 | case Instruction::Add: | |
2036 | NI = BinaryOperator::CreateSub(Op0, Op1); | |
2037 | break; | |
2038 | case Instruction::Sub: | |
2039 | NI = BinaryOperator::CreateAdd(Op0, Op1); | |
2040 | break; | |
2041 | case Instruction::FAdd: | |
2042 | NI = BinaryOperator::CreateFSub(Op0, Op1); | |
2043 | NI->setFastMathFlags(cast<FPMathOperator>(User)->getFastMathFlags()); | |
2044 | break; | |
2045 | case Instruction::FSub: | |
2046 | NI = BinaryOperator::CreateFAdd(Op0, Op1); | |
2047 | NI->setFastMathFlags(cast<FPMathOperator>(User)->getFastMathFlags()); | |
2048 | break; | |
2049 | } | |
2050 | ||
2051 | NI->insertBefore(User); | |
2052 | NI->setName(User->getName()); | |
2053 | User->replaceAllUsesWith(NI); | |
1a4d82fc | 2054 | NI->setDebugLoc(I->getDebugLoc()); |
85aaf69f | 2055 | RedoInsts.insert(I); |
1a4d82fc | 2056 | MadeChange = true; |
85aaf69f | 2057 | return NI; |
1a4d82fc JJ |
2058 | } |
2059 | ||
223e47cc LB |
2060 | /// OptimizeInst - Inspect and optimize the given instruction. Note that erasing |
2061 | /// instructions is not allowed. | |
2062 | void Reassociate::OptimizeInst(Instruction *I) { | |
2063 | // Only consider operations that we understand. | |
2064 | if (!isa<BinaryOperator>(I)) | |
2065 | return; | |
2066 | ||
1a4d82fc | 2067 | if (I->getOpcode() == Instruction::Shl && isa<ConstantInt>(I->getOperand(1))) |
223e47cc LB |
2068 | // If an operand of this shift is a reassociable multiply, or if the shift |
2069 | // is used by a reassociable multiply or add, turn into a multiply. | |
2070 | if (isReassociableOp(I->getOperand(0), Instruction::Mul) || | |
2071 | (I->hasOneUse() && | |
1a4d82fc JJ |
2072 | (isReassociableOp(I->user_back(), Instruction::Mul) || |
2073 | isReassociableOp(I->user_back(), Instruction::Add)))) { | |
223e47cc LB |
2074 | Instruction *NI = ConvertShiftToMul(I); |
2075 | RedoInsts.insert(I); | |
2076 | MadeChange = true; | |
2077 | I = NI; | |
2078 | } | |
2079 | ||
85aaf69f SL |
2080 | // Canonicalize negative constants out of expressions. |
2081 | if (Instruction *Res = canonicalizeNegConstExpr(I)) | |
2082 | I = Res; | |
223e47cc | 2083 | |
85aaf69f SL |
2084 | // Commute binary operators, to canonicalize the order of their operands. |
2085 | // This can potentially expose more CSE opportunities, and makes writing other | |
2086 | // transformations simpler. | |
2087 | if (I->isCommutative()) | |
2088 | canonicalizeOperands(I); | |
223e47cc | 2089 | |
85aaf69f SL |
2090 | // Don't optimize vector instructions. |
2091 | if (I->getType()->isVectorTy()) | |
2092 | return; | |
1a4d82fc | 2093 | |
85aaf69f SL |
2094 | // Don't optimize floating point instructions that don't have unsafe algebra. |
2095 | if (I->getType()->isFloatingPointTy() && !I->hasUnsafeAlgebra()) | |
2096 | return; | |
223e47cc LB |
2097 | |
2098 | // Do not reassociate boolean (i1) expressions. We want to preserve the | |
2099 | // original order of evaluation for short-circuited comparisons that | |
2100 | // SimplifyCFG has folded to AND/OR expressions. If the expression | |
2101 | // is not further optimized, it is likely to be transformed back to a | |
2102 | // short-circuited form for code gen, and the source order may have been | |
2103 | // optimized for the most likely conditions. | |
2104 | if (I->getType()->isIntegerTy(1)) | |
2105 | return; | |
2106 | ||
2107 | // If this is a subtract instruction which is not already in negate form, | |
2108 | // see if we can convert it to X+-Y. | |
2109 | if (I->getOpcode() == Instruction::Sub) { | |
2110 | if (ShouldBreakUpSubtract(I)) { | |
2111 | Instruction *NI = BreakUpSubtract(I); | |
2112 | RedoInsts.insert(I); | |
2113 | MadeChange = true; | |
2114 | I = NI; | |
2115 | } else if (BinaryOperator::isNeg(I)) { | |
2116 | // Otherwise, this is a negation. See if the operand is a multiply tree | |
2117 | // and if this is not an inner node of a multiply tree. | |
2118 | if (isReassociableOp(I->getOperand(1), Instruction::Mul) && | |
2119 | (!I->hasOneUse() || | |
1a4d82fc JJ |
2120 | !isReassociableOp(I->user_back(), Instruction::Mul))) { |
2121 | Instruction *NI = LowerNegateToMultiply(I); | |
2122 | RedoInsts.insert(I); | |
2123 | MadeChange = true; | |
2124 | I = NI; | |
2125 | } | |
2126 | } | |
2127 | } else if (I->getOpcode() == Instruction::FSub) { | |
2128 | if (ShouldBreakUpSubtract(I)) { | |
2129 | Instruction *NI = BreakUpSubtract(I); | |
2130 | RedoInsts.insert(I); | |
2131 | MadeChange = true; | |
2132 | I = NI; | |
2133 | } else if (BinaryOperator::isFNeg(I)) { | |
2134 | // Otherwise, this is a negation. See if the operand is a multiply tree | |
2135 | // and if this is not an inner node of a multiply tree. | |
2136 | if (isReassociableOp(I->getOperand(1), Instruction::FMul) && | |
2137 | (!I->hasOneUse() || | |
2138 | !isReassociableOp(I->user_back(), Instruction::FMul))) { | |
223e47cc LB |
2139 | Instruction *NI = LowerNegateToMultiply(I); |
2140 | RedoInsts.insert(I); | |
2141 | MadeChange = true; | |
2142 | I = NI; | |
2143 | } | |
2144 | } | |
2145 | } | |
2146 | ||
2147 | // If this instruction is an associative binary operator, process it. | |
2148 | if (!I->isAssociative()) return; | |
2149 | BinaryOperator *BO = cast<BinaryOperator>(I); | |
2150 | ||
2151 | // If this is an interior node of a reassociable tree, ignore it until we | |
2152 | // get to the root of the tree, to avoid N^2 analysis. | |
2153 | unsigned Opcode = BO->getOpcode(); | |
1a4d82fc | 2154 | if (BO->hasOneUse() && BO->user_back()->getOpcode() == Opcode) |
223e47cc LB |
2155 | return; |
2156 | ||
2157 | // If this is an add tree that is used by a sub instruction, ignore it | |
2158 | // until we process the subtract. | |
2159 | if (BO->hasOneUse() && BO->getOpcode() == Instruction::Add && | |
1a4d82fc JJ |
2160 | cast<Instruction>(BO->user_back())->getOpcode() == Instruction::Sub) |
2161 | return; | |
2162 | if (BO->hasOneUse() && BO->getOpcode() == Instruction::FAdd && | |
2163 | cast<Instruction>(BO->user_back())->getOpcode() == Instruction::FSub) | |
223e47cc LB |
2164 | return; |
2165 | ||
2166 | ReassociateExpression(BO); | |
2167 | } | |
2168 | ||
2169 | void Reassociate::ReassociateExpression(BinaryOperator *I) { | |
1a4d82fc JJ |
2170 | assert(!I->getType()->isVectorTy() && |
2171 | "Reassociation of vector instructions is not supported."); | |
223e47cc LB |
2172 | |
2173 | // First, walk the expression tree, linearizing the tree, collecting the | |
2174 | // operand information. | |
2175 | SmallVector<RepeatedValue, 8> Tree; | |
2176 | MadeChange |= LinearizeExprTree(I, Tree); | |
2177 | SmallVector<ValueEntry, 8> Ops; | |
2178 | Ops.reserve(Tree.size()); | |
2179 | for (unsigned i = 0, e = Tree.size(); i != e; ++i) { | |
2180 | RepeatedValue E = Tree[i]; | |
2181 | Ops.append(E.second.getZExtValue(), | |
2182 | ValueEntry(getRank(E.first), E.first)); | |
2183 | } | |
2184 | ||
2185 | DEBUG(dbgs() << "RAIn:\t"; PrintOps(I, Ops); dbgs() << '\n'); | |
2186 | ||
2187 | // Now that we have linearized the tree to a list and have gathered all of | |
2188 | // the operands and their ranks, sort the operands by their rank. Use a | |
2189 | // stable_sort so that values with equal ranks will have their relative | |
2190 | // positions maintained (and so the compiler is deterministic). Note that | |
2191 | // this sorts so that the highest ranking values end up at the beginning of | |
2192 | // the vector. | |
2193 | std::stable_sort(Ops.begin(), Ops.end()); | |
2194 | ||
2195 | // OptimizeExpression - Now that we have the expression tree in a convenient | |
2196 | // sorted form, optimize it globally if possible. | |
2197 | if (Value *V = OptimizeExpression(I, Ops)) { | |
2198 | if (V == I) | |
2199 | // Self-referential expression in unreachable code. | |
2200 | return; | |
2201 | // This expression tree simplified to something that isn't a tree, | |
2202 | // eliminate it. | |
2203 | DEBUG(dbgs() << "Reassoc to scalar: " << *V << '\n'); | |
2204 | I->replaceAllUsesWith(V); | |
2205 | if (Instruction *VI = dyn_cast<Instruction>(V)) | |
2206 | VI->setDebugLoc(I->getDebugLoc()); | |
2207 | RedoInsts.insert(I); | |
2208 | ++NumAnnihil; | |
2209 | return; | |
2210 | } | |
2211 | ||
2212 | // We want to sink immediates as deeply as possible except in the case where | |
2213 | // this is a multiply tree used only by an add, and the immediate is a -1. | |
2214 | // In this case we reassociate to put the negation on the outside so that we | |
2215 | // can fold the negation into the add: (-X)*Y + Z -> Z-X*Y | |
1a4d82fc JJ |
2216 | if (I->hasOneUse()) { |
2217 | if (I->getOpcode() == Instruction::Mul && | |
2218 | cast<Instruction>(I->user_back())->getOpcode() == Instruction::Add && | |
2219 | isa<ConstantInt>(Ops.back().Op) && | |
2220 | cast<ConstantInt>(Ops.back().Op)->isAllOnesValue()) { | |
2221 | ValueEntry Tmp = Ops.pop_back_val(); | |
2222 | Ops.insert(Ops.begin(), Tmp); | |
2223 | } else if (I->getOpcode() == Instruction::FMul && | |
2224 | cast<Instruction>(I->user_back())->getOpcode() == | |
2225 | Instruction::FAdd && | |
2226 | isa<ConstantFP>(Ops.back().Op) && | |
2227 | cast<ConstantFP>(Ops.back().Op)->isExactlyValue(-1.0)) { | |
2228 | ValueEntry Tmp = Ops.pop_back_val(); | |
2229 | Ops.insert(Ops.begin(), Tmp); | |
2230 | } | |
223e47cc LB |
2231 | } |
2232 | ||
2233 | DEBUG(dbgs() << "RAOut:\t"; PrintOps(I, Ops); dbgs() << '\n'); | |
2234 | ||
2235 | if (Ops.size() == 1) { | |
2236 | if (Ops[0].Op == I) | |
2237 | // Self-referential expression in unreachable code. | |
2238 | return; | |
2239 | ||
2240 | // This expression tree simplified to something that isn't a tree, | |
2241 | // eliminate it. | |
2242 | I->replaceAllUsesWith(Ops[0].Op); | |
2243 | if (Instruction *OI = dyn_cast<Instruction>(Ops[0].Op)) | |
2244 | OI->setDebugLoc(I->getDebugLoc()); | |
2245 | RedoInsts.insert(I); | |
2246 | return; | |
2247 | } | |
2248 | ||
2249 | // Now that we ordered and optimized the expressions, splat them back into | |
2250 | // the expression tree, removing any unneeded nodes. | |
2251 | RewriteExprTree(I, Ops); | |
2252 | } | |
2253 | ||
2254 | bool Reassociate::runOnFunction(Function &F) { | |
1a4d82fc JJ |
2255 | if (skipOptnoneFunction(F)) |
2256 | return false; | |
2257 | ||
223e47cc LB |
2258 | // Calculate the rank map for F |
2259 | BuildRankMap(F); | |
2260 | ||
2261 | MadeChange = false; | |
2262 | for (Function::iterator BI = F.begin(), BE = F.end(); BI != BE; ++BI) { | |
2263 | // Optimize every instruction in the basic block. | |
2264 | for (BasicBlock::iterator II = BI->begin(), IE = BI->end(); II != IE; ) | |
2265 | if (isInstructionTriviallyDead(II)) { | |
2266 | EraseInst(II++); | |
2267 | } else { | |
2268 | OptimizeInst(II); | |
2269 | assert(II->getParent() == BI && "Moved to a different block!"); | |
2270 | ++II; | |
2271 | } | |
2272 | ||
2273 | // If this produced extra instructions to optimize, handle them now. | |
2274 | while (!RedoInsts.empty()) { | |
2275 | Instruction *I = RedoInsts.pop_back_val(); | |
2276 | if (isInstructionTriviallyDead(I)) | |
2277 | EraseInst(I); | |
2278 | else | |
2279 | OptimizeInst(I); | |
2280 | } | |
2281 | } | |
2282 | ||
2283 | // We are done with the rank map. | |
2284 | RankMap.clear(); | |
2285 | ValueRankMap.clear(); | |
2286 | ||
2287 | return MadeChange; | |
2288 | } |