InstructionSimplify.cpp revision 8c5c6f0e090f91b6555cdd9d2eea238fff3befe6
19f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner//===- InstructionSimplify.cpp - Fold instruction operands ----------------===// 29f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner// 39f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner// The LLVM Compiler Infrastructure 49f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner// 59f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner// This file is distributed under the University of Illinois Open Source 69f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner// License. See LICENSE.TXT for details. 79f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner// 89f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner//===----------------------------------------------------------------------===// 99f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner// 109f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner// This file implements routines for folding instructions into simpler forms 114cd2ad15b43f21d641330b4b09961af08646445eDuncan Sands// that do not require creating new instructions. This does constant folding 124cd2ad15b43f21d641330b4b09961af08646445eDuncan Sands// ("add i32 1, 1" -> "2") but can also handle non-constant operands, either 134cd2ad15b43f21d641330b4b09961af08646445eDuncan Sands// returning a constant ("and i32 %x, 0" -> "0") or an already existing value 14ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands// ("and i32 %x, %x" -> "%x"). All operands are assumed to have already been 15ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands// simplified: This is usually true and assuming it simplifies the logic (if 16ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands// they have not been simplified then results are correct but maybe suboptimal). 179f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner// 189f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner//===----------------------------------------------------------------------===// 199f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 20a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands#define DEBUG_TYPE "instsimplify" 219f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner#include "llvm/Analysis/InstructionSimplify.h" 22d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/ADT/SetVector.h" 23d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/ADT/Statistic.h" 249f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner#include "llvm/Analysis/ConstantFolding.h" 251845009290e4d804ad377927bd8a08cca3036adcDuncan Sands#include "llvm/Analysis/Dominators.h" 26d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands#include "llvm/Analysis/ValueTracking.h" 27fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman#include "llvm/Analysis/MemoryBuiltins.h" 280b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/DataLayout.h" 290b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/GlobalAlias.h" 300b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Operator.h" 313a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky#include "llvm/Support/ConstantRange.h" 32fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth#include "llvm/Support/GetElementPtrTypeIterator.h" 33d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner#include "llvm/Support/PatternMatch.h" 341845009290e4d804ad377927bd8a08cca3036adcDuncan Sands#include "llvm/Support/ValueHandle.h" 359f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattnerusing namespace llvm; 36d06094f0682f2ede03caff4892b1a57469896d48Chris Lattnerusing namespace llvm::PatternMatch; 379f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 3881a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattnerenum { RecursionLimit = 3 }; 39a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 40a3c44a5280042dbc0cde995675c225ede4528c6eDuncan SandsSTATISTIC(NumExpand, "Number of expansions"); 41a3c44a5280042dbc0cde995675c225ede4528c6eDuncan SandsSTATISTIC(NumFactor , "Number of factorizations"); 42a3c44a5280042dbc0cde995675c225ede4528c6eDuncan SandsSTATISTIC(NumReassoc, "Number of reassociations"); 43a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands 440aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstruct Query { 453574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow const DataLayout *TD; 460aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const TargetLibraryInfo *TLI; 470aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const DominatorTree *DT; 480aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands 493574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow Query(const DataLayout *td, const TargetLibraryInfo *tli, 509133783d5483e38b16af6c10df7a8bbe655d3446Bill Wendling const DominatorTree *dt) : TD(td), TLI(tli), DT(dt) {} 510aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands}; 520aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands 530aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyAndInst(Value *, Value *, const Query &, unsigned); 540aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyBinOp(unsigned, Value *, Value *, const Query &, 55618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier unsigned); 560aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyCmpInst(unsigned, Value *, Value *, const Query &, 57618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier unsigned); 580aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyOrInst(Value *, Value *, const Query &, unsigned); 590aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyXorInst(Value *, Value *, const Query &, unsigned); 60bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sandsstatic Value *SimplifyTruncInst(Value *, Type *, const Query &, unsigned); 611845009290e4d804ad377927bd8a08cca3036adcDuncan Sands 62f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands/// getFalse - For a boolean type, or a vector of boolean type, return false, or 63f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands/// a vector with every element false, as appropriate for the type. 64f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sandsstatic Constant *getFalse(Type *Ty) { 6566d004ef708642bbdc38fd761507f2e9ee3970cdNick Lewycky assert(Ty->getScalarType()->isIntegerTy(1) && 66f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands "Expected i1 type or a vector of i1!"); 67f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return Constant::getNullValue(Ty); 68f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands} 69f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands 70f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands/// getTrue - For a boolean type, or a vector of boolean type, return true, or 71f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands/// a vector with every element true, as appropriate for the type. 72f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sandsstatic Constant *getTrue(Type *Ty) { 7366d004ef708642bbdc38fd761507f2e9ee3970cdNick Lewycky assert(Ty->getScalarType()->isIntegerTy(1) && 74f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands "Expected i1 type or a vector of i1!"); 75f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return Constant::getAllOnesValue(Ty); 76f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands} 77f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands 786dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands/// isSameCompare - Is V equivalent to the comparison "LHS Pred RHS"? 796dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sandsstatic bool isSameCompare(Value *V, CmpInst::Predicate Pred, Value *LHS, 806dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands Value *RHS) { 816dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands CmpInst *Cmp = dyn_cast<CmpInst>(V); 826dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (!Cmp) 836dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return false; 846dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands CmpInst::Predicate CPred = Cmp->getPredicate(); 856dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands Value *CLHS = Cmp->getOperand(0), *CRHS = Cmp->getOperand(1); 866dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (CPred == Pred && CLHS == LHS && CRHS == RHS) 876dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return true; 886dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return CPred == CmpInst::getSwappedPredicate(Pred) && CLHS == RHS && 896dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands CRHS == LHS; 906dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands} 916dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands 921845009290e4d804ad377927bd8a08cca3036adcDuncan Sands/// ValueDominatesPHI - Does the given value dominate the specified phi node? 931845009290e4d804ad377927bd8a08cca3036adcDuncan Sandsstatic bool ValueDominatesPHI(Value *V, PHINode *P, const DominatorTree *DT) { 941845009290e4d804ad377927bd8a08cca3036adcDuncan Sands Instruction *I = dyn_cast<Instruction>(V); 951845009290e4d804ad377927bd8a08cca3036adcDuncan Sands if (!I) 961845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // Arguments and constants dominate all instructions. 971845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return true; 981845009290e4d804ad377927bd8a08cca3036adcDuncan Sands 99ff739c1575df58f3926c2f3b6e00a6c45f773523Chandler Carruth // If we are processing instructions (and/or basic blocks) that have not been 100ff739c1575df58f3926c2f3b6e00a6c45f773523Chandler Carruth // fully added to a function, the parent nodes may still be null. Simply 101ff739c1575df58f3926c2f3b6e00a6c45f773523Chandler Carruth // return the conservative answer in these cases. 102ff739c1575df58f3926c2f3b6e00a6c45f773523Chandler Carruth if (!I->getParent() || !P->getParent() || !I->getParent()->getParent()) 103ff739c1575df58f3926c2f3b6e00a6c45f773523Chandler Carruth return false; 104ff739c1575df58f3926c2f3b6e00a6c45f773523Chandler Carruth 1051845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // If we have a DominatorTree then do a precise test. 1065b8f0ddc7e5bc3c7ffe1b2226a8316796f18b90eEli Friedman if (DT) { 1075b8f0ddc7e5bc3c7ffe1b2226a8316796f18b90eEli Friedman if (!DT->isReachableFromEntry(P->getParent())) 1085b8f0ddc7e5bc3c7ffe1b2226a8316796f18b90eEli Friedman return true; 1095b8f0ddc7e5bc3c7ffe1b2226a8316796f18b90eEli Friedman if (!DT->isReachableFromEntry(I->getParent())) 1105b8f0ddc7e5bc3c7ffe1b2226a8316796f18b90eEli Friedman return false; 1115b8f0ddc7e5bc3c7ffe1b2226a8316796f18b90eEli Friedman return DT->dominates(I, P); 1125b8f0ddc7e5bc3c7ffe1b2226a8316796f18b90eEli Friedman } 1131845009290e4d804ad377927bd8a08cca3036adcDuncan Sands 1141845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // Otherwise, if the instruction is in the entry block, and is not an invoke, 1151845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // then it obviously dominates all phi nodes. 1161845009290e4d804ad377927bd8a08cca3036adcDuncan Sands if (I->getParent() == &I->getParent()->getParent()->getEntryBlock() && 1171845009290e4d804ad377927bd8a08cca3036adcDuncan Sands !isa<InvokeInst>(I)) 1181845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return true; 1191845009290e4d804ad377927bd8a08cca3036adcDuncan Sands 1201845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return false; 1211845009290e4d804ad377927bd8a08cca3036adcDuncan Sands} 122a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 1233421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// ExpandBinOp - Simplify "A op (B op' C)" by distributing op over op', turning 1243421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// it into "(A op B) op' (A op C)". Here "op" is given by Opcode and "op'" is 1253421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// given by OpcodeToExpand, while "A" corresponds to LHS and "B op' C" to RHS. 1263421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// Also performs the transform "(A op' B) op C" -> "(A op C) op' (B op C)". 1273421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// Returns the simplified value, or null if no simplification was performed. 1283421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sandsstatic Value *ExpandBinOp(unsigned Opcode, Value *LHS, Value *RHS, 1290aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands unsigned OpcToExpand, const Query &Q, 130618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier unsigned MaxRecurse) { 131e21083aa3a79506f896d95d7147c3c4627a77ef0Benjamin Kramer Instruction::BinaryOps OpcodeToExpand = (Instruction::BinaryOps)OpcToExpand; 1323421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 1333421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (!MaxRecurse--) 1343421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return 0; 1353421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1363421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Check whether the expression has the form "(A op' B) op C". 1373421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (BinaryOperator *Op0 = dyn_cast<BinaryOperator>(LHS)) 1383421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Op0->getOpcode() == OpcodeToExpand) { 1393421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // It does! Try turning it into "(A op C) op' (B op C)". 1403421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands Value *A = Op0->getOperand(0), *B = Op0->getOperand(1), *C = RHS; 1413421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Do "A op C" and "B op C" both simplify? 1420aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *L = SimplifyBinOp(Opcode, A, C, Q, MaxRecurse)) 1430aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *R = SimplifyBinOp(Opcode, B, C, Q, MaxRecurse)) { 1443421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // They do! Return "L op' R" if it simplifies or is already available. 1453421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // If "L op' R" equals "A op' B" then "L op' R" is just the LHS. 146124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if ((L == A && R == B) || (Instruction::isCommutative(OpcodeToExpand) 147124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands && L == B && R == A)) { 148a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumExpand; 1493421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return LHS; 150a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 1513421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Otherwise return "L op' R" if it simplifies. 1520aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyBinOp(OpcodeToExpand, L, R, Q, MaxRecurse)) { 153a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumExpand; 1543421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 155a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 1563421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 1573421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 1583421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1593421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Check whether the expression has the form "A op (B op' C)". 1603421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (BinaryOperator *Op1 = dyn_cast<BinaryOperator>(RHS)) 1613421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Op1->getOpcode() == OpcodeToExpand) { 1623421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // It does! Try turning it into "(A op B) op' (A op C)". 1633421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands Value *A = LHS, *B = Op1->getOperand(0), *C = Op1->getOperand(1); 1643421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Do "A op B" and "A op C" both simplify? 1650aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *L = SimplifyBinOp(Opcode, A, B, Q, MaxRecurse)) 1660aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *R = SimplifyBinOp(Opcode, A, C, Q, MaxRecurse)) { 1673421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // They do! Return "L op' R" if it simplifies or is already available. 1683421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // If "L op' R" equals "B op' C" then "L op' R" is just the RHS. 169124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if ((L == B && R == C) || (Instruction::isCommutative(OpcodeToExpand) 170124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands && L == C && R == B)) { 171a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumExpand; 1723421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return RHS; 173a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 1743421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Otherwise return "L op' R" if it simplifies. 1750aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyBinOp(OpcodeToExpand, L, R, Q, MaxRecurse)) { 176a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumExpand; 1773421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 178a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 1793421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 1803421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 1813421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1823421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return 0; 1833421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands} 1843421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1853421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// FactorizeBinOp - Simplify "LHS Opcode RHS" by factorizing out a common term 1863421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// using the operation OpCodeToExtract. For example, when Opcode is Add and 1873421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// OpCodeToExtract is Mul then this tries to turn "(A*B)+(A*C)" into "A*(B+C)". 1883421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// Returns the simplified value, or null if no simplification was performed. 1893421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sandsstatic Value *FactorizeBinOp(unsigned Opcode, Value *LHS, Value *RHS, 1900aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands unsigned OpcToExtract, const Query &Q, 191618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier unsigned MaxRecurse) { 192e21083aa3a79506f896d95d7147c3c4627a77ef0Benjamin Kramer Instruction::BinaryOps OpcodeToExtract = (Instruction::BinaryOps)OpcToExtract; 1933421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 1943421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (!MaxRecurse--) 1953421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return 0; 1963421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1973421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands BinaryOperator *Op0 = dyn_cast<BinaryOperator>(LHS); 1983421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands BinaryOperator *Op1 = dyn_cast<BinaryOperator>(RHS); 1993421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 2003421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (!Op0 || Op0->getOpcode() != OpcodeToExtract || 2013421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands !Op1 || Op1->getOpcode() != OpcodeToExtract) 2023421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return 0; 2033421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 2043421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // The expression has the form "(A op' B) op (C op' D)". 20582fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands Value *A = Op0->getOperand(0), *B = Op0->getOperand(1); 20682fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands Value *C = Op1->getOperand(0), *D = Op1->getOperand(1); 2073421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 2083421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Use left distributivity, i.e. "X op' (Y op Z) = (X op' Y) op (X op' Z)". 2093421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Does the instruction have the form "(A op' B) op (A op' D)" or, in the 2103421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // commutative case, "(A op' B) op (C op' A)"? 211124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (A == C || (Instruction::isCommutative(OpcodeToExtract) && A == D)) { 212124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands Value *DD = A == C ? D : C; 2133421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Form "A op' (B op DD)" if it simplifies completely. 2143421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Does "B op DD" simplify? 2150aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyBinOp(Opcode, B, DD, Q, MaxRecurse)) { 2163421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // It does! Return "A op' V" if it simplifies or is already available. 2171cd05bb605e3c3eee9197d3f10b628c60d0cc07aDuncan Sands // If V equals B then "A op' V" is just the LHS. If V equals DD then 2181cd05bb605e3c3eee9197d3f10b628c60d0cc07aDuncan Sands // "A op' V" is just the RHS. 219124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (V == B || V == DD) { 220a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumFactor; 221124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands return V == B ? LHS : RHS; 222a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 2233421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Otherwise return "A op' V" if it simplifies. 2240aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *W = SimplifyBinOp(OpcodeToExtract, A, V, Q, MaxRecurse)) { 225a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumFactor; 2263421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return W; 227a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 2283421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 2293421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 2303421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 2313421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Use right distributivity, i.e. "(X op Y) op' Z = (X op' Z) op (Y op' Z)". 2323421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Does the instruction have the form "(A op' B) op (C op' B)" or, in the 2333421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // commutative case, "(A op' B) op (B op' D)"? 234124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (B == D || (Instruction::isCommutative(OpcodeToExtract) && B == C)) { 235124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands Value *CC = B == D ? C : D; 2363421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Form "(A op CC) op' B" if it simplifies completely.. 2373421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Does "A op CC" simplify? 2380aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyBinOp(Opcode, A, CC, Q, MaxRecurse)) { 2393421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // It does! Return "V op' B" if it simplifies or is already available. 2401cd05bb605e3c3eee9197d3f10b628c60d0cc07aDuncan Sands // If V equals A then "V op' B" is just the LHS. If V equals CC then 2411cd05bb605e3c3eee9197d3f10b628c60d0cc07aDuncan Sands // "V op' B" is just the RHS. 242124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (V == A || V == CC) { 243a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumFactor; 244124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands return V == A ? LHS : RHS; 245a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 2463421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Otherwise return "V op' B" if it simplifies. 2470aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *W = SimplifyBinOp(OpcodeToExtract, V, B, Q, MaxRecurse)) { 248a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumFactor; 2493421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return W; 250a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 2513421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 2523421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 2533421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 2543421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return 0; 2553421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands} 2563421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 2573421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// SimplifyAssociativeBinOp - Generic simplifications for associative binary 2583421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// operations. Returns the simpler value, or null if none was found. 259e21083aa3a79506f896d95d7147c3c4627a77ef0Benjamin Kramerstatic Value *SimplifyAssociativeBinOp(unsigned Opc, Value *LHS, Value *RHS, 2600aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 261e21083aa3a79506f896d95d7147c3c4627a77ef0Benjamin Kramer Instruction::BinaryOps Opcode = (Instruction::BinaryOps)Opc; 262566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands assert(Instruction::isAssociative(Opcode) && "Not an associative operation!"); 263566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 264566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 265566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (!MaxRecurse--) 266566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return 0; 267566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 268566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands BinaryOperator *Op0 = dyn_cast<BinaryOperator>(LHS); 269566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands BinaryOperator *Op1 = dyn_cast<BinaryOperator>(RHS); 270566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 271566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Transform: "(A op B) op C" ==> "A op (B op C)" if it simplifies completely. 272566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Op0 && Op0->getOpcode() == Opcode) { 273566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *A = Op0->getOperand(0); 274566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *B = Op0->getOperand(1); 275566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *C = RHS; 276566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 277566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Does "B op C" simplify? 2780aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyBinOp(Opcode, B, C, Q, MaxRecurse)) { 279566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // It does! Return "A op V" if it simplifies or is already available. 280566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // If V equals B then "A op V" is just the LHS. 281124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (V == B) return LHS; 282566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Otherwise return "A op V" if it simplifies. 2830aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *W = SimplifyBinOp(Opcode, A, V, Q, MaxRecurse)) { 284a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumReassoc; 285566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return W; 286a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 287566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 288566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 289566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 290566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Transform: "A op (B op C)" ==> "(A op B) op C" if it simplifies completely. 291566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Op1 && Op1->getOpcode() == Opcode) { 292566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *A = LHS; 293566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *B = Op1->getOperand(0); 294566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *C = Op1->getOperand(1); 295566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 296566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Does "A op B" simplify? 2970aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyBinOp(Opcode, A, B, Q, MaxRecurse)) { 298566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // It does! Return "V op C" if it simplifies or is already available. 299566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // If V equals B then "V op C" is just the RHS. 300124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (V == B) return RHS; 301566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Otherwise return "V op C" if it simplifies. 3020aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *W = SimplifyBinOp(Opcode, V, C, Q, MaxRecurse)) { 303a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumReassoc; 304566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return W; 305a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 306566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 307566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 308566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 309566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // The remaining transforms require commutativity as well as associativity. 310566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (!Instruction::isCommutative(Opcode)) 311566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return 0; 312566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 313566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Transform: "(A op B) op C" ==> "(C op A) op B" if it simplifies completely. 314566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Op0 && Op0->getOpcode() == Opcode) { 315566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *A = Op0->getOperand(0); 316566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *B = Op0->getOperand(1); 317566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *C = RHS; 318566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 319566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Does "C op A" simplify? 3200aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyBinOp(Opcode, C, A, Q, MaxRecurse)) { 321566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // It does! Return "V op B" if it simplifies or is already available. 322566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // If V equals A then "V op B" is just the LHS. 323124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (V == A) return LHS; 324566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Otherwise return "V op B" if it simplifies. 3250aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *W = SimplifyBinOp(Opcode, V, B, Q, MaxRecurse)) { 326a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumReassoc; 327566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return W; 328a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 329566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 330566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 331566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 332566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Transform: "A op (B op C)" ==> "B op (C op A)" if it simplifies completely. 333566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Op1 && Op1->getOpcode() == Opcode) { 334566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *A = LHS; 335566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *B = Op1->getOperand(0); 336566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *C = Op1->getOperand(1); 337566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 338566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Does "C op A" simplify? 3390aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyBinOp(Opcode, C, A, Q, MaxRecurse)) { 340566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // It does! Return "B op V" if it simplifies or is already available. 341566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // If V equals C then "B op V" is just the RHS. 342124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (V == C) return RHS; 343566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Otherwise return "B op V" if it simplifies. 3440aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *W = SimplifyBinOp(Opcode, B, V, Q, MaxRecurse)) { 345a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumReassoc; 346566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return W; 347a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 348566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 349566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 350566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 351566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return 0; 352566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands} 353566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 354b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// ThreadBinOpOverSelect - In the case of a binary operation with a select 355b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// instruction as an operand, try to simplify the binop by seeing whether 356b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// evaluating it on both branches of the select results in the same value. 357b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// Returns the common value if so, otherwise returns null. 358b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sandsstatic Value *ThreadBinOpOverSelect(unsigned Opcode, Value *LHS, Value *RHS, 3590aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 3600312a93693abc2eb682b2b101c889959888fd883Duncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 3610312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (!MaxRecurse--) 3620312a93693abc2eb682b2b101c889959888fd883Duncan Sands return 0; 3630312a93693abc2eb682b2b101c889959888fd883Duncan Sands 364b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands SelectInst *SI; 365b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (isa<SelectInst>(LHS)) { 366b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands SI = cast<SelectInst>(LHS); 367b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } else { 368b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands assert(isa<SelectInst>(RHS) && "No select instruction operand!"); 369b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands SI = cast<SelectInst>(RHS); 370b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } 371b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 372b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // Evaluate the BinOp on the true and false branches of the select. 373b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Value *TV; 374b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Value *FV; 375b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (SI == LHS) { 3760aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands TV = SimplifyBinOp(Opcode, SI->getTrueValue(), RHS, Q, MaxRecurse); 3770aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands FV = SimplifyBinOp(Opcode, SI->getFalseValue(), RHS, Q, MaxRecurse); 378b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } else { 3790aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands TV = SimplifyBinOp(Opcode, LHS, SI->getTrueValue(), Q, MaxRecurse); 3800aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands FV = SimplifyBinOp(Opcode, LHS, SI->getFalseValue(), Q, MaxRecurse); 381b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } 382b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 3837cf85e74e3885005ca8e5fdb155fa5351e255b85Duncan Sands // If they simplified to the same value, then return the common value. 384124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands // If they both failed to simplify then return null. 385124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (TV == FV) 386b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return TV; 387b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 388b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // If one branch simplified to undef, return the other one. 389b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (TV && isa<UndefValue>(TV)) 390b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return FV; 391b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (FV && isa<UndefValue>(FV)) 392b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return TV; 393b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 394b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // If applying the operation did not change the true and false select values, 395b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // then the result of the binop is the select itself. 396124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (TV == SI->getTrueValue() && FV == SI->getFalseValue()) 397b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return SI; 398b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 399b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // If one branch simplified and the other did not, and the simplified 400b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // value is equal to the unsimplified one, return the simplified value. 401b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // For example, select (cond, X, X & Z) & Z -> X & Z. 402b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if ((FV && !TV) || (TV && !FV)) { 403b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // Check that the simplified value has the form "X op Y" where "op" is the 404b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // same as the original operation. 405b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Instruction *Simplified = dyn_cast<Instruction>(FV ? FV : TV); 406b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (Simplified && Simplified->getOpcode() == Opcode) { 407b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // The value that didn't simplify is "UnsimplifiedLHS op UnsimplifiedRHS". 408b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // We already know that "op" is the same as for the simplified value. See 409b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // if the operands match too. If so, return the simplified value. 410b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Value *UnsimplifiedBranch = FV ? SI->getTrueValue() : SI->getFalseValue(); 411b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Value *UnsimplifiedLHS = SI == LHS ? UnsimplifiedBranch : LHS; 412b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Value *UnsimplifiedRHS = SI == LHS ? RHS : UnsimplifiedBranch; 413124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (Simplified->getOperand(0) == UnsimplifiedLHS && 414124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands Simplified->getOperand(1) == UnsimplifiedRHS) 415b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return Simplified; 416b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (Simplified->isCommutative() && 417124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands Simplified->getOperand(1) == UnsimplifiedLHS && 418124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands Simplified->getOperand(0) == UnsimplifiedRHS) 419b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return Simplified; 420b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } 421b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } 422b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 423b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return 0; 424b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands} 425b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 426b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// ThreadCmpOverSelect - In the case of a comparison with a select instruction, 427b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// try to simplify the comparison by seeing whether both branches of the select 428b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// result in the same value. Returns the common value if so, otherwise returns 429b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// null. 430b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sandsstatic Value *ThreadCmpOverSelect(CmpInst::Predicate Pred, Value *LHS, 4310aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Value *RHS, const Query &Q, 432a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands unsigned MaxRecurse) { 4330312a93693abc2eb682b2b101c889959888fd883Duncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 4340312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (!MaxRecurse--) 4350312a93693abc2eb682b2b101c889959888fd883Duncan Sands return 0; 4360312a93693abc2eb682b2b101c889959888fd883Duncan Sands 437b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // Make sure the select is on the LHS. 438b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (!isa<SelectInst>(LHS)) { 439b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands std::swap(LHS, RHS); 440b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Pred = CmpInst::getSwappedPredicate(Pred); 441b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } 442b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands assert(isa<SelectInst>(LHS) && "Not comparing with a select instruction!"); 443b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands SelectInst *SI = cast<SelectInst>(LHS); 4446dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands Value *Cond = SI->getCondition(); 4456dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands Value *TV = SI->getTrueValue(); 4466dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands Value *FV = SI->getFalseValue(); 447b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 44850ca4d37f7f3b460c6441eb5ad14625a7d86b5d9Duncan Sands // Now that we have "cmp select(Cond, TV, FV), RHS", analyse it. 449b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // Does "cmp TV, RHS" simplify? 4500aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Value *TCmp = SimplifyCmpInst(Pred, TV, RHS, Q, MaxRecurse); 4516dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (TCmp == Cond) { 4526dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // It not only simplified, it simplified to the select condition. Replace 4536dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // it with 'true'. 4546dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands TCmp = getTrue(Cond->getType()); 4556dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands } else if (!TCmp) { 4566dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // It didn't simplify. However if "cmp TV, RHS" is equal to the select 4576dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // condition then we can replace it with 'true'. Otherwise give up. 4586dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (!isSameCompare(Cond, Pred, TV, RHS)) 4596dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return 0; 4606dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands TCmp = getTrue(Cond->getType()); 46150ca4d37f7f3b460c6441eb5ad14625a7d86b5d9Duncan Sands } 46250ca4d37f7f3b460c6441eb5ad14625a7d86b5d9Duncan Sands 4636dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // Does "cmp FV, RHS" simplify? 4640aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Value *FCmp = SimplifyCmpInst(Pred, FV, RHS, Q, MaxRecurse); 4656dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (FCmp == Cond) { 4666dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // It not only simplified, it simplified to the select condition. Replace 4676dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // it with 'false'. 4686dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands FCmp = getFalse(Cond->getType()); 4696dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands } else if (!FCmp) { 4706dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // It didn't simplify. However if "cmp FV, RHS" is equal to the select 4716dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // condition then we can replace it with 'false'. Otherwise give up. 4726dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (!isSameCompare(Cond, Pred, FV, RHS)) 4736dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return 0; 4746dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands FCmp = getFalse(Cond->getType()); 4756dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands } 4766dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands 4776dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // If both sides simplified to the same value, then use it as the result of 4786dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // the original comparison. 4796dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (TCmp == FCmp) 4806dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return TCmp; 481aa97bb54f02784abefa0ae170af5937915bdb329Duncan Sands 482aa97bb54f02784abefa0ae170af5937915bdb329Duncan Sands // The remaining cases only make sense if the select condition has the same 483aa97bb54f02784abefa0ae170af5937915bdb329Duncan Sands // type as the result of the comparison, so bail out if this is not so. 484aa97bb54f02784abefa0ae170af5937915bdb329Duncan Sands if (Cond->getType()->isVectorTy() != RHS->getType()->isVectorTy()) 485aa97bb54f02784abefa0ae170af5937915bdb329Duncan Sands return 0; 4866dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // If the false value simplified to false, then the result of the compare 4876dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // is equal to "Cond && TCmp". This also catches the case when the false 4886dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // value simplified to false and the true value to true, returning "Cond". 4896dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (match(FCmp, m_Zero())) 4900aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyAndInst(Cond, TCmp, Q, MaxRecurse)) 4916dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return V; 4926dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // If the true value simplified to true, then the result of the compare 4936dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // is equal to "Cond || FCmp". 4946dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (match(TCmp, m_One())) 4950aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyOrInst(Cond, FCmp, Q, MaxRecurse)) 4966dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return V; 4976dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // Finally, if the false value simplified to true and the true value to 4986dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // false, then the result of the compare is equal to "!Cond". 4996dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (match(FCmp, m_One()) && match(TCmp, m_Zero())) 5006dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (Value *V = 5016dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands SimplifyXorInst(Cond, Constant::getAllOnesValue(Cond->getType()), 5020aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse)) 5036dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return V; 5046dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands 505b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return 0; 506b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands} 507b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 508a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// ThreadBinOpOverPHI - In the case of a binary operation with an operand that 509a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// is a PHI instruction, try to simplify the binop by seeing whether evaluating 510a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// it on the incoming phi values yields the same result for every value. If so 511a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// returns the common value, otherwise returns null. 512a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *ThreadBinOpOverPHI(unsigned Opcode, Value *LHS, Value *RHS, 5130aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 5140312a93693abc2eb682b2b101c889959888fd883Duncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 5150312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (!MaxRecurse--) 5160312a93693abc2eb682b2b101c889959888fd883Duncan Sands return 0; 5170312a93693abc2eb682b2b101c889959888fd883Duncan Sands 518a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands PHINode *PI; 519a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands if (isa<PHINode>(LHS)) { 520a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands PI = cast<PHINode>(LHS); 5211845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // Bail out if RHS and the phi may be mutually interdependent due to a loop. 5220aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (!ValueDominatesPHI(RHS, PI, Q.DT)) 5231845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return 0; 524a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands } else { 525a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands assert(isa<PHINode>(RHS) && "No PHI instruction operand!"); 526a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands PI = cast<PHINode>(RHS); 5271845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // Bail out if LHS and the phi may be mutually interdependent due to a loop. 5280aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (!ValueDominatesPHI(LHS, PI, Q.DT)) 5291845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return 0; 530a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands } 531a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 532a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // Evaluate the BinOp on the incoming phi values. 533a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands Value *CommonValue = 0; 534a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands for (unsigned i = 0, e = PI->getNumIncomingValues(); i != e; ++i) { 535552008946530e01efdad15044e1f621883d14a3aDuncan Sands Value *Incoming = PI->getIncomingValue(i); 536ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // If the incoming value is the phi node itself, it can safely be skipped. 537552008946530e01efdad15044e1f621883d14a3aDuncan Sands if (Incoming == PI) continue; 538a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands Value *V = PI == LHS ? 5390aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands SimplifyBinOp(Opcode, Incoming, RHS, Q, MaxRecurse) : 5400aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands SimplifyBinOp(Opcode, LHS, Incoming, Q, MaxRecurse); 541a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the operation failed to simplify, or simplified to a different value 542a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // to previously, then give up. 543a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands if (!V || (CommonValue && V != CommonValue)) 544a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return 0; 545a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands CommonValue = V; 546a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands } 547a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 548a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return CommonValue; 549a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 550a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 551a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// ThreadCmpOverPHI - In the case of a comparison with a PHI instruction, try 552a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// try to simplify the comparison by seeing whether comparing with all of the 553a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// incoming phi values yields the same result every time. If so returns the 554a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// common result, otherwise returns null. 555a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *ThreadCmpOverPHI(CmpInst::Predicate Pred, Value *LHS, Value *RHS, 5560aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 5570312a93693abc2eb682b2b101c889959888fd883Duncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 5580312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (!MaxRecurse--) 5590312a93693abc2eb682b2b101c889959888fd883Duncan Sands return 0; 5600312a93693abc2eb682b2b101c889959888fd883Duncan Sands 561a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // Make sure the phi is on the LHS. 562a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands if (!isa<PHINode>(LHS)) { 563a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands std::swap(LHS, RHS); 564a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands Pred = CmpInst::getSwappedPredicate(Pred); 565a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands } 566a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands assert(isa<PHINode>(LHS) && "Not comparing with a phi instruction!"); 567a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands PHINode *PI = cast<PHINode>(LHS); 568a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 5691845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // Bail out if RHS and the phi may be mutually interdependent due to a loop. 5700aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (!ValueDominatesPHI(RHS, PI, Q.DT)) 5711845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return 0; 5721845009290e4d804ad377927bd8a08cca3036adcDuncan Sands 573a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // Evaluate the BinOp on the incoming phi values. 574a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands Value *CommonValue = 0; 575a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands for (unsigned i = 0, e = PI->getNumIncomingValues(); i != e; ++i) { 576552008946530e01efdad15044e1f621883d14a3aDuncan Sands Value *Incoming = PI->getIncomingValue(i); 577ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // If the incoming value is the phi node itself, it can safely be skipped. 578552008946530e01efdad15044e1f621883d14a3aDuncan Sands if (Incoming == PI) continue; 5790aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Value *V = SimplifyCmpInst(Pred, Incoming, RHS, Q, MaxRecurse); 580a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the operation failed to simplify, or simplified to a different value 581a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // to previously, then give up. 582a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands if (!V || (CommonValue && V != CommonValue)) 583a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return 0; 584a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands CommonValue = V; 585a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands } 586a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 587a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return CommonValue; 588a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 589a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 5908aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner/// SimplifyAddInst - Given operands for an Add, see if we can 591d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner/// fold the result. If not, this returns null. 592ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sandsstatic Value *SimplifyAddInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, 5930aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 594d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 595d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 596d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Constant *Ops[] = { CLHS, CRHS }; 5970aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands return ConstantFoldInstOperands(Instruction::Add, CLHS->getType(), Ops, 5980aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q.TD, Q.TLI); 5998aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner } 60012a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 6018aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner // Canonicalize the constant to the RHS. 6028aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner std::swap(Op0, Op1); 6038aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner } 60412a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 605fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X + undef -> undef 606f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 607fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return Op1; 60812a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 609fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X + 0 -> X 610fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands if (match(Op1, m_Zero())) 611fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return Op0; 612fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 613fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X + (Y - X) -> Y 614fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // (Y - X) + X -> Y 615ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands // Eg: X + -X -> 0 616124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands Value *Y = 0; 617124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (match(Op1, m_Sub(m_Value(Y), m_Specific(Op0))) || 618124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands match(Op0, m_Sub(m_Value(Y), m_Specific(Op1)))) 619fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return Y; 620fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 621fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X + ~X -> -1 since ~X = -X-1 622124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (match(Op0, m_Not(m_Specific(Op1))) || 623124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands match(Op1, m_Not(m_Specific(Op0)))) 624fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return Constant::getAllOnesValue(Op0->getType()); 62587689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands 62682fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands /// i1 add -> xor. 62775d289ed6201e82718343d7a36d2a2fa082f6217Duncan Sands if (MaxRecurse && Op0->getType()->isIntegerTy(1)) 6280aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyXorInst(Op0, Op1, Q, MaxRecurse-1)) 62907f30fbd734069b80b90c6aeea0ae645ce3880c0Duncan Sands return V; 63082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 631566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Try some generic simplifications for associative operations. 6320aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyAssociativeBinOp(Instruction::Add, Op0, Op1, Q, 633566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands MaxRecurse)) 634566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return V; 635566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 6363421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Mul distributes over Add. Try some generic simplifications based on this. 6373421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = FactorizeBinOp(Instruction::Add, Op0, Op1, Instruction::Mul, 6380aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse)) 6393421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 6403421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 64187689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // Threading Add over selects and phi nodes is pointless, so don't bother. 64287689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // Threading over the select in "A + select(cond, B, C)" means evaluating 64387689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // "A+B" and "A+C" and seeing if they are equal; but they are equal if and 64487689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // only if B and C are equal. If B and C are equal then (since we assume 64587689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // that operands have already been simplified) "select(cond, B, C)" should 64687689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // have been simplified to the common value of B and C already. Analysing 64787689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // "A+B" and "A+C" thus gains nothing, but costs compile time. Similarly 64887689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // for threading over phi nodes. 64987689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands 6508aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner return 0; 6518aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner} 6528aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner 653ee9a2e322af96accc9e55ed6373c0057453714b1Duncan SandsValue *llvm::SimplifyAddInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, 6543574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow const DataLayout *TD, const TargetLibraryInfo *TLI, 655618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT) { 6560aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands return ::SimplifyAddInst(Op0, Op1, isNSW, isNUW, Query (TD, TLI, DT), 6570aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands RecursionLimit); 658ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands} 659ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands 660fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth/// \brief Compute the base pointer and cumulative constant offsets for V. 661fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth/// 662fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth/// This strips all constant offsets off of V, leaving it the base pointer, and 663fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth/// accumulates the total constant offset applied in the returned constant. It 664fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth/// returns 0 if V is not a pointer, and returns the constant '0' if there are 665fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth/// no constant offsets applied. 666819f9d6bf91c439967ef623d0c047e7f672683faDan Gohman/// 667819f9d6bf91c439967ef623d0c047e7f672683faDan Gohman/// This is very similar to GetPointerBaseWithConstantOffset except it doesn't 668819f9d6bf91c439967ef623d0c047e7f672683faDan Gohman/// follow non-inbounds geps. This allows it to remain usable for icmp ult/etc. 669819f9d6bf91c439967ef623d0c047e7f672683faDan Gohman/// folding. 670d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramerstatic Constant *stripAndComputeConstantOffsets(const DataLayout *TD, 671d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramer Value *&V) { 672d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramer assert(V->getType()->getScalarType()->isPointerTy()); 673fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth 6743e3de565e9c7258fb97773b3a64fc091355cb2deDan Gohman // Without DataLayout, just be conservative for now. Theoretically, more could 6753e3de565e9c7258fb97773b3a64fc091355cb2deDan Gohman // be done in this case. 6763e3de565e9c7258fb97773b3a64fc091355cb2deDan Gohman if (!TD) 6773e3de565e9c7258fb97773b3a64fc091355cb2deDan Gohman return ConstantInt::get(IntegerType::get(V->getContext(), 64), 0); 6783e3de565e9c7258fb97773b3a64fc091355cb2deDan Gohman 6793e3de565e9c7258fb97773b3a64fc091355cb2deDan Gohman unsigned IntPtrWidth = TD->getPointerSizeInBits(); 68090c14fcb7ea3436a8b3053f8a9aa529c03011d34Chandler Carruth APInt Offset = APInt::getNullValue(IntPtrWidth); 681fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth 682fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth // Even though we don't look through PHI nodes, we could be called on an 683fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth // instruction in an unreachable block, which may be on a cycle. 684fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth SmallPtrSet<Value *, 4> Visited; 685fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth Visited.insert(V); 686fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth do { 687fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth if (GEPOperator *GEP = dyn_cast<GEPOperator>(V)) { 6883e3de565e9c7258fb97773b3a64fc091355cb2deDan Gohman if (!GEP->isInBounds() || !GEP->accumulateConstantOffset(*TD, Offset)) 689fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth break; 690fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth V = GEP->getPointerOperand(); 691fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth } else if (Operator::getOpcode(V) == Instruction::BitCast) { 692fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth V = cast<Operator>(V)->getOperand(0); 693fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth } else if (GlobalAlias *GA = dyn_cast<GlobalAlias>(V)) { 694fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth if (GA->mayBeOverridden()) 695fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth break; 696fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth V = GA->getAliasee(); 697fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth } else { 698fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth break; 699fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth } 700d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramer assert(V->getType()->getScalarType()->isPointerTy() && 701d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramer "Unexpected operand type!"); 702fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth } while (Visited.insert(V)); 703fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth 7043e3de565e9c7258fb97773b3a64fc091355cb2deDan Gohman Type *IntPtrTy = TD->getIntPtrType(V->getContext()); 705d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramer Constant *OffsetIntPtr = ConstantInt::get(IntPtrTy, Offset); 706d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramer if (V->getType()->isVectorTy()) 707d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramer return ConstantVector::getSplat(V->getType()->getVectorNumElements(), 708d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramer OffsetIntPtr); 709d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramer return OffsetIntPtr; 710fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth} 711fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth 712fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth/// \brief Compute the constant difference between two pointer values. 713fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth/// If the difference is not a constant, returns zero. 7143e3de565e9c7258fb97773b3a64fc091355cb2deDan Gohmanstatic Constant *computePointerDifference(const DataLayout *TD, 715fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth Value *LHS, Value *RHS) { 716fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth Constant *LHSOffset = stripAndComputeConstantOffsets(TD, LHS); 717fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth Constant *RHSOffset = stripAndComputeConstantOffsets(TD, RHS); 718fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth 719fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth // If LHS and RHS are not related via constant offsets to the same base 720fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth // value, there is nothing we can do here. 721fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth if (LHS != RHS) 722fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth return 0; 723fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth 724fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth // Otherwise, the difference of LHS - RHS can be computed as: 725fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth // LHS - RHS 726fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth // = (LHSOffset + Base) - (RHSOffset + Base) 727fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth // = LHSOffset - RHSOffset 728fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth return ConstantExpr::getSub(LHSOffset, RHSOffset); 729fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth} 730fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth 731fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands/// SimplifySubInst - Given operands for a Sub, see if we can 732fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands/// fold the result. If not, this returns null. 733ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sandsstatic Value *SimplifySubInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, 7340aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 735fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands if (Constant *CLHS = dyn_cast<Constant>(Op0)) 736fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 737fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands Constant *Ops[] = { CLHS, CRHS }; 738fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return ConstantFoldInstOperands(Instruction::Sub, CLHS->getType(), 7390aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Ops, Q.TD, Q.TLI); 740fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands } 741fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 742fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X - undef -> undef 743fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // undef - X -> undef 744f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op0, m_Undef()) || match(Op1, m_Undef())) 745fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return UndefValue::get(Op0->getType()); 746fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 747fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X - 0 -> X 748fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands if (match(Op1, m_Zero())) 749fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return Op0; 750fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 751fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X - X -> 0 752124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (Op0 == Op1) 753fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return Constant::getNullValue(Op0->getType()); 754fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 755fe02c69f84ad52d42be934e4fe702f03e4991a6aDuncan Sands // (X*2) - X -> X 756fe02c69f84ad52d42be934e4fe702f03e4991a6aDuncan Sands // (X<<1) - X -> X 757b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands Value *X = 0; 758fe02c69f84ad52d42be934e4fe702f03e4991a6aDuncan Sands if (match(Op0, m_Mul(m_Specific(Op1), m_ConstantInt<2>())) || 759fe02c69f84ad52d42be934e4fe702f03e4991a6aDuncan Sands match(Op0, m_Shl(m_Specific(Op1), m_One()))) 760fe02c69f84ad52d42be934e4fe702f03e4991a6aDuncan Sands return Op1; 761fe02c69f84ad52d42be934e4fe702f03e4991a6aDuncan Sands 762b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // (X + Y) - Z -> X + (Y - Z) or Y + (X - Z) if everything simplifies. 763b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // For example, (X + Y) - Y -> X; (Y + X) - Y -> X 764b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands Value *Y = 0, *Z = Op1; 765b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands if (MaxRecurse && match(Op0, m_Add(m_Value(X), m_Value(Y)))) { // (X + Y) - Z 766b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // See if "V === Y - Z" simplifies. 7670aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyBinOp(Instruction::Sub, Y, Z, Q, MaxRecurse-1)) 768b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does! Now see if "X + V" simplifies. 7690aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *W = SimplifyBinOp(Instruction::Add, X, V, Q, MaxRecurse-1)) { 770b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does, we successfully reassociated! 771b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands ++NumReassoc; 772b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands return W; 773b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands } 774b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // See if "V === X - Z" simplifies. 7750aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyBinOp(Instruction::Sub, X, Z, Q, MaxRecurse-1)) 776b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does! Now see if "Y + V" simplifies. 7770aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *W = SimplifyBinOp(Instruction::Add, Y, V, Q, MaxRecurse-1)) { 778b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does, we successfully reassociated! 779b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands ++NumReassoc; 780b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands return W; 781b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands } 782b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands } 78382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 784b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // X - (Y + Z) -> (X - Y) - Z or (X - Z) - Y if everything simplifies. 785b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // For example, X - (X + 1) -> -1 786b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands X = Op0; 787b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands if (MaxRecurse && match(Op1, m_Add(m_Value(Y), m_Value(Z)))) { // X - (Y + Z) 788b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // See if "V === X - Y" simplifies. 7890aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyBinOp(Instruction::Sub, X, Y, Q, MaxRecurse-1)) 790b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does! Now see if "V - Z" simplifies. 7910aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *W = SimplifyBinOp(Instruction::Sub, V, Z, Q, MaxRecurse-1)) { 792b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does, we successfully reassociated! 793b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands ++NumReassoc; 794b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands return W; 795b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands } 796b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // See if "V === X - Z" simplifies. 7970aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyBinOp(Instruction::Sub, X, Z, Q, MaxRecurse-1)) 798b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does! Now see if "V - Y" simplifies. 7990aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *W = SimplifyBinOp(Instruction::Sub, V, Y, Q, MaxRecurse-1)) { 800b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does, we successfully reassociated! 801b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands ++NumReassoc; 802b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands return W; 803b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands } 804b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands } 805b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands 806b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // Z - (X - Y) -> (Z - X) + Y if everything simplifies. 807b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // For example, X - (X - Y) -> Y. 808b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands Z = Op0; 809c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands if (MaxRecurse && match(Op1, m_Sub(m_Value(X), m_Value(Y)))) // Z - (X - Y) 810c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands // See if "V === Z - X" simplifies. 8110aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyBinOp(Instruction::Sub, Z, X, Q, MaxRecurse-1)) 812b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does! Now see if "V + Y" simplifies. 8130aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *W = SimplifyBinOp(Instruction::Add, V, Y, Q, MaxRecurse-1)) { 814c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands // It does, we successfully reassociated! 815c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands ++NumReassoc; 816c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands return W; 817c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands } 818c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands 819bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands // trunc(X) - trunc(Y) -> trunc(X - Y) if everything simplifies. 820bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands if (MaxRecurse && match(Op0, m_Trunc(m_Value(X))) && 821bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands match(Op1, m_Trunc(m_Value(Y)))) 822bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands if (X->getType() == Y->getType()) 823bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands // See if "V === X - Y" simplifies. 824bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands if (Value *V = SimplifyBinOp(Instruction::Sub, X, Y, Q, MaxRecurse-1)) 825bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands // It does! Now see if "trunc V" simplifies. 826bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands if (Value *W = SimplifyTruncInst(V, Op0->getType(), Q, MaxRecurse-1)) 827bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands // It does, return the simplified "trunc V". 828bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands return W; 829bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands 830bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands // Variations on GEP(base, I, ...) - GEP(base, i, ...) -> GEP(null, I-i, ...). 8313e3de565e9c7258fb97773b3a64fc091355cb2deDan Gohman if (match(Op0, m_PtrToInt(m_Value(X))) && 832bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands match(Op1, m_PtrToInt(m_Value(Y)))) 8333e3de565e9c7258fb97773b3a64fc091355cb2deDan Gohman if (Constant *Result = computePointerDifference(Q.TD, X, Y)) 834bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands return ConstantExpr::getIntegerCast(Result, Op0->getType(), true); 835bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands 8363421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Mul distributes over Sub. Try some generic simplifications based on this. 8373421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = FactorizeBinOp(Instruction::Sub, Op0, Op1, Instruction::Mul, 8380aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse)) 8393421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 8403421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 841b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // i1 sub -> xor. 842b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands if (MaxRecurse && Op0->getType()->isIntegerTy(1)) 8430aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyXorInst(Op0, Op1, Q, MaxRecurse-1)) 844b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands return V; 845b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands 846fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // Threading Sub over selects and phi nodes is pointless, so don't bother. 847fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // Threading over the select in "A - select(cond, B, C)" means evaluating 848fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // "A-B" and "A-C" and seeing if they are equal; but they are equal if and 849fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // only if B and C are equal. If B and C are equal then (since we assume 850fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // that operands have already been simplified) "select(cond, B, C)" should 851fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // have been simplified to the common value of B and C already. Analysing 852fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // "A-B" and "A-C" thus gains nothing, but costs compile time. Similarly 853fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // for threading over phi nodes. 854fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 855fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return 0; 856fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands} 857fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 858ee9a2e322af96accc9e55ed6373c0057453714b1Duncan SandsValue *llvm::SimplifySubInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, 8593574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow const DataLayout *TD, const TargetLibraryInfo *TLI, 860618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT) { 8610aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands return ::SimplifySubInst(Op0, Op1, isNSW, isNUW, Query (TD, TLI, DT), 8620aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands RecursionLimit); 863ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands} 864ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands 86509ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman/// Given operands for an FAdd, see if we can fold the result. If not, this 86609ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman/// returns null. 86709ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilsemanstatic Value *SimplifyFAddInst(Value *Op0, Value *Op1, FastMathFlags FMF, 86809ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman const Query &Q, unsigned MaxRecurse) { 86909ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 87009ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 87109ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman Constant *Ops[] = { CLHS, CRHS }; 87209ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman return ConstantFoldInstOperands(Instruction::FAdd, CLHS->getType(), 87309ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman Ops, Q.TD, Q.TLI); 87409ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman } 87509ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 87609ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman // Canonicalize the constant to the RHS. 87709ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman std::swap(Op0, Op1); 87809ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman } 87909ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 88009ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman // fadd X, -0 ==> X 88109ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if (match(Op1, m_NegZero())) 88209ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman return Op0; 88309ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 88409ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman // fadd X, 0 ==> X, when we know X is not -0 88509ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if (match(Op1, m_Zero()) && 88609ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman (FMF.noSignedZeros() || CannotBeNegativeZero(Op0))) 88709ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman return Op0; 88809ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 88909ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman // fadd [nnan ninf] X, (fsub [nnan ninf] 0, X) ==> 0 89009ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman // where nnan and ninf have to occur at least once somewhere in this 89109ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman // expression 89209ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman Value *SubOp = 0; 89309ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if (match(Op1, m_FSub(m_AnyZero(), m_Specific(Op0)))) 89409ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman SubOp = Op1; 89509ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman else if (match(Op0, m_FSub(m_AnyZero(), m_Specific(Op1)))) 89609ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman SubOp = Op0; 89709ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if (SubOp) { 89809ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman Instruction *FSub = cast<Instruction>(SubOp); 89909ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if ((FMF.noNaNs() || FSub->hasNoNaNs()) && 90009ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman (FMF.noInfs() || FSub->hasNoInfs())) 90109ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman return Constant::getNullValue(Op0->getType()); 90209ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman } 90309ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 90409ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman return 0; 90509ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman} 90609ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 90709ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman/// Given operands for an FSub, see if we can fold the result. If not, this 90809ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman/// returns null. 90909ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilsemanstatic Value *SimplifyFSubInst(Value *Op0, Value *Op1, FastMathFlags FMF, 91009ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman const Query &Q, unsigned MaxRecurse) { 91109ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 91209ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 91309ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman Constant *Ops[] = { CLHS, CRHS }; 91409ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman return ConstantFoldInstOperands(Instruction::FSub, CLHS->getType(), 91509ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman Ops, Q.TD, Q.TLI); 91609ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman } 91709ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman } 91809ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 91909ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman // fsub X, 0 ==> X 92009ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if (match(Op1, m_Zero())) 92109ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman return Op0; 92209ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 92309ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman // fsub X, -0 ==> X, when we know X is not -0 92409ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if (match(Op1, m_NegZero()) && 92509ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman (FMF.noSignedZeros() || CannotBeNegativeZero(Op0))) 92609ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman return Op0; 92709ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 92809ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman // fsub 0, (fsub -0.0, X) ==> X 92909ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman Value *X; 93009ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if (match(Op0, m_AnyZero())) { 93109ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if (match(Op1, m_FSub(m_NegZero(), m_Value(X)))) 93209ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman return X; 93309ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if (FMF.noSignedZeros() && match(Op1, m_FSub(m_AnyZero(), m_Value(X)))) 93409ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman return X; 93509ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman } 93609ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 93709ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman // fsub nnan ninf x, x ==> 0.0 93809ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if (FMF.noNaNs() && FMF.noInfs() && Op0 == Op1) 93909ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman return Constant::getNullValue(Op0->getType()); 94009ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 94109ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman return 0; 94209ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman} 94309ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 944eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman/// Given the operands for an FMul, see if we can fold the result 945eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilsemanstatic Value *SimplifyFMulInst(Value *Op0, Value *Op1, 946eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman FastMathFlags FMF, 947eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman const Query &Q, 948eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman unsigned MaxRecurse) { 949eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 950eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 951eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman Constant *Ops[] = { CLHS, CRHS }; 952eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman return ConstantFoldInstOperands(Instruction::FMul, CLHS->getType(), 953eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman Ops, Q.TD, Q.TLI); 954eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman } 955eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman 95609ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman // Canonicalize the constant to the RHS. 95709ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman std::swap(Op0, Op1); 958eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman } 959eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman 96009ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman // fmul X, 1.0 ==> X 96109ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if (match(Op1, m_FPOne())) 96209ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman return Op0; 96309ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 96409ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman // fmul nnan nsz X, 0 ==> 0 96509ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if (FMF.noNaNs() && FMF.noSignedZeros() && match(Op1, m_AnyZero())) 96609ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman return Op1; 96709ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 968eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman return 0; 969eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman} 970eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman 97182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands/// SimplifyMulInst - Given operands for a Mul, see if we can 97282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands/// fold the result. If not, this returns null. 9730aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyMulInst(Value *Op0, Value *Op1, const Query &Q, 9740aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands unsigned MaxRecurse) { 97582fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 97682fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 97782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands Constant *Ops[] = { CLHS, CRHS }; 97882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return ConstantFoldInstOperands(Instruction::Mul, CLHS->getType(), 9790aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Ops, Q.TD, Q.TLI); 98082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands } 98182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 98282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // Canonicalize the constant to the RHS. 98382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands std::swap(Op0, Op1); 98482fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands } 98582fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 98682fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // X * undef -> 0 987f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 98882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return Constant::getNullValue(Op0->getType()); 98982fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 99082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // X * 0 -> 0 99182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (match(Op1, m_Zero())) 99282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return Op1; 99382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 99482fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // X * 1 -> X 99582fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (match(Op1, m_One())) 99682fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return Op0; 99782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 9981895e98ef38afbe011575cc25f4889d96e37421bDuncan Sands // (X / Y) * Y -> X if the division is exact. 99955c6d57734cd2f141dc2d6912fc22746d5eeae54Benjamin Kramer Value *X = 0; 100055c6d57734cd2f141dc2d6912fc22746d5eeae54Benjamin Kramer if (match(Op0, m_Exact(m_IDiv(m_Value(X), m_Specific(Op1)))) || // (X / Y) * Y 100155c6d57734cd2f141dc2d6912fc22746d5eeae54Benjamin Kramer match(Op1, m_Exact(m_IDiv(m_Value(X), m_Specific(Op0))))) // Y * (X / Y) 100255c6d57734cd2f141dc2d6912fc22746d5eeae54Benjamin Kramer return X; 10031895e98ef38afbe011575cc25f4889d96e37421bDuncan Sands 10045413880654585f01ea9880f24f07f27c8da56ba8Nick Lewycky // i1 mul -> and. 100575d289ed6201e82718343d7a36d2a2fa082f6217Duncan Sands if (MaxRecurse && Op0->getType()->isIntegerTy(1)) 10060aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyAndInst(Op0, Op1, Q, MaxRecurse-1)) 100707f30fbd734069b80b90c6aeea0ae645ce3880c0Duncan Sands return V; 100882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 100982fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // Try some generic simplifications for associative operations. 10100aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyAssociativeBinOp(Instruction::Mul, Op0, Op1, Q, 101182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands MaxRecurse)) 101282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return V; 101382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 101482fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // Mul distributes over Add. Try some generic simplifications based on this. 101582fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (Value *V = ExpandBinOp(Instruction::Mul, Op0, Op1, Instruction::Add, 10160aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse)) 101782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return V; 101882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 101982fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // If the operation is with the result of a select instruction, check whether 102082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // operating on either branch of the select always yields the same value. 102182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) 10220aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadBinOpOverSelect(Instruction::Mul, Op0, Op1, Q, 102382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands MaxRecurse)) 102482fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return V; 102582fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 102682fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // If the operation is with the result of a phi instruction, check whether 102782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // operating on all incoming values of the phi always yields the same value. 102882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (isa<PHINode>(Op0) || isa<PHINode>(Op1)) 10290aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadBinOpOverPHI(Instruction::Mul, Op0, Op1, Q, 103082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands MaxRecurse)) 103182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return V; 103282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 103382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return 0; 103482fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands} 103582fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 103609ee250e728ccdb7afc6354d777f8319c5a0465cMichael IlsemanValue *llvm::SimplifyFAddInst(Value *Op0, Value *Op1, FastMathFlags FMF, 103709ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman const DataLayout *TD, const TargetLibraryInfo *TLI, 103809ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman const DominatorTree *DT) { 103909ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman return ::SimplifyFAddInst(Op0, Op1, FMF, Query (TD, TLI, DT), RecursionLimit); 104009ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman} 104109ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 104209ee250e728ccdb7afc6354d777f8319c5a0465cMichael IlsemanValue *llvm::SimplifyFSubInst(Value *Op0, Value *Op1, FastMathFlags FMF, 104309ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman const DataLayout *TD, const TargetLibraryInfo *TLI, 104409ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman const DominatorTree *DT) { 104509ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman return ::SimplifyFSubInst(Op0, Op1, FMF, Query (TD, TLI, DT), RecursionLimit); 104609ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman} 104709ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 1048eb61c920f12cacee38815bf10821d2f294b66f3aMichael IlsemanValue *llvm::SimplifyFMulInst(Value *Op0, Value *Op1, 1049eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman FastMathFlags FMF, 1050eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman const DataLayout *TD, 1051eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman const TargetLibraryInfo *TLI, 1052eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman const DominatorTree *DT) { 1053eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman return ::SimplifyFMulInst(Op0, Op1, FMF, Query (TD, TLI, DT), RecursionLimit); 1054eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman} 1055eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman 10563574eca1b02600bac4e625297f4ecf745f4c4f32Micah VillmowValue *llvm::SimplifyMulInst(Value *Op0, Value *Op1, const DataLayout *TD, 1057618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 105882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands const DominatorTree *DT) { 10590aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands return ::SimplifyMulInst(Op0, Op1, Query (TD, TLI, DT), RecursionLimit); 106082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands} 106182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 1062593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands/// SimplifyDiv - Given operands for an SDiv or UDiv, see if we can 1063593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands/// fold the result. If not, this returns null. 1064479b4b9ef06dd84097202ffa6aea07913cdf651cAnders Carlssonstatic Value *SimplifyDiv(Instruction::BinaryOps Opcode, Value *Op0, Value *Op1, 10650aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 1066593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Constant *C0 = dyn_cast<Constant>(Op0)) { 1067593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Constant *C1 = dyn_cast<Constant>(Op1)) { 1068593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands Constant *Ops[] = { C0, C1 }; 10690aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands return ConstantFoldInstOperands(Opcode, C0->getType(), Ops, Q.TD, Q.TLI); 1070593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands } 1071593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands } 1072593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1073a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands bool isSigned = Opcode == Instruction::SDiv; 1074a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands 1075593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // X / undef -> undef 1076f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 1077593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return Op1; 1078593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1079593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // undef / X -> 0 1080f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op0, m_Undef())) 1081593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return Constant::getNullValue(Op0->getType()); 1082593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1083593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // 0 / X -> 0, we don't need to preserve faults! 1084593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (match(Op0, m_Zero())) 1085593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return Op0; 1086593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1087593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // X / 1 -> X 1088593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (match(Op1, m_One())) 1089593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return Op0; 1090593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1091593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Op0->getType()->isIntegerTy(1)) 1092593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // It can't be division by zero, hence it must be division by one. 1093593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return Op0; 1094593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1095593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // X / X -> 1 1096593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Op0 == Op1) 1097593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return ConstantInt::get(Op0->getType(), 1); 1098593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1099593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // (X * Y) / Y -> X if the multiplication does not overflow. 1100593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands Value *X = 0, *Y = 0; 1101593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (match(Op0, m_Mul(m_Value(X), m_Value(Y))) && (X == Op1 || Y == Op1)) { 1102593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Y != Op1) std::swap(X, Y); // Ensure expression is (X * Y) / Y, Y = Op1 110332a43cc0fc3cd42702d7859eaa58dd42f561a54dDuncan Sands OverflowingBinaryOperator *Mul = cast<OverflowingBinaryOperator>(Op0); 11044b720718fbda1194f925e0a9d931bc220e8b0e3aDuncan Sands // If the Mul knows it does not overflow, then we are good to go. 11054b720718fbda1194f925e0a9d931bc220e8b0e3aDuncan Sands if ((isSigned && Mul->hasNoSignedWrap()) || 11064b720718fbda1194f925e0a9d931bc220e8b0e3aDuncan Sands (!isSigned && Mul->hasNoUnsignedWrap())) 11074b720718fbda1194f925e0a9d931bc220e8b0e3aDuncan Sands return X; 1108593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // If X has the form X = A / Y then X * Y cannot overflow. 1109593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (BinaryOperator *Div = dyn_cast<BinaryOperator>(X)) 1110593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Div->getOpcode() == Opcode && Div->getOperand(1) == Y) 1111593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return X; 1112593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands } 1113593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1114a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands // (X rem Y) / Y -> 0 1115a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands if ((isSigned && match(Op0, m_SRem(m_Value(), m_Specific(Op1)))) || 1116a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands (!isSigned && match(Op0, m_URem(m_Value(), m_Specific(Op1))))) 1117a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands return Constant::getNullValue(Op0->getType()); 1118a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands 1119a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands // If the operation is with the result of a select instruction, check whether 1120a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands // operating on either branch of the select always yields the same value. 1121a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) 11220aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadBinOpOverSelect(Opcode, Op0, Op1, Q, MaxRecurse)) 1123a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands return V; 1124a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands 1125a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands // If the operation is with the result of a phi instruction, check whether 1126a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands // operating on all incoming values of the phi always yields the same value. 1127a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands if (isa<PHINode>(Op0) || isa<PHINode>(Op1)) 11280aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadBinOpOverPHI(Opcode, Op0, Op1, Q, MaxRecurse)) 1129a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands return V; 1130a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands 1131593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return 0; 1132593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands} 1133593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1134593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands/// SimplifySDivInst - Given operands for an SDiv, see if we can 1135593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands/// fold the result. If not, this returns null. 11360aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifySDivInst(Value *Op0, Value *Op1, const Query &Q, 11370aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands unsigned MaxRecurse) { 11380aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyDiv(Instruction::SDiv, Op0, Op1, Q, MaxRecurse)) 1139593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return V; 1140593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1141593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return 0; 1142593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands} 1143593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 11443574eca1b02600bac4e625297f4ecf745f4c4f32Micah VillmowValue *llvm::SimplifySDivInst(Value *Op0, Value *Op1, const DataLayout *TD, 1145618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 11461fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel const DominatorTree *DT) { 11470aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands return ::SimplifySDivInst(Op0, Op1, Query (TD, TLI, DT), RecursionLimit); 1148593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands} 1149593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1150593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands/// SimplifyUDivInst - Given operands for a UDiv, see if we can 1151593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands/// fold the result. If not, this returns null. 11520aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyUDivInst(Value *Op0, Value *Op1, const Query &Q, 11530aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands unsigned MaxRecurse) { 11540aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyDiv(Instruction::UDiv, Op0, Op1, Q, MaxRecurse)) 1155593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return V; 1156593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1157593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return 0; 1158593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands} 1159593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 11603574eca1b02600bac4e625297f4ecf745f4c4f32Micah VillmowValue *llvm::SimplifyUDivInst(Value *Op0, Value *Op1, const DataLayout *TD, 1161618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 11621fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel const DominatorTree *DT) { 11630aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands return ::SimplifyUDivInst(Op0, Op1, Query (TD, TLI, DT), RecursionLimit); 1164593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands} 1165593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 11660aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyFDivInst(Value *Op0, Value *Op1, const Query &Q, 11670aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands unsigned) { 11681fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel // undef / X -> undef (the undef could be a snan). 1169f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op0, m_Undef())) 11701fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel return Op0; 11711fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel 11721fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel // X / undef -> undef 1173f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 11741fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel return Op1; 11751fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel 11761fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel return 0; 11771fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel} 11781fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel 11793574eca1b02600bac4e625297f4ecf745f4c4f32Micah VillmowValue *llvm::SimplifyFDivInst(Value *Op0, Value *Op1, const DataLayout *TD, 1180618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 11811fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel const DominatorTree *DT) { 11820aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands return ::SimplifyFDivInst(Op0, Op1, Query (TD, TLI, DT), RecursionLimit); 11831fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel} 11841fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel 1185f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands/// SimplifyRem - Given operands for an SRem or URem, see if we can 1186f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands/// fold the result. If not, this returns null. 1187f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sandsstatic Value *SimplifyRem(Instruction::BinaryOps Opcode, Value *Op0, Value *Op1, 11880aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 1189f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (Constant *C0 = dyn_cast<Constant>(Op0)) { 1190f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (Constant *C1 = dyn_cast<Constant>(Op1)) { 1191f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands Constant *Ops[] = { C0, C1 }; 11920aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands return ConstantFoldInstOperands(Opcode, C0->getType(), Ops, Q.TD, Q.TLI); 1193f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands } 1194f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands } 1195f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1196f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // X % undef -> undef 1197f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op1, m_Undef())) 1198f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Op1; 1199f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1200f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // undef % X -> 0 1201f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op0, m_Undef())) 1202f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Constant::getNullValue(Op0->getType()); 1203f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1204f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // 0 % X -> 0, we don't need to preserve faults! 1205f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op0, m_Zero())) 1206f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Op0; 1207f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1208f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // X % 0 -> undef, we don't need to preserve faults! 1209f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op1, m_Zero())) 1210f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return UndefValue::get(Op0->getType()); 1211f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1212f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // X % 1 -> 0 1213f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op1, m_One())) 1214f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Constant::getNullValue(Op0->getType()); 1215f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1216f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (Op0->getType()->isIntegerTy(1)) 1217f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // It can't be remainder by zero, hence it must be remainder by one. 1218f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Constant::getNullValue(Op0->getType()); 1219f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1220f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // X % X -> 0 1221f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (Op0 == Op1) 1222f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Constant::getNullValue(Op0->getType()); 1223f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1224f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // If the operation is with the result of a select instruction, check whether 1225f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // operating on either branch of the select always yields the same value. 1226f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) 12270aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadBinOpOverSelect(Opcode, Op0, Op1, Q, MaxRecurse)) 1228f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return V; 1229f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1230f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // If the operation is with the result of a phi instruction, check whether 1231f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // operating on all incoming values of the phi always yields the same value. 1232f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (isa<PHINode>(Op0) || isa<PHINode>(Op1)) 12330aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadBinOpOverPHI(Opcode, Op0, Op1, Q, MaxRecurse)) 1234f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return V; 1235f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1236f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return 0; 1237f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1238f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1239f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands/// SimplifySRemInst - Given operands for an SRem, see if we can 1240f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands/// fold the result. If not, this returns null. 12410aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifySRemInst(Value *Op0, Value *Op1, const Query &Q, 12420aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands unsigned MaxRecurse) { 12430aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyRem(Instruction::SRem, Op0, Op1, Q, MaxRecurse)) 1244f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return V; 1245f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1246f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return 0; 1247f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1248f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 12493574eca1b02600bac4e625297f4ecf745f4c4f32Micah VillmowValue *llvm::SimplifySRemInst(Value *Op0, Value *Op1, const DataLayout *TD, 1250618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1251f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands const DominatorTree *DT) { 12520aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands return ::SimplifySRemInst(Op0, Op1, Query (TD, TLI, DT), RecursionLimit); 1253f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1254f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1255f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands/// SimplifyURemInst - Given operands for a URem, see if we can 1256f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands/// fold the result. If not, this returns null. 12570aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyURemInst(Value *Op0, Value *Op1, const Query &Q, 1258618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier unsigned MaxRecurse) { 12590aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyRem(Instruction::URem, Op0, Op1, Q, MaxRecurse)) 1260f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return V; 1261f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1262f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return 0; 1263f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1264f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 12653574eca1b02600bac4e625297f4ecf745f4c4f32Micah VillmowValue *llvm::SimplifyURemInst(Value *Op0, Value *Op1, const DataLayout *TD, 1266618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1267f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands const DominatorTree *DT) { 12680aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands return ::SimplifyURemInst(Op0, Op1, Query (TD, TLI, DT), RecursionLimit); 1269f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1270f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 12710aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyFRemInst(Value *Op0, Value *Op1, const Query &, 1272618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier unsigned) { 1273f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // undef % X -> undef (the undef could be a snan). 1274f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op0, m_Undef())) 1275f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Op0; 1276f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1277f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // X % undef -> undef 1278f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op1, m_Undef())) 1279f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Op1; 1280f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1281f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return 0; 1282f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1283f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 12843574eca1b02600bac4e625297f4ecf745f4c4f32Micah VillmowValue *llvm::SimplifyFRemInst(Value *Op0, Value *Op1, const DataLayout *TD, 1285618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1286f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands const DominatorTree *DT) { 12870aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands return ::SimplifyFRemInst(Op0, Op1, Query (TD, TLI, DT), RecursionLimit); 1288f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1289f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1290cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands/// SimplifyShift - Given operands for an Shl, LShr or AShr, see if we can 1291c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands/// fold the result. If not, this returns null. 1292cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sandsstatic Value *SimplifyShift(unsigned Opcode, Value *Op0, Value *Op1, 12930aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 1294c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands if (Constant *C0 = dyn_cast<Constant>(Op0)) { 1295c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands if (Constant *C1 = dyn_cast<Constant>(Op1)) { 1296c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands Constant *Ops[] = { C0, C1 }; 12970aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands return ConstantFoldInstOperands(Opcode, C0->getType(), Ops, Q.TD, Q.TLI); 1298c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands } 1299c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands } 1300c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1301cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // 0 shift by X -> 0 1302c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands if (match(Op0, m_Zero())) 1303c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return Op0; 1304c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1305cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // X shift by 0 -> X 1306c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands if (match(Op1, m_Zero())) 1307c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return Op0; 1308c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1309cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // X shift by undef -> undef because it may shift by the bitwidth. 1310f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 1311c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return Op1; 1312c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1313c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands // Shifting by the bitwidth or more is undefined. 1314c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands if (ConstantInt *CI = dyn_cast<ConstantInt>(Op1)) 1315c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands if (CI->getValue().getLimitedValue() >= 1316c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands Op0->getType()->getScalarSizeInBits()) 1317c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return UndefValue::get(Op0->getType()); 1318c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1319cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // If the operation is with the result of a select instruction, check whether 1320cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // operating on either branch of the select always yields the same value. 1321cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) 13220aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadBinOpOverSelect(Opcode, Op0, Op1, Q, MaxRecurse)) 1323cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return V; 1324cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands 1325cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // If the operation is with the result of a phi instruction, check whether 1326cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // operating on all incoming values of the phi always yields the same value. 1327cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands if (isa<PHINode>(Op0) || isa<PHINode>(Op1)) 13280aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadBinOpOverPHI(Opcode, Op0, Op1, Q, MaxRecurse)) 1329cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return V; 1330cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands 1331cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return 0; 1332cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands} 1333cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands 1334cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands/// SimplifyShlInst - Given operands for an Shl, see if we can 1335cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands/// fold the result. If not, this returns null. 133681a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattnerstatic Value *SimplifyShlInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, 13370aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 13380aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyShift(Instruction::Shl, Op0, Op1, Q, MaxRecurse)) 1339cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return V; 1340cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands 1341cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // undef << X -> 0 1342f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op0, m_Undef())) 1343cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return Constant::getNullValue(Op0->getType()); 1344cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands 134581a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner // (X >> A) << A -> X 134681a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Value *X; 134755c6d57734cd2f141dc2d6912fc22746d5eeae54Benjamin Kramer if (match(Op0, m_Exact(m_Shr(m_Value(X), m_Specific(Op1))))) 134881a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner return X; 1349c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return 0; 1350c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands} 1351c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 135281a0dc911586c77421c2255aa417dc9b350b9e20Chris LattnerValue *llvm::SimplifyShlInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, 13533574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow const DataLayout *TD, const TargetLibraryInfo *TLI, 1354618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT) { 13550aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands return ::SimplifyShlInst(Op0, Op1, isNSW, isNUW, Query (TD, TLI, DT), 13560aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands RecursionLimit); 1357c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands} 1358c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1359c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands/// SimplifyLShrInst - Given operands for an LShr, see if we can 1360c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands/// fold the result. If not, this returns null. 136181a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattnerstatic Value *SimplifyLShrInst(Value *Op0, Value *Op1, bool isExact, 13620aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 13630aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyShift(Instruction::LShr, Op0, Op1, Q, MaxRecurse)) 1364cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return V; 1365c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 13668c5c6f0e090f91b6555cdd9d2eea238fff3befe6David Majnemer // X >> X -> 0 13678c5c6f0e090f91b6555cdd9d2eea238fff3befe6David Majnemer if (Op0 == Op1) 13688c5c6f0e090f91b6555cdd9d2eea238fff3befe6David Majnemer return Constant::getNullValue(Op0->getType()); 13698c5c6f0e090f91b6555cdd9d2eea238fff3befe6David Majnemer 1370c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands // undef >>l X -> 0 1371f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op0, m_Undef())) 1372c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return Constant::getNullValue(Op0->getType()); 1373c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 137481a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner // (X << A) >> A -> X 137581a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Value *X; 137681a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner if (match(Op0, m_Shl(m_Value(X), m_Specific(Op1))) && 137781a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner cast<OverflowingBinaryOperator>(Op0)->hasNoUnsignedWrap()) 137881a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner return X; 137952fb846578714d14bbde9b28884a6a8729217677Duncan Sands 1380c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return 0; 1381c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands} 1382c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 138381a0dc911586c77421c2255aa417dc9b350b9e20Chris LattnerValue *llvm::SimplifyLShrInst(Value *Op0, Value *Op1, bool isExact, 13843574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow const DataLayout *TD, 1385618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1386618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT) { 13870aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands return ::SimplifyLShrInst(Op0, Op1, isExact, Query (TD, TLI, DT), 13880aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands RecursionLimit); 1389c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands} 1390c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1391c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands/// SimplifyAShrInst - Given operands for an AShr, see if we can 1392c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands/// fold the result. If not, this returns null. 139381a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattnerstatic Value *SimplifyAShrInst(Value *Op0, Value *Op1, bool isExact, 13940aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 13950aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyShift(Instruction::AShr, Op0, Op1, Q, MaxRecurse)) 1396cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return V; 1397c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 13988c5c6f0e090f91b6555cdd9d2eea238fff3befe6David Majnemer // X >> X -> 0 13998c5c6f0e090f91b6555cdd9d2eea238fff3befe6David Majnemer if (Op0 == Op1) 14008c5c6f0e090f91b6555cdd9d2eea238fff3befe6David Majnemer return Constant::getNullValue(Op0->getType()); 14018c5c6f0e090f91b6555cdd9d2eea238fff3befe6David Majnemer 1402c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands // all ones >>a X -> all ones 1403c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands if (match(Op0, m_AllOnes())) 1404c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return Op0; 1405c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1406c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands // undef >>a X -> all ones 1407f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op0, m_Undef())) 1408c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return Constant::getAllOnesValue(Op0->getType()); 1409c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 141081a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner // (X << A) >> A -> X 141181a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Value *X; 141281a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner if (match(Op0, m_Shl(m_Value(X), m_Specific(Op1))) && 141381a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner cast<OverflowingBinaryOperator>(Op0)->hasNoSignedWrap()) 141481a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner return X; 141552fb846578714d14bbde9b28884a6a8729217677Duncan Sands 1416c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return 0; 1417c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands} 1418c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 141981a0dc911586c77421c2255aa417dc9b350b9e20Chris LattnerValue *llvm::SimplifyAShrInst(Value *Op0, Value *Op1, bool isExact, 14203574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow const DataLayout *TD, 1421618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1422618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT) { 14230aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands return ::SimplifyAShrInst(Op0, Op1, isExact, Query (TD, TLI, DT), 14240aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands RecursionLimit); 1425c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands} 1426c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 14278aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner/// SimplifyAndInst - Given operands for an And, see if we can 14288aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner/// fold the result. If not, this returns null. 14290aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyAndInst(Value *Op0, Value *Op1, const Query &Q, 1430618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier unsigned MaxRecurse) { 14318aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 14328aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 14338aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner Constant *Ops[] = { CLHS, CRHS }; 1434d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return ConstantFoldInstOperands(Instruction::And, CLHS->getType(), 14350aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Ops, Q.TD, Q.TLI); 1436d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 143712a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1438d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // Canonicalize the constant to the RHS. 1439d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner std::swap(Op0, Op1); 1440d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 144112a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1442d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X & undef -> 0 1443f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 1444d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Constant::getNullValue(Op0->getType()); 144512a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1446d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X & X = X 1447124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (Op0 == Op1) 1448d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 144912a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 14502b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // X & 0 = 0 14512b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (match(Op1, m_Zero())) 1452d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op1; 145312a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 14542b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // X & -1 = X 14552b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (match(Op1, m_AllOnes())) 14562b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return Op0; 145712a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1458d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // A & ~A = ~A & A = 0 145981a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner if (match(Op0, m_Not(m_Specific(Op1))) || 146081a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner match(Op1, m_Not(m_Specific(Op0)))) 1461d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Constant::getNullValue(Op0->getType()); 146212a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1463d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // (A | ?) & A = A 146481a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Value *A = 0, *B = 0; 1465d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (match(Op0, m_Or(m_Value(A), m_Value(B))) && 1466124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands (A == Op1 || B == Op1)) 1467d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op1; 146812a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1469d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // A & (A | ?) = A 1470d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (match(Op1, m_Or(m_Value(A), m_Value(B))) && 1471124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands (A == Op0 || B == Op0)) 1472d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 147312a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1474dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands // A & (-A) = A if A is a power of two or zero. 1475dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands if (match(Op0, m_Neg(m_Specific(Op1))) || 1476dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands match(Op1, m_Neg(m_Specific(Op0)))) { 1477dbaa2376f7b3c027e895ff4bee3ae08351f3ea88Rafael Espindola if (isKnownToBeAPowerOfTwo(Op0, /*OrZero*/true)) 1478dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands return Op0; 1479dbaa2376f7b3c027e895ff4bee3ae08351f3ea88Rafael Espindola if (isKnownToBeAPowerOfTwo(Op1, /*OrZero*/true)) 1480dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands return Op1; 1481dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands } 1482dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands 1483566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Try some generic simplifications for associative operations. 14840aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyAssociativeBinOp(Instruction::And, Op0, Op1, Q, 14850aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands MaxRecurse)) 1486566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return V; 14876844c8ea5a67e551be7106d6b7b9e1a64eecbe51Benjamin Kramer 14883421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // And distributes over Or. Try some generic simplifications based on this. 14893421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = ExpandBinOp(Instruction::And, Op0, Op1, Instruction::Or, 14900aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse)) 14913421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 14923421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 14933421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // And distributes over Xor. Try some generic simplifications based on this. 14943421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = ExpandBinOp(Instruction::And, Op0, Op1, Instruction::Xor, 14950aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse)) 14963421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 14973421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 14983421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Or distributes over And. Try some generic simplifications based on this. 14993421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = FactorizeBinOp(Instruction::And, Op0, Op1, Instruction::Or, 15000aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse)) 15013421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 15023421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1503b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // If the operation is with the result of a select instruction, check whether 1504b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // operating on either branch of the select always yields the same value. 15050312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) 15060aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadBinOpOverSelect(Instruction::And, Op0, Op1, Q, 15070aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands MaxRecurse)) 1508a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return V; 1509a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 1510a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the operation is with the result of a phi instruction, check whether 1511a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // operating on all incoming values of the phi always yields the same value. 15120312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<PHINode>(Op0) || isa<PHINode>(Op1)) 15130aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadBinOpOverPHI(Instruction::And, Op0, Op1, Q, 15140312a93693abc2eb682b2b101c889959888fd883Duncan Sands MaxRecurse)) 1515b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return V; 1516b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 1517d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return 0; 1518d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner} 15199f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 15203574eca1b02600bac4e625297f4ecf745f4c4f32Micah VillmowValue *llvm::SimplifyAndInst(Value *Op0, Value *Op1, const DataLayout *TD, 1521618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 15221845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const DominatorTree *DT) { 15230aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands return ::SimplifyAndInst(Op0, Op1, Query (TD, TLI, DT), RecursionLimit); 1524a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 1525a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 1526d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner/// SimplifyOrInst - Given operands for an Or, see if we can 15279f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner/// fold the result. If not, this returns null. 15280aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyOrInst(Value *Op0, Value *Op1, const Query &Q, 15290aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands unsigned MaxRecurse) { 1530d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 1531d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 1532d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Constant *Ops[] = { CLHS, CRHS }; 1533d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return ConstantFoldInstOperands(Instruction::Or, CLHS->getType(), 15340aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Ops, Q.TD, Q.TLI); 1535d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 153612a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1537d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // Canonicalize the constant to the RHS. 1538d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner std::swap(Op0, Op1); 1539d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 154012a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1541d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X | undef -> -1 1542f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 1543d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Constant::getAllOnesValue(Op0->getType()); 154412a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1545d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X | X = X 1546124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (Op0 == Op1) 1547d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 1548d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 15492b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // X | 0 = X 15502b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (match(Op1, m_Zero())) 1551d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 155212a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 15532b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // X | -1 = -1 15542b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (match(Op1, m_AllOnes())) 15552b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return Op1; 155612a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1557d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // A | ~A = ~A | A = -1 155881a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner if (match(Op0, m_Not(m_Specific(Op1))) || 155981a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner match(Op1, m_Not(m_Specific(Op0)))) 1560d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Constant::getAllOnesValue(Op0->getType()); 156112a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1562d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // (A & ?) | A = A 156381a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Value *A = 0, *B = 0; 1564d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (match(Op0, m_And(m_Value(A), m_Value(B))) && 1565124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands (A == Op1 || B == Op1)) 1566d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op1; 156712a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1568d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // A | (A & ?) = A 1569d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (match(Op1, m_And(m_Value(A), m_Value(B))) && 1570124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands (A == Op0 || B == Op0)) 1571d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 157212a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 157338f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer // ~(A & ?) | A = -1 157438f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer if (match(Op0, m_Not(m_And(m_Value(A), m_Value(B)))) && 157538f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer (A == Op1 || B == Op1)) 157638f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer return Constant::getAllOnesValue(Op1->getType()); 157738f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer 157838f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer // A | ~(A & ?) = -1 157938f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer if (match(Op1, m_Not(m_And(m_Value(A), m_Value(B)))) && 158038f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer (A == Op0 || B == Op0)) 158138f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer return Constant::getAllOnesValue(Op0->getType()); 158238f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer 1583566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Try some generic simplifications for associative operations. 15840aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyAssociativeBinOp(Instruction::Or, Op0, Op1, Q, 15850aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands MaxRecurse)) 1586566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return V; 15876844c8ea5a67e551be7106d6b7b9e1a64eecbe51Benjamin Kramer 15883421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Or distributes over And. Try some generic simplifications based on this. 15890aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ExpandBinOp(Instruction::Or, Op0, Op1, Instruction::And, Q, 15900aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands MaxRecurse)) 15913421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 15923421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 15933421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // And distributes over Or. Try some generic simplifications based on this. 15943421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = FactorizeBinOp(Instruction::Or, Op0, Op1, Instruction::And, 15950aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse)) 15963421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 15973421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1598b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // If the operation is with the result of a select instruction, check whether 1599b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // operating on either branch of the select always yields the same value. 16000312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) 16010aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadBinOpOverSelect(Instruction::Or, Op0, Op1, Q, 16020312a93693abc2eb682b2b101c889959888fd883Duncan Sands MaxRecurse)) 1603a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return V; 1604a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 1605a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the operation is with the result of a phi instruction, check whether 1606a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // operating on all incoming values of the phi always yields the same value. 16070312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<PHINode>(Op0) || isa<PHINode>(Op1)) 16080aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadBinOpOverPHI(Instruction::Or, Op0, Op1, Q, MaxRecurse)) 1609b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return V; 1610b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 16119f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner return 0; 16129f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner} 16139f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 16143574eca1b02600bac4e625297f4ecf745f4c4f32Micah VillmowValue *llvm::SimplifyOrInst(Value *Op0, Value *Op1, const DataLayout *TD, 1615618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 16161845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const DominatorTree *DT) { 16170aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands return ::SimplifyOrInst(Op0, Op1, Query (TD, TLI, DT), RecursionLimit); 1618a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 1619d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 16202b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands/// SimplifyXorInst - Given operands for a Xor, see if we can 16212b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands/// fold the result. If not, this returns null. 16220aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyXorInst(Value *Op0, Value *Op1, const Query &Q, 16230aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands unsigned MaxRecurse) { 16242b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 16252b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 16262b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands Constant *Ops[] = { CLHS, CRHS }; 16272b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return ConstantFoldInstOperands(Instruction::Xor, CLHS->getType(), 16280aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Ops, Q.TD, Q.TLI); 16292b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands } 16302b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 16312b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // Canonicalize the constant to the RHS. 16322b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands std::swap(Op0, Op1); 16332b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands } 16342b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 16352b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // A ^ undef -> undef 1636f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 1637f8b1a5ea9602bb65a5cf59d3d34f2851a08cdc3eDuncan Sands return Op1; 16382b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 16392b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // A ^ 0 = A 16402b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (match(Op1, m_Zero())) 16412b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return Op0; 16422b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 1643f23d4adbfaf870d5fa67c6bff0da7891d3a98f9dEli Friedman // A ^ A = 0 1644f23d4adbfaf870d5fa67c6bff0da7891d3a98f9dEli Friedman if (Op0 == Op1) 1645f23d4adbfaf870d5fa67c6bff0da7891d3a98f9dEli Friedman return Constant::getNullValue(Op0->getType()); 1646f23d4adbfaf870d5fa67c6bff0da7891d3a98f9dEli Friedman 16472b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // A ^ ~A = ~A ^ A = -1 164881a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner if (match(Op0, m_Not(m_Specific(Op1))) || 164981a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner match(Op1, m_Not(m_Specific(Op0)))) 16502b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return Constant::getAllOnesValue(Op0->getType()); 16512b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 1652566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Try some generic simplifications for associative operations. 16530aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyAssociativeBinOp(Instruction::Xor, Op0, Op1, Q, 16540aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands MaxRecurse)) 1655566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return V; 16562b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 16573421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // And distributes over Xor. Try some generic simplifications based on this. 16583421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = FactorizeBinOp(Instruction::Xor, Op0, Op1, Instruction::And, 16590aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse)) 16603421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 16613421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 166287689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // Threading Xor over selects and phi nodes is pointless, so don't bother. 166387689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // Threading over the select in "A ^ select(cond, B, C)" means evaluating 166487689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // "A^B" and "A^C" and seeing if they are equal; but they are equal if and 166587689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // only if B and C are equal. If B and C are equal then (since we assume 166687689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // that operands have already been simplified) "select(cond, B, C)" should 166787689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // have been simplified to the common value of B and C already. Analysing 166887689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // "A^B" and "A^C" thus gains nothing, but costs compile time. Similarly 166987689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // for threading over phi nodes. 16702b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 16712b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return 0; 16722b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands} 16732b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 16743574eca1b02600bac4e625297f4ecf745f4c4f32Micah VillmowValue *llvm::SimplifyXorInst(Value *Op0, Value *Op1, const DataLayout *TD, 1675618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 16762b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands const DominatorTree *DT) { 16770aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands return ::SimplifyXorInst(Op0, Op1, Query (TD, TLI, DT), RecursionLimit); 16782b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands} 16792b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 1680db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattnerstatic Type *GetCompareTy(Value *Op) { 1681210c5d4880b525e064088b6fec713260128c16ebChris Lattner return CmpInst::makeCmpResultType(Op->getType()); 1682210c5d4880b525e064088b6fec713260128c16ebChris Lattner} 1683210c5d4880b525e064088b6fec713260128c16ebChris Lattner 1684e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands/// ExtractEquivalentCondition - Rummage around inside V looking for something 1685e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands/// equivalent to the comparison "LHS Pred RHS". Return such a value if found, 1686e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands/// otherwise return null. Helper function for analyzing max/min idioms. 1687e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sandsstatic Value *ExtractEquivalentCondition(Value *V, CmpInst::Predicate Pred, 1688e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands Value *LHS, Value *RHS) { 1689e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands SelectInst *SI = dyn_cast<SelectInst>(V); 1690e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (!SI) 1691e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return 0; 1692e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands CmpInst *Cmp = dyn_cast<CmpInst>(SI->getCondition()); 1693e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (!Cmp) 1694e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return 0; 1695e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands Value *CmpLHS = Cmp->getOperand(0), *CmpRHS = Cmp->getOperand(1); 1696e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Pred == Cmp->getPredicate() && LHS == CmpLHS && RHS == CmpRHS) 1697e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return Cmp; 1698e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Pred == CmpInst::getSwappedPredicate(Cmp->getPredicate()) && 1699e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands LHS == CmpRHS && RHS == CmpLHS) 1700e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return Cmp; 1701e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return 0; 1702e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands} 1703e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands 1704901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// A significant optimization not implemented here is assuming that alloca 1705901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// addresses are not equal to incoming argument values. They don't *alias*, 1706901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// as we say, but that doesn't mean they aren't equal, so we take a 1707901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// conservative approach. 1708901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// 1709901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// This is inspired in part by C++11 5.10p1: 1710901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// "Two pointers of the same type compare equal if and only if they are both 1711901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// null, both point to the same function, or both represent the same 1712901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// address." 1713901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// 1714901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// This is pretty permissive. 1715901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// 1716901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// It's also partly due to C11 6.5.9p6: 1717901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// "Two pointers compare equal if and only if both are null pointers, both are 1718901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// pointers to the same object (including a pointer to an object and a 1719901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// subobject at its beginning) or function, both are pointers to one past the 1720901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// last element of the same array object, or one is a pointer to one past the 1721901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// end of one array object and the other is a pointer to the start of a 172292c3742319cc219f8a57aa7d8eea5b17ec93ad06NAKAMURA Takumi// different array object that happens to immediately follow the first array 1723901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// object in the address space.) 1724901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// 1725901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// C11's version is more restrictive, however there's no reason why an argument 1726901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// couldn't be a one-past-the-end value for a stack object in the caller and be 1727901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// equal to the beginning of a stack object in the callee. 1728901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// 1729901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// If the C and C++ standards are ever made sufficiently restrictive in this 1730901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// area, it may be possible to update LLVM's semantics accordingly and reinstate 1731901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// this optimization. 17323e3de565e9c7258fb97773b3a64fc091355cb2deDan Gohmanstatic Constant *computePointerICmp(const DataLayout *TD, 1733fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman const TargetLibraryInfo *TLI, 173458725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth CmpInst::Predicate Pred, 173558725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth Value *LHS, Value *RHS) { 1736fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // First, skip past any trivial no-ops. 1737fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman LHS = LHS->stripPointerCasts(); 1738fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman RHS = RHS->stripPointerCasts(); 1739fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman 1740fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // A non-null pointer is not equal to a null pointer. 1741fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman if (llvm::isKnownNonNull(LHS) && isa<ConstantPointerNull>(RHS) && 1742fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman (Pred == CmpInst::ICMP_EQ || Pred == CmpInst::ICMP_NE)) 1743fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman return ConstantInt::get(GetCompareTy(LHS), 1744fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman !CmpInst::isTrueWhenEqual(Pred)); 1745fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman 174658725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth // We can only fold certain predicates on pointer comparisons. 174758725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth switch (Pred) { 174858725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth default: 174958725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth return 0; 175058725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth 175158725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth // Equality comaprisons are easy to fold. 175258725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth case CmpInst::ICMP_EQ: 175358725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth case CmpInst::ICMP_NE: 175458725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth break; 175558725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth 175658725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth // We can only handle unsigned relational comparisons because 'inbounds' on 175758725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth // a GEP only protects against unsigned wrapping. 175858725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth case CmpInst::ICMP_UGT: 175958725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth case CmpInst::ICMP_UGE: 176058725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth case CmpInst::ICMP_ULT: 176158725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth case CmpInst::ICMP_ULE: 176258725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth // However, we have to switch them to their signed variants to handle 176358725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth // negative indices from the base pointer. 176458725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth Pred = ICmpInst::getSignedPredicate(Pred); 176558725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth break; 176658725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth } 176758725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth 1768fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // Strip off any constant offsets so that we can reason about them. 1769fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // It's tempting to use getUnderlyingObject or even just stripInBoundsOffsets 1770fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // here and compare base addresses like AliasAnalysis does, however there are 1771fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // numerous hazards. AliasAnalysis and its utilities rely on special rules 1772fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // governing loads and stores which don't apply to icmps. Also, AliasAnalysis 1773fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // doesn't need to guarantee pointer inequality when it says NoAlias. 1774d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramer Constant *LHSOffset = stripAndComputeConstantOffsets(TD, LHS); 1775d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramer Constant *RHSOffset = stripAndComputeConstantOffsets(TD, RHS); 1776fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman 1777fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // If LHS and RHS are related via constant offsets to the same base 1778fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // value, we can replace it with an icmp which just compares the offsets. 1779fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman if (LHS == RHS) 1780fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman return ConstantExpr::getICmp(Pred, LHSOffset, RHSOffset); 1781fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman 1782fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // Various optimizations for (in)equality comparisons. 1783fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman if (Pred == CmpInst::ICMP_EQ || Pred == CmpInst::ICMP_NE) { 1784fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // Different non-empty allocations that exist at the same time have 1785fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // different addresses (if the program can tell). Global variables always 1786fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // exist, so they always exist during the lifetime of each other and all 1787fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // allocas. Two different allocas usually have different addresses... 1788fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // 1789fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // However, if there's an @llvm.stackrestore dynamically in between two 1790fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // allocas, they may have the same address. It's tempting to reduce the 1791fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // scope of the problem by only looking at *static* allocas here. That would 1792fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // cover the majority of allocas while significantly reducing the likelihood 1793fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // of having an @llvm.stackrestore pop up in the middle. However, it's not 1794fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // actually impossible for an @llvm.stackrestore to pop up in the middle of 1795fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // an entry block. Also, if we have a block that's not attached to a 1796fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // function, we can't tell if it's "static" under the current definition. 1797fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // Theoretically, this problem could be fixed by creating a new kind of 1798fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // instruction kind specifically for static allocas. Such a new instruction 1799fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // could be required to be at the top of the entry block, thus preventing it 1800fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // from being subject to a @llvm.stackrestore. Instcombine could even 1801fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // convert regular allocas into these special allocas. It'd be nifty. 1802fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // However, until then, this problem remains open. 1803fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // 1804fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // So, we'll assume that two non-empty allocas have different addresses 1805fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // for now. 1806fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // 1807fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // With all that, if the offsets are within the bounds of their allocations 1808fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // (and not one-past-the-end! so we can't use inbounds!), and their 1809fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // allocations aren't the same, the pointers are not equal. 1810fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // 1811fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // Note that it's not necessary to check for LHS being a global variable 1812fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // address, due to canonicalization and constant folding. 1813fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman if (isa<AllocaInst>(LHS) && 1814fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman (isa<AllocaInst>(RHS) || isa<GlobalVariable>(RHS))) { 1815d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramer ConstantInt *LHSOffsetCI = dyn_cast<ConstantInt>(LHSOffset); 1816d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramer ConstantInt *RHSOffsetCI = dyn_cast<ConstantInt>(RHSOffset); 1817fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman uint64_t LHSSize, RHSSize; 1818d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramer if (LHSOffsetCI && RHSOffsetCI && 1819d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramer getObjectSize(LHS, LHSSize, TD, TLI) && 1820fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman getObjectSize(RHS, RHSSize, TD, TLI)) { 1821d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramer const APInt &LHSOffsetValue = LHSOffsetCI->getValue(); 1822d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramer const APInt &RHSOffsetValue = RHSOffsetCI->getValue(); 1823fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman if (!LHSOffsetValue.isNegative() && 1824fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman !RHSOffsetValue.isNegative() && 1825fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman LHSOffsetValue.ult(LHSSize) && 1826fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman RHSOffsetValue.ult(RHSSize)) { 1827fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman return ConstantInt::get(GetCompareTy(LHS), 1828fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman !CmpInst::isTrueWhenEqual(Pred)); 1829fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman } 1830fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman } 183158725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth 1832fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // Repeat the above check but this time without depending on DataLayout 1833fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // or being able to compute a precise size. 1834fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman if (!cast<PointerType>(LHS->getType())->isEmptyTy() && 1835fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman !cast<PointerType>(RHS->getType())->isEmptyTy() && 1836fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman LHSOffset->isNullValue() && 1837fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman RHSOffset->isNullValue()) 1838fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman return ConstantInt::get(GetCompareTy(LHS), 1839fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman !CmpInst::isTrueWhenEqual(Pred)); 1840fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman } 1841fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman } 184258725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth 1843fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // Otherwise, fail. 1844fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman return 0; 184558725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth} 1846009e2650d69fe93bda1864340c5f000e56c52fb8Chris Lattner 18479dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// SimplifyICmpInst - Given operands for an ICmpInst, see if we can 18489dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// fold the result. If not, this returns null. 1849a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS, 18500aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 18519f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner CmpInst::Predicate Pred = (CmpInst::Predicate)Predicate; 18529dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner assert(CmpInst::isIntPredicate(Pred) && "Not an integer compare!"); 185312a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1854d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(LHS)) { 18558f73deaa8732a556046bf4ac6207be55972e3b74Chris Lattner if (Constant *CRHS = dyn_cast<Constant>(RHS)) 18560aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands return ConstantFoldCompareInstOperands(Pred, CLHS, CRHS, Q.TD, Q.TLI); 1857d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 1858d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // If we have a constant, make sure it is on the RHS. 1859d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner std::swap(LHS, RHS); 1860d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Pred = CmpInst::getSwappedPredicate(Pred); 1861d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 186212a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1863db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *ITy = GetCompareTy(LHS); // The return type. 1864db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *OpTy = LHS->getType(); // The operand type. 186512a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1866210c5d4880b525e064088b6fec713260128c16ebChris Lattner // icmp X, X -> true/false 1867c8e14b3d37b80abb6adb4b831af0452d9ecbf2b2Chris Lattner // X icmp undef -> true/false. For example, icmp ugt %X, undef -> false 1868c8e14b3d37b80abb6adb4b831af0452d9ecbf2b2Chris Lattner // because X could be 0. 1869124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (LHS == RHS || isa<UndefValue>(RHS)) 1870210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(ITy, CmpInst::isTrueWhenEqual(Pred)); 187112a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 18726dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // Special case logic when the operands have i1 type. 187366d004ef708642bbdc38fd761507f2e9ee3970cdNick Lewycky if (OpTy->getScalarType()->isIntegerTy(1)) { 18746dc91253ab1872e118b08511a09d5c934988354eDuncan Sands switch (Pred) { 18756dc91253ab1872e118b08511a09d5c934988354eDuncan Sands default: break; 18766dc91253ab1872e118b08511a09d5c934988354eDuncan Sands case ICmpInst::ICMP_EQ: 18776dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // X == 1 -> X 18786dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (match(RHS, m_One())) 18796dc91253ab1872e118b08511a09d5c934988354eDuncan Sands return LHS; 18806dc91253ab1872e118b08511a09d5c934988354eDuncan Sands break; 18816dc91253ab1872e118b08511a09d5c934988354eDuncan Sands case ICmpInst::ICMP_NE: 18826dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // X != 0 -> X 18836dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (match(RHS, m_Zero())) 18846dc91253ab1872e118b08511a09d5c934988354eDuncan Sands return LHS; 18856dc91253ab1872e118b08511a09d5c934988354eDuncan Sands break; 18866dc91253ab1872e118b08511a09d5c934988354eDuncan Sands case ICmpInst::ICMP_UGT: 18876dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // X >u 0 -> X 18886dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (match(RHS, m_Zero())) 18896dc91253ab1872e118b08511a09d5c934988354eDuncan Sands return LHS; 18906dc91253ab1872e118b08511a09d5c934988354eDuncan Sands break; 18916dc91253ab1872e118b08511a09d5c934988354eDuncan Sands case ICmpInst::ICMP_UGE: 18926dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // X >=u 1 -> X 18936dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (match(RHS, m_One())) 18946dc91253ab1872e118b08511a09d5c934988354eDuncan Sands return LHS; 18956dc91253ab1872e118b08511a09d5c934988354eDuncan Sands break; 18966dc91253ab1872e118b08511a09d5c934988354eDuncan Sands case ICmpInst::ICMP_SLT: 18976dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // X <s 0 -> X 18986dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (match(RHS, m_Zero())) 18996dc91253ab1872e118b08511a09d5c934988354eDuncan Sands return LHS; 19006dc91253ab1872e118b08511a09d5c934988354eDuncan Sands break; 19016dc91253ab1872e118b08511a09d5c934988354eDuncan Sands case ICmpInst::ICMP_SLE: 19026dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // X <=s -1 -> X 19036dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (match(RHS, m_One())) 19046dc91253ab1872e118b08511a09d5c934988354eDuncan Sands return LHS; 19056dc91253ab1872e118b08511a09d5c934988354eDuncan Sands break; 19066dc91253ab1872e118b08511a09d5c934988354eDuncan Sands } 19076dc91253ab1872e118b08511a09d5c934988354eDuncan Sands } 190812a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1909d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands // If we are comparing with zero then try hard since this is a common case. 1910d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (match(RHS, m_Zero())) { 1911d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands bool LHSKnownNonNegative, LHSKnownNegative; 1912d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands switch (Pred) { 1913858143816d43e58b17bfd11cb1b57afbd7f0f893Craig Topper default: llvm_unreachable("Unknown ICmp predicate!"); 1914d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_ULT: 1915f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 1916d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_UGE: 1917f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 1918d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_EQ: 1919d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_ULE: 19200aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (isKnownNonZero(LHS, Q.TD)) 1921f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 1922d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands break; 1923d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_NE: 1924d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_UGT: 19250aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (isKnownNonZero(LHS, Q.TD)) 1926f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 1927d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands break; 1928d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_SLT: 19290aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, Q.TD); 1930d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNegative) 1931f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 1932d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNonNegative) 1933f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 1934d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands break; 1935d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_SLE: 19360aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, Q.TD); 1937d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNegative) 1938f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 19390aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (LHSKnownNonNegative && isKnownNonZero(LHS, Q.TD)) 1940f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 1941d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands break; 1942d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_SGE: 19430aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, Q.TD); 1944d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNegative) 1945f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 1946d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNonNegative) 1947f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 1948d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands break; 1949d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_SGT: 19500aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, Q.TD); 1951d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNegative) 1952f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 19530aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (LHSKnownNonNegative && isKnownNonZero(LHS, Q.TD)) 1954f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 1955d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands break; 1956d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands } 1957d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands } 1958d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands 1959d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands // See if we are doing a comparison with a constant integer. 1960210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) { 19613a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // Rule out tautological comparisons (eg., ult 0 or uge 0). 19623a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky ConstantRange RHS_CR = ICmpInst::makeConstantRange(Pred, CI->getValue()); 19633a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (RHS_CR.isEmptySet()) 19643a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky return ConstantInt::getFalse(CI->getContext()); 19653a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (RHS_CR.isFullSet()) 19663a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky return ConstantInt::getTrue(CI->getContext()); 19673a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky 19683a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // Many binary operators with constant RHS have easy to compute constant 19693a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // range. Use them to check whether the comparison is a tautology. 19703a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky uint32_t Width = CI->getBitWidth(); 19713a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt Lower = APInt(Width, 0); 19723a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt Upper = APInt(Width, 0); 19733a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky ConstantInt *CI2; 19743a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (match(LHS, m_URem(m_Value(), m_ConstantInt(CI2)))) { 19753a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'urem x, CI2' produces [0, CI2). 19763a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = CI2->getValue(); 19773a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_SRem(m_Value(), m_ConstantInt(CI2)))) { 19783a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'srem x, CI2' produces (-|CI2|, |CI2|). 19793a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = CI2->getValue().abs(); 19803a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Lower = (-Upper) + 1; 1981c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands } else if (match(LHS, m_UDiv(m_ConstantInt(CI2), m_Value()))) { 1982c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands // 'udiv CI2, x' produces [0, CI2]. 19837781ae5be570940178295f6f808215089a3fe411Eli Friedman Upper = CI2->getValue() + 1; 19843a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_UDiv(m_Value(), m_ConstantInt(CI2)))) { 19853a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'udiv x, CI2' produces [0, UINT_MAX / CI2]. 19863a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt NegOne = APInt::getAllOnesValue(Width); 19873a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (!CI2->isZero()) 19883a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = NegOne.udiv(CI2->getValue()) + 1; 19893a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_SDiv(m_Value(), m_ConstantInt(CI2)))) { 19903a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'sdiv x, CI2' produces [INT_MIN / CI2, INT_MAX / CI2]. 19913a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt IntMin = APInt::getSignedMinValue(Width); 19923a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt IntMax = APInt::getSignedMaxValue(Width); 19933a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt Val = CI2->getValue().abs(); 19943a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (!Val.isMinValue()) { 19953a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Lower = IntMin.sdiv(Val); 19963a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = IntMax.sdiv(Val) + 1; 19973a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } 19983a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_LShr(m_Value(), m_ConstantInt(CI2)))) { 19993a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'lshr x, CI2' produces [0, UINT_MAX >> CI2]. 20003a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt NegOne = APInt::getAllOnesValue(Width); 20013a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (CI2->getValue().ult(Width)) 20023a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = NegOne.lshr(CI2->getValue()) + 1; 20033a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_AShr(m_Value(), m_ConstantInt(CI2)))) { 20043a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'ashr x, CI2' produces [INT_MIN >> CI2, INT_MAX >> CI2]. 20053a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt IntMin = APInt::getSignedMinValue(Width); 20063a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt IntMax = APInt::getSignedMaxValue(Width); 20073a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (CI2->getValue().ult(Width)) { 20083a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Lower = IntMin.ashr(CI2->getValue()); 20093a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = IntMax.ashr(CI2->getValue()) + 1; 20103a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } 20113a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_Or(m_Value(), m_ConstantInt(CI2)))) { 20123a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'or x, CI2' produces [CI2, UINT_MAX]. 20133a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Lower = CI2->getValue(); 20143a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_And(m_Value(), m_ConstantInt(CI2)))) { 20153a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'and x, CI2' produces [0, CI2]. 20163a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = CI2->getValue() + 1; 20173a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } 20183a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (Lower != Upper) { 20193a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky ConstantRange LHS_CR = ConstantRange(Lower, Upper); 20203a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (RHS_CR.contains(LHS_CR)) 20213a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky return ConstantInt::getTrue(RHS->getContext()); 20223a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (RHS_CR.inverse().contains(LHS_CR)) 20233a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky return ConstantInt::getFalse(RHS->getContext()); 2024210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 2025210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 20261ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands 20279d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Compare of cast, for example (zext X) != 0 -> X != 0 20289d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (isa<CastInst>(LHS) && (isa<Constant>(RHS) || isa<CastInst>(RHS))) { 20299d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Instruction *LI = cast<CastInst>(LHS); 20309d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Value *SrcOp = LI->getOperand(0); 2031db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *SrcTy = SrcOp->getType(); 2032db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *DstTy = LI->getType(); 20339d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 20349d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Turn icmp (ptrtoint x), (ptrtoint/constant) into a compare of the input 20359d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // if the integer type is the same size as the pointer type. 20360aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (MaxRecurse && Q.TD && isa<PtrToIntInst>(LI) && 2037426c2bf5cdd2173e4a33aea8cb92cf684a724f4bChandler Carruth Q.TD->getPointerSizeInBits() == DstTy->getPrimitiveSizeInBits()) { 20389d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Constant *RHSC = dyn_cast<Constant>(RHS)) { 20399d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Transfer the cast to the constant. 20409d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(Pred, SrcOp, 20419d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantExpr::getIntToPtr(RHSC, SrcTy), 20420aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse-1)) 20439d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 20449d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } else if (PtrToIntInst *RI = dyn_cast<PtrToIntInst>(RHS)) { 20459d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (RI->getOperand(0)->getType() == SrcTy) 20469d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Compare without the cast. 20479d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(Pred, SrcOp, RI->getOperand(0), 20480aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse-1)) 20499d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 20509d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 20519d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 20529d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 20539d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (isa<ZExtInst>(LHS)) { 20549d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Turn icmp (zext X), (zext Y) into a compare of X and Y if they have the 20559d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // same type. 20569d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (ZExtInst *RI = dyn_cast<ZExtInst>(RHS)) { 20579d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (MaxRecurse && SrcTy == RI->getOperand(0)->getType()) 20589d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Compare X and Y. Note that signed predicates become unsigned. 20599d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(ICmpInst::getUnsignedPredicate(Pred), 20600aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands SrcOp, RI->getOperand(0), Q, 20619d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands MaxRecurse-1)) 20629d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 20639d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 20649d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Turn icmp (zext X), Cst into a compare of X and Cst if Cst is extended 20659d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // too. If not, then try to deduce the result of the comparison. 20669d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands else if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) { 20679d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Compute the constant that would happen if we truncated to SrcTy then 20689d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // reextended to DstTy. 20699d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant *Trunc = ConstantExpr::getTrunc(CI, SrcTy); 20709d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant *RExt = ConstantExpr::getCast(CastInst::ZExt, Trunc, DstTy); 20719d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 20729d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // If the re-extended constant didn't change then this is effectively 20739d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // also a case of comparing two zero-extended values. 20749d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (RExt == CI && MaxRecurse) 20759d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(ICmpInst::getUnsignedPredicate(Pred), 20760aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands SrcOp, Trunc, Q, MaxRecurse-1)) 20779d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 20789d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 20799d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Otherwise the upper bits of LHS are zero while RHS has a non-zero bit 20809d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // there. Use this to work out the result of the comparison. 20819d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (RExt != CI) { 20829d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands switch (Pred) { 2083858143816d43e58b17bfd11cb1b57afbd7f0f893Craig Topper default: llvm_unreachable("Unknown ICmp predicate!"); 20849d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // LHS <u RHS. 20859d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_EQ: 20869d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_UGT: 20879d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_UGE: 20889d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return ConstantInt::getFalse(CI->getContext()); 20899d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 20909d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_NE: 20919d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_ULT: 20929d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_ULE: 20939d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return ConstantInt::getTrue(CI->getContext()); 20949d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 20959d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // LHS is non-negative. If RHS is negative then LHS >s LHS. If RHS 20969d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // is non-negative then LHS <s RHS. 20979d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SGT: 20989d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SGE: 20999d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return CI->getValue().isNegative() ? 21009d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getTrue(CI->getContext()) : 21019d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getFalse(CI->getContext()); 21029d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 21039d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SLT: 21049d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SLE: 21059d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return CI->getValue().isNegative() ? 21069d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getFalse(CI->getContext()) : 21079d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getTrue(CI->getContext()); 21089d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 21099d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 21109d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 21119d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 21129d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 21139d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (isa<SExtInst>(LHS)) { 21149d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Turn icmp (sext X), (sext Y) into a compare of X and Y if they have the 21159d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // same type. 21169d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (SExtInst *RI = dyn_cast<SExtInst>(RHS)) { 21179d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (MaxRecurse && SrcTy == RI->getOperand(0)->getType()) 21189d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Compare X and Y. Note that the predicate does not change. 21199d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(Pred, SrcOp, RI->getOperand(0), 21200aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse-1)) 21219d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 21229d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 21239d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Turn icmp (sext X), Cst into a compare of X and Cst if Cst is extended 21249d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // too. If not, then try to deduce the result of the comparison. 21259d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands else if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) { 21269d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Compute the constant that would happen if we truncated to SrcTy then 21279d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // reextended to DstTy. 21289d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant *Trunc = ConstantExpr::getTrunc(CI, SrcTy); 21299d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant *RExt = ConstantExpr::getCast(CastInst::SExt, Trunc, DstTy); 21309d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 21319d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // If the re-extended constant didn't change then this is effectively 21329d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // also a case of comparing two sign-extended values. 21339d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (RExt == CI && MaxRecurse) 21340aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyICmpInst(Pred, SrcOp, Trunc, Q, MaxRecurse-1)) 21359d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 21369d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 21379d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Otherwise the upper bits of LHS are all equal, while RHS has varying 21389d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // bits there. Use this to work out the result of the comparison. 21399d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (RExt != CI) { 21409d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands switch (Pred) { 2141858143816d43e58b17bfd11cb1b57afbd7f0f893Craig Topper default: llvm_unreachable("Unknown ICmp predicate!"); 21429d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_EQ: 21439d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return ConstantInt::getFalse(CI->getContext()); 21449d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_NE: 21459d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return ConstantInt::getTrue(CI->getContext()); 21469d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 21479d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // If RHS is non-negative then LHS <s RHS. If RHS is negative then 21489d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // LHS >s RHS. 21499d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SGT: 21509d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SGE: 21519d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return CI->getValue().isNegative() ? 21529d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getTrue(CI->getContext()) : 21539d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getFalse(CI->getContext()); 21549d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SLT: 21559d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SLE: 21569d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return CI->getValue().isNegative() ? 21579d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getFalse(CI->getContext()) : 21589d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getTrue(CI->getContext()); 21599d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 21609d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // If LHS is non-negative then LHS <u RHS. If LHS is negative then 21619d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // LHS >u RHS. 21629d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_UGT: 21639d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_UGE: 216494c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // Comparison is true iff the LHS <s 0. 21659d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (MaxRecurse) 21669d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(ICmpInst::ICMP_SLT, SrcOp, 21679d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant::getNullValue(SrcTy), 21680aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse-1)) 21699d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 21709d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands break; 21719d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_ULT: 21729d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_ULE: 217394c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // Comparison is true iff the LHS >=s 0. 21749d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (MaxRecurse) 21759d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(ICmpInst::ICMP_SGE, SrcOp, 21769d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant::getNullValue(SrcTy), 21770aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse-1)) 21789d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 21799d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands break; 21809d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 21819d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 21829d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 21839d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 21849d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 21859d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 218652fb846578714d14bbde9b28884a6a8729217677Duncan Sands // Special logic for binary operators. 218752fb846578714d14bbde9b28884a6a8729217677Duncan Sands BinaryOperator *LBO = dyn_cast<BinaryOperator>(LHS); 218852fb846578714d14bbde9b28884a6a8729217677Duncan Sands BinaryOperator *RBO = dyn_cast<BinaryOperator>(RHS); 218952fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (MaxRecurse && (LBO || RBO)) { 219052fb846578714d14bbde9b28884a6a8729217677Duncan Sands // Analyze the case when either LHS or RHS is an add instruction. 219152fb846578714d14bbde9b28884a6a8729217677Duncan Sands Value *A = 0, *B = 0, *C = 0, *D = 0; 219252fb846578714d14bbde9b28884a6a8729217677Duncan Sands // LHS = A + B (or A and B are null); RHS = C + D (or C and D are null). 219352fb846578714d14bbde9b28884a6a8729217677Duncan Sands bool NoLHSWrapProblem = false, NoRHSWrapProblem = false; 219452fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (LBO && LBO->getOpcode() == Instruction::Add) { 219552fb846578714d14bbde9b28884a6a8729217677Duncan Sands A = LBO->getOperand(0); B = LBO->getOperand(1); 219652fb846578714d14bbde9b28884a6a8729217677Duncan Sands NoLHSWrapProblem = ICmpInst::isEquality(Pred) || 219752fb846578714d14bbde9b28884a6a8729217677Duncan Sands (CmpInst::isUnsigned(Pred) && LBO->hasNoUnsignedWrap()) || 219852fb846578714d14bbde9b28884a6a8729217677Duncan Sands (CmpInst::isSigned(Pred) && LBO->hasNoSignedWrap()); 219952fb846578714d14bbde9b28884a6a8729217677Duncan Sands } 220052fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (RBO && RBO->getOpcode() == Instruction::Add) { 220152fb846578714d14bbde9b28884a6a8729217677Duncan Sands C = RBO->getOperand(0); D = RBO->getOperand(1); 220252fb846578714d14bbde9b28884a6a8729217677Duncan Sands NoRHSWrapProblem = ICmpInst::isEquality(Pred) || 220352fb846578714d14bbde9b28884a6a8729217677Duncan Sands (CmpInst::isUnsigned(Pred) && RBO->hasNoUnsignedWrap()) || 220452fb846578714d14bbde9b28884a6a8729217677Duncan Sands (CmpInst::isSigned(Pred) && RBO->hasNoSignedWrap()); 220552fb846578714d14bbde9b28884a6a8729217677Duncan Sands } 220652fb846578714d14bbde9b28884a6a8729217677Duncan Sands 220752fb846578714d14bbde9b28884a6a8729217677Duncan Sands // icmp (X+Y), X -> icmp Y, 0 for equalities or if there is no overflow. 220852fb846578714d14bbde9b28884a6a8729217677Duncan Sands if ((A == RHS || B == RHS) && NoLHSWrapProblem) 220952fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (Value *V = SimplifyICmpInst(Pred, A == RHS ? B : A, 221052fb846578714d14bbde9b28884a6a8729217677Duncan Sands Constant::getNullValue(RHS->getType()), 22110aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse-1)) 221252fb846578714d14bbde9b28884a6a8729217677Duncan Sands return V; 221352fb846578714d14bbde9b28884a6a8729217677Duncan Sands 221452fb846578714d14bbde9b28884a6a8729217677Duncan Sands // icmp X, (X+Y) -> icmp 0, Y for equalities or if there is no overflow. 221552fb846578714d14bbde9b28884a6a8729217677Duncan Sands if ((C == LHS || D == LHS) && NoRHSWrapProblem) 221652fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (Value *V = SimplifyICmpInst(Pred, 221752fb846578714d14bbde9b28884a6a8729217677Duncan Sands Constant::getNullValue(LHS->getType()), 22180aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands C == LHS ? D : C, Q, MaxRecurse-1)) 221952fb846578714d14bbde9b28884a6a8729217677Duncan Sands return V; 222052fb846578714d14bbde9b28884a6a8729217677Duncan Sands 222152fb846578714d14bbde9b28884a6a8729217677Duncan Sands // icmp (X+Y), (X+Z) -> icmp Y,Z for equalities or if there is no overflow. 222252fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (A && C && (A == C || A == D || B == C || B == D) && 222352fb846578714d14bbde9b28884a6a8729217677Duncan Sands NoLHSWrapProblem && NoRHSWrapProblem) { 222452fb846578714d14bbde9b28884a6a8729217677Duncan Sands // Determine Y and Z in the form icmp (X+Y), (X+Z). 2225aceb03eb58778ae4a2811d2c2bbd23e0e0cf49b5Duncan Sands Value *Y, *Z; 2226aceb03eb58778ae4a2811d2c2bbd23e0e0cf49b5Duncan Sands if (A == C) { 22274f0dfbb454ea8110459e2d1ee5f92e74cb3e8a5cDuncan Sands // C + B == C + D -> B == D 2228aceb03eb58778ae4a2811d2c2bbd23e0e0cf49b5Duncan Sands Y = B; 2229aceb03eb58778ae4a2811d2c2bbd23e0e0cf49b5Duncan Sands Z = D; 2230aceb03eb58778ae4a2811d2c2bbd23e0e0cf49b5Duncan Sands } else if (A == D) { 22314f0dfbb454ea8110459e2d1ee5f92e74cb3e8a5cDuncan Sands // D + B == C + D -> B == C 2232aceb03eb58778ae4a2811d2c2bbd23e0e0cf49b5Duncan Sands Y = B; 2233aceb03eb58778ae4a2811d2c2bbd23e0e0cf49b5Duncan Sands Z = C; 2234aceb03eb58778ae4a2811d2c2bbd23e0e0cf49b5Duncan Sands } else if (B == C) { 22354f0dfbb454ea8110459e2d1ee5f92e74cb3e8a5cDuncan Sands // A + C == C + D -> A == D 2236aceb03eb58778ae4a2811d2c2bbd23e0e0cf49b5Duncan Sands Y = A; 2237aceb03eb58778ae4a2811d2c2bbd23e0e0cf49b5Duncan Sands Z = D; 22384f0dfbb454ea8110459e2d1ee5f92e74cb3e8a5cDuncan Sands } else { 22394f0dfbb454ea8110459e2d1ee5f92e74cb3e8a5cDuncan Sands assert(B == D); 22404f0dfbb454ea8110459e2d1ee5f92e74cb3e8a5cDuncan Sands // A + D == C + D -> A == C 2241aceb03eb58778ae4a2811d2c2bbd23e0e0cf49b5Duncan Sands Y = A; 2242aceb03eb58778ae4a2811d2c2bbd23e0e0cf49b5Duncan Sands Z = C; 2243aceb03eb58778ae4a2811d2c2bbd23e0e0cf49b5Duncan Sands } 22440aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyICmpInst(Pred, Y, Z, Q, MaxRecurse-1)) 224552fb846578714d14bbde9b28884a6a8729217677Duncan Sands return V; 224652fb846578714d14bbde9b28884a6a8729217677Duncan Sands } 224752fb846578714d14bbde9b28884a6a8729217677Duncan Sands } 224852fb846578714d14bbde9b28884a6a8729217677Duncan Sands 224984dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky if (LBO && match(LBO, m_URem(m_Value(), m_Specific(RHS)))) { 2250786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky bool KnownNonNegative, KnownNegative; 225188cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky switch (Pred) { 225288cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky default: 225388cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky break; 2254786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky case ICmpInst::ICMP_SGT: 2255786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky case ICmpInst::ICMP_SGE: 22560aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands ComputeSignBit(LHS, KnownNonNegative, KnownNegative, Q.TD); 2257786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky if (!KnownNonNegative) 2258786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky break; 2259786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky // fall-through 226088cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky case ICmpInst::ICMP_EQ: 226188cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky case ICmpInst::ICMP_UGT: 226288cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky case ICmpInst::ICMP_UGE: 2263f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 2264786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky case ICmpInst::ICMP_SLT: 2265786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky case ICmpInst::ICMP_SLE: 22660aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands ComputeSignBit(LHS, KnownNonNegative, KnownNegative, Q.TD); 2267786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky if (!KnownNonNegative) 2268786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky break; 2269786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky // fall-through 227088cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky case ICmpInst::ICMP_NE: 227188cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky case ICmpInst::ICMP_ULT: 227288cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky case ICmpInst::ICMP_ULE: 2273f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 227488cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky } 227588cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky } 227684dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky if (RBO && match(RBO, m_URem(m_Value(), m_Specific(LHS)))) { 227784dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky bool KnownNonNegative, KnownNegative; 227884dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky switch (Pred) { 227984dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky default: 228084dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky break; 228184dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_SGT: 228284dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_SGE: 22830aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands ComputeSignBit(RHS, KnownNonNegative, KnownNegative, Q.TD); 228484dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky if (!KnownNonNegative) 228584dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky break; 228684dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky // fall-through 2287a0e2f38b25ce7c51c22ed40d8a315fe1dd98926dNick Lewycky case ICmpInst::ICMP_NE: 228884dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_UGT: 228984dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_UGE: 2290f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 229184dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_SLT: 229284dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_SLE: 22930aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands ComputeSignBit(RHS, KnownNonNegative, KnownNegative, Q.TD); 229484dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky if (!KnownNonNegative) 229584dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky break; 229684dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky // fall-through 2297a0e2f38b25ce7c51c22ed40d8a315fe1dd98926dNick Lewycky case ICmpInst::ICMP_EQ: 229884dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_ULT: 229984dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_ULE: 2300f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 230184dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky } 230284dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky } 230388cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky 2304c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands // x udiv y <=u x. 2305c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands if (LBO && match(LBO, m_UDiv(m_Specific(RHS), m_Value()))) { 2306c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands // icmp pred (X /u Y), X 2307c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands if (Pred == ICmpInst::ICMP_UGT) 2308c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands return getFalse(ITy); 2309c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands if (Pred == ICmpInst::ICMP_ULE) 2310c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands return getTrue(ITy); 2311c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands } 2312c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands 231358bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (MaxRecurse && LBO && RBO && LBO->getOpcode() == RBO->getOpcode() && 231458bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky LBO->getOperand(1) == RBO->getOperand(1)) { 231558bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky switch (LBO->getOpcode()) { 231658bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky default: break; 231758bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::UDiv: 231858bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::LShr: 231958bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (ICmpInst::isSigned(Pred)) 232058bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 232158bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky // fall-through 232258bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::SDiv: 232358bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::AShr: 2324b6e7cd655c6ee119dbeacc321ee92387f983edb0Eli Friedman if (!LBO->isExact() || !RBO->isExact()) 232558bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 232658bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (Value *V = SimplifyICmpInst(Pred, LBO->getOperand(0), 23270aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands RBO->getOperand(0), Q, MaxRecurse-1)) 232858bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky return V; 232958bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 233058bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::Shl: { 2331c9d904ee2ca36ab6238ed93c7ad2ea67b5fd0a23Duncan Sands bool NUW = LBO->hasNoUnsignedWrap() && RBO->hasNoUnsignedWrap(); 233258bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky bool NSW = LBO->hasNoSignedWrap() && RBO->hasNoSignedWrap(); 233358bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (!NUW && !NSW) 233458bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 233558bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (!NSW && ICmpInst::isSigned(Pred)) 233658bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 233758bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (Value *V = SimplifyICmpInst(Pred, LBO->getOperand(0), 23380aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands RBO->getOperand(0), Q, MaxRecurse-1)) 233958bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky return V; 234058bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 234158bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky } 234258bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky } 234358bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky } 234458bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky 2345ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Simplify comparisons involving max/min. 2346ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands Value *A, *B; 2347ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands CmpInst::Predicate P = CmpInst::BAD_ICMP_PREDICATE; 234894c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru CmpInst::Predicate EqP; // Chosen so that "A == max/min(A,B)" iff "A EqP B". 2349ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands 23508140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Signed variants on "max(a,b)>=a -> true". 2351ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (match(LHS, m_SMax(m_Value(A), m_Value(B))) && (A == RHS || B == RHS)) { 2352ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != RHS) std::swap(A, B); // smax(A, B) pred A. 235394c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru EqP = CmpInst::ICMP_SGE; // "A == smax(A, B)" iff "A sge B". 2354ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as smax(A, B) pred A. 2355ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = Pred; 2356ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } else if (match(RHS, m_SMax(m_Value(A), m_Value(B))) && 2357ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands (A == LHS || B == LHS)) { 2358ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != LHS) std::swap(A, B); // A pred smax(A, B). 235994c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru EqP = CmpInst::ICMP_SGE; // "A == smax(A, B)" iff "A sge B". 2360ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as smax(A, B) swapped-pred A. 2361ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = CmpInst::getSwappedPredicate(Pred); 2362ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } else if (match(LHS, m_SMin(m_Value(A), m_Value(B))) && 2363ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands (A == RHS || B == RHS)) { 2364ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != RHS) std::swap(A, B); // smin(A, B) pred A. 236594c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru EqP = CmpInst::ICMP_SLE; // "A == smin(A, B)" iff "A sle B". 2366ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as smax(-A, -B) swapped-pred -A. 2367ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Note that we do not need to actually form -A or -B thanks to EqP. 2368ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = CmpInst::getSwappedPredicate(Pred); 2369ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } else if (match(RHS, m_SMin(m_Value(A), m_Value(B))) && 2370ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands (A == LHS || B == LHS)) { 2371ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != LHS) std::swap(A, B); // A pred smin(A, B). 237294c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru EqP = CmpInst::ICMP_SLE; // "A == smin(A, B)" iff "A sle B". 2373ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as smax(-A, -B) pred -A. 2374ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Note that we do not need to actually form -A or -B thanks to EqP. 2375ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = Pred; 2376ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } 2377ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (P != CmpInst::BAD_ICMP_PREDICATE) { 2378ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Cases correspond to "max(A, B) p A". 2379ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands switch (P) { 2380ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands default: 2381ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands break; 2382ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_EQ: 2383ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_SLE: 2384e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Equivalent to "A EqP B". This may be the same as the condition tested 2385e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // in the max/min; if so, we can just return that. 2386e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(LHS, EqP, A, B)) 2387e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2388e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(RHS, EqP, A, B)) 2389e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2390e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Otherwise, see if "A EqP B" simplifies. 2391ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (MaxRecurse) 23920aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyICmpInst(EqP, A, B, Q, MaxRecurse-1)) 2393ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands return V; 2394ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands break; 2395ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_NE: 2396e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands case CmpInst::ICMP_SGT: { 2397e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands CmpInst::Predicate InvEqP = CmpInst::getInversePredicate(EqP); 2398e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Equivalent to "A InvEqP B". This may be the same as the condition 2399e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // tested in the max/min; if so, we can just return that. 2400e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(LHS, InvEqP, A, B)) 2401e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2402e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(RHS, InvEqP, A, B)) 2403e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2404e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Otherwise, see if "A InvEqP B" simplifies. 2405ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (MaxRecurse) 24060aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyICmpInst(InvEqP, A, B, Q, MaxRecurse-1)) 2407ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands return V; 2408ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands break; 2409e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands } 2410ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_SGE: 2411ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Always true. 2412f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 2413ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_SLT: 2414ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Always false. 2415f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 2416ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } 2417ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } 2418ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands 24198140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Unsigned variants on "max(a,b)>=a -> true". 2420ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = CmpInst::BAD_ICMP_PREDICATE; 2421ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (match(LHS, m_UMax(m_Value(A), m_Value(B))) && (A == RHS || B == RHS)) { 2422ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != RHS) std::swap(A, B); // umax(A, B) pred A. 242394c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru EqP = CmpInst::ICMP_UGE; // "A == umax(A, B)" iff "A uge B". 2424ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as umax(A, B) pred A. 2425ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = Pred; 2426ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } else if (match(RHS, m_UMax(m_Value(A), m_Value(B))) && 2427ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands (A == LHS || B == LHS)) { 2428ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != LHS) std::swap(A, B); // A pred umax(A, B). 242994c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru EqP = CmpInst::ICMP_UGE; // "A == umax(A, B)" iff "A uge B". 2430ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as umax(A, B) swapped-pred A. 2431ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = CmpInst::getSwappedPredicate(Pred); 2432ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } else if (match(LHS, m_UMin(m_Value(A), m_Value(B))) && 2433ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands (A == RHS || B == RHS)) { 2434ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != RHS) std::swap(A, B); // umin(A, B) pred A. 243594c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru EqP = CmpInst::ICMP_ULE; // "A == umin(A, B)" iff "A ule B". 2436ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as umax(-A, -B) swapped-pred -A. 2437ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Note that we do not need to actually form -A or -B thanks to EqP. 2438ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = CmpInst::getSwappedPredicate(Pred); 2439ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } else if (match(RHS, m_UMin(m_Value(A), m_Value(B))) && 2440ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands (A == LHS || B == LHS)) { 2441ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != LHS) std::swap(A, B); // A pred umin(A, B). 244294c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru EqP = CmpInst::ICMP_ULE; // "A == umin(A, B)" iff "A ule B". 2443ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as umax(-A, -B) pred -A. 2444ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Note that we do not need to actually form -A or -B thanks to EqP. 2445ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = Pred; 2446ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } 2447ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (P != CmpInst::BAD_ICMP_PREDICATE) { 2448ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Cases correspond to "max(A, B) p A". 2449ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands switch (P) { 2450ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands default: 2451ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands break; 2452ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_EQ: 2453ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_ULE: 2454e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Equivalent to "A EqP B". This may be the same as the condition tested 2455e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // in the max/min; if so, we can just return that. 2456e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(LHS, EqP, A, B)) 2457e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2458e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(RHS, EqP, A, B)) 2459e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2460e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Otherwise, see if "A EqP B" simplifies. 2461ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (MaxRecurse) 24620aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyICmpInst(EqP, A, B, Q, MaxRecurse-1)) 2463ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands return V; 2464ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands break; 2465ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_NE: 2466e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands case CmpInst::ICMP_UGT: { 2467e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands CmpInst::Predicate InvEqP = CmpInst::getInversePredicate(EqP); 2468e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Equivalent to "A InvEqP B". This may be the same as the condition 2469e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // tested in the max/min; if so, we can just return that. 2470e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(LHS, InvEqP, A, B)) 2471e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2472e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(RHS, InvEqP, A, B)) 2473e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2474e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Otherwise, see if "A InvEqP B" simplifies. 2475ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (MaxRecurse) 24760aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyICmpInst(InvEqP, A, B, Q, MaxRecurse-1)) 2477ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands return V; 2478ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands break; 2479e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands } 2480ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_UGE: 2481ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Always true. 2482f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 2483ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_ULT: 2484ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Always false. 2485f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 2486ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } 2487ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } 2488ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands 24898140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Variants on "max(x,y) >= min(x,z)". 24908140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands Value *C, *D; 24918140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (match(LHS, m_SMax(m_Value(A), m_Value(B))) && 24928140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands match(RHS, m_SMin(m_Value(C), m_Value(D))) && 24938140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands (A == C || A == D || B == C || B == D)) { 24948140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // max(x, ?) pred min(x, ?). 24958140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_SGE) 24968140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always true. 2497f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 24988140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_SLT) 24998140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always false. 2500f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 25018140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands } else if (match(LHS, m_SMin(m_Value(A), m_Value(B))) && 25028140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands match(RHS, m_SMax(m_Value(C), m_Value(D))) && 25038140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands (A == C || A == D || B == C || B == D)) { 25048140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // min(x, ?) pred max(x, ?). 25058140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_SLE) 25068140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always true. 2507f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 25088140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_SGT) 25098140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always false. 2510f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 25118140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands } else if (match(LHS, m_UMax(m_Value(A), m_Value(B))) && 25128140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands match(RHS, m_UMin(m_Value(C), m_Value(D))) && 25138140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands (A == C || A == D || B == C || B == D)) { 25148140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // max(x, ?) pred min(x, ?). 25158140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_UGE) 25168140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always true. 2517f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 25188140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_ULT) 25198140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always false. 2520f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 25218140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands } else if (match(LHS, m_UMin(m_Value(A), m_Value(B))) && 25228140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands match(RHS, m_UMax(m_Value(C), m_Value(D))) && 25238140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands (A == C || A == D || B == C || B == D)) { 25248140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // min(x, ?) pred max(x, ?). 25258140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_ULE) 25268140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always true. 2527f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 25288140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_UGT) 25298140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always false. 2530f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 25318140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands } 25328140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands 253358725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth // Simplify comparisons of related pointers using a powerful, recursive 253458725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth // GEP-walk when we have target data available.. 25353e3de565e9c7258fb97773b3a64fc091355cb2deDan Gohman if (LHS->getType()->isPointerTy()) 2536fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman if (Constant *C = computePointerICmp(Q.TD, Q.TLI, Pred, LHS, RHS)) 253758725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth return C; 253858725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth 2539f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky if (GetElementPtrInst *GLHS = dyn_cast<GetElementPtrInst>(LHS)) { 2540f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky if (GEPOperator *GRHS = dyn_cast<GEPOperator>(RHS)) { 2541f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky if (GLHS->getPointerOperand() == GRHS->getPointerOperand() && 2542f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky GLHS->hasAllConstantIndices() && GRHS->hasAllConstantIndices() && 2543f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky (ICmpInst::isEquality(Pred) || 2544f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky (GLHS->isInBounds() && GRHS->isInBounds() && 2545f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky Pred == ICmpInst::getSignedPredicate(Pred)))) { 2546f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky // The bases are equal and the indices are constant. Build a constant 2547f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky // expression GEP with the same indices and a null base pointer to see 2548f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky // what constant folding can make out of it. 2549f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky Constant *Null = Constant::getNullValue(GLHS->getPointerOperandType()); 2550f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky SmallVector<Value *, 4> IndicesLHS(GLHS->idx_begin(), GLHS->idx_end()); 2551f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky Constant *NewLHS = ConstantExpr::getGetElementPtr(Null, IndicesLHS); 2552f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky 2553f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky SmallVector<Value *, 4> IndicesRHS(GRHS->idx_begin(), GRHS->idx_end()); 2554f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky Constant *NewRHS = ConstantExpr::getGetElementPtr(Null, IndicesRHS); 2555f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky return ConstantExpr::getICmp(Pred, NewLHS, NewRHS); 2556f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky } 2557f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky } 2558f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky } 2559f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky 25601ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands // If the comparison is with the result of a select instruction, check whether 25611ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands // comparing with either branch of the select always yields the same value. 25620312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<SelectInst>(LHS) || isa<SelectInst>(RHS)) 25630aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadCmpOverSelect(Pred, LHS, RHS, Q, MaxRecurse)) 2564a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return V; 2565a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 2566a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the comparison is with the result of a phi instruction, check whether 2567a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // doing the compare with each incoming phi value yields a common result. 25680312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<PHINode>(LHS) || isa<PHINode>(RHS)) 25690aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadCmpOverPHI(Pred, LHS, RHS, Q, MaxRecurse)) 25703bbb0cc42b67b4bf2c488285666999963bab0f7eDuncan Sands return V; 25711ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands 25729dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner return 0; 25739dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner} 25749dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 2575a74a58c83be492b7d5b7383656f049909394cff4Duncan SandsValue *llvm::SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS, 25763574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow const DataLayout *TD, 2577618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 2578618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT) { 25790aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands return ::SimplifyICmpInst(Predicate, LHS, RHS, Query (TD, TLI, DT), 25800aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands RecursionLimit); 2581a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 2582a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 25839dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// SimplifyFCmpInst - Given operands for an FCmpInst, see if we can 25849dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// fold the result. If not, this returns null. 2585a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *SimplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS, 25860aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 25879dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner CmpInst::Predicate Pred = (CmpInst::Predicate)Predicate; 25889dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner assert(CmpInst::isFPPredicate(Pred) && "Not an FP compare!"); 25899dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 2590d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(LHS)) { 25919dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner if (Constant *CRHS = dyn_cast<Constant>(RHS)) 25920aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands return ConstantFoldCompareInstOperands(Pred, CLHS, CRHS, Q.TD, Q.TLI); 259312a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2594d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // If we have a constant, make sure it is on the RHS. 2595d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner std::swap(LHS, RHS); 2596d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Pred = CmpInst::getSwappedPredicate(Pred); 2597d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 259812a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2599210c5d4880b525e064088b6fec713260128c16ebChris Lattner // Fold trivial predicates. 2600210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (Pred == FCmpInst::FCMP_FALSE) 2601210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(GetCompareTy(LHS), 0); 2602210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (Pred == FCmpInst::FCMP_TRUE) 2603210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(GetCompareTy(LHS), 1); 2604210c5d4880b525e064088b6fec713260128c16ebChris Lattner 2605210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (isa<UndefValue>(RHS)) // fcmp pred X, undef -> undef 2606210c5d4880b525e064088b6fec713260128c16ebChris Lattner return UndefValue::get(GetCompareTy(LHS)); 2607210c5d4880b525e064088b6fec713260128c16ebChris Lattner 2608210c5d4880b525e064088b6fec713260128c16ebChris Lattner // fcmp x,x -> true/false. Not all compares are foldable. 2609124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (LHS == RHS) { 2610210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (CmpInst::isTrueWhenEqual(Pred)) 2611210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(GetCompareTy(LHS), 1); 2612210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (CmpInst::isFalseWhenEqual(Pred)) 2613210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(GetCompareTy(LHS), 0); 2614210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 261512a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2616210c5d4880b525e064088b6fec713260128c16ebChris Lattner // Handle fcmp with constant RHS 2617210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (Constant *RHSC = dyn_cast<Constant>(RHS)) { 2618210c5d4880b525e064088b6fec713260128c16ebChris Lattner // If the constant is a nan, see if we can fold the comparison based on it. 2619210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (ConstantFP *CFP = dyn_cast<ConstantFP>(RHSC)) { 2620210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (CFP->getValueAPF().isNaN()) { 2621210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (FCmpInst::isOrdered(Pred)) // True "if ordered and foo" 2622210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::getFalse(CFP->getContext()); 2623210c5d4880b525e064088b6fec713260128c16ebChris Lattner assert(FCmpInst::isUnordered(Pred) && 2624210c5d4880b525e064088b6fec713260128c16ebChris Lattner "Comparison must be either ordered or unordered!"); 2625210c5d4880b525e064088b6fec713260128c16ebChris Lattner // True if unordered. 2626210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::getTrue(CFP->getContext()); 2627210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 26286b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // Check whether the constant is an infinity. 26296b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman if (CFP->getValueAPF().isInfinity()) { 26306b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman if (CFP->getValueAPF().isNegative()) { 26316b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman switch (Pred) { 26326b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman case FCmpInst::FCMP_OLT: 26336b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // No value is ordered and less than negative infinity. 26346b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman return ConstantInt::getFalse(CFP->getContext()); 26356b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman case FCmpInst::FCMP_UGE: 26366b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // All values are unordered with or at least negative infinity. 26376b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman return ConstantInt::getTrue(CFP->getContext()); 26386b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman default: 26396b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman break; 26406b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } 26416b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } else { 26426b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman switch (Pred) { 26436b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman case FCmpInst::FCMP_OGT: 26446b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // No value is ordered and greater than infinity. 26456b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman return ConstantInt::getFalse(CFP->getContext()); 26466b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman case FCmpInst::FCMP_ULE: 26476b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // All values are unordered with and at most infinity. 26486b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman return ConstantInt::getTrue(CFP->getContext()); 26496b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman default: 26506b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman break; 26516b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } 26526b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } 26536b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } 2654210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 2655210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 265612a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 265792826def593df7a422c7b07f09342febce81ddd3Duncan Sands // If the comparison is with the result of a select instruction, check whether 265892826def593df7a422c7b07f09342febce81ddd3Duncan Sands // comparing with either branch of the select always yields the same value. 26590312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<SelectInst>(LHS) || isa<SelectInst>(RHS)) 26600aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadCmpOverSelect(Pred, LHS, RHS, Q, MaxRecurse)) 2661a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return V; 2662a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 2663a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the comparison is with the result of a phi instruction, check whether 2664a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // doing the compare with each incoming phi value yields a common result. 26650312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<PHINode>(LHS) || isa<PHINode>(RHS)) 26660aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadCmpOverPHI(Pred, LHS, RHS, Q, MaxRecurse)) 26673bbb0cc42b67b4bf2c488285666999963bab0f7eDuncan Sands return V; 266892826def593df7a422c7b07f09342febce81ddd3Duncan Sands 26699f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner return 0; 26709f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner} 26719f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 2672a74a58c83be492b7d5b7383656f049909394cff4Duncan SandsValue *llvm::SimplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS, 26733574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow const DataLayout *TD, 2674618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 2675618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT) { 26760aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands return ::SimplifyFCmpInst(Predicate, LHS, RHS, Query (TD, TLI, DT), 26770aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands RecursionLimit); 2678a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 2679a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 2680047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner/// SimplifySelectInst - Given operands for a SelectInst, see if we can fold 2681047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner/// the result. If not, this returns null. 26820aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifySelectInst(Value *CondVal, Value *TrueVal, 26830aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Value *FalseVal, const Query &Q, 26840aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands unsigned MaxRecurse) { 2685047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner // select true, X, Y -> X 2686047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner // select false, X, Y -> Y 2687047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner if (ConstantInt *CB = dyn_cast<ConstantInt>(CondVal)) 2688047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return CB->getZExtValue() ? TrueVal : FalseVal; 268912a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2690047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner // select C, X, X -> X 2691124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (TrueVal == FalseVal) 2692047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return TrueVal; 269312a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2694047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner if (isa<UndefValue>(CondVal)) { // select undef, X, Y -> X or Y 2695047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner if (isa<Constant>(TrueVal)) 2696047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return TrueVal; 2697047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return FalseVal; 2698047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner } 269968c0dbc14fb7599987fb3e27be4e12c1ac36535eDan Gohman if (isa<UndefValue>(TrueVal)) // select C, undef, X -> X 270068c0dbc14fb7599987fb3e27be4e12c1ac36535eDan Gohman return FalseVal; 270168c0dbc14fb7599987fb3e27be4e12c1ac36535eDan Gohman if (isa<UndefValue>(FalseVal)) // select C, X, undef -> X 270268c0dbc14fb7599987fb3e27be4e12c1ac36535eDan Gohman return TrueVal; 270312a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2704047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return 0; 2705047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner} 2706047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner 27070aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan SandsValue *llvm::SimplifySelectInst(Value *Cond, Value *TrueVal, Value *FalseVal, 27083574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow const DataLayout *TD, 27090aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const TargetLibraryInfo *TLI, 27100aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const DominatorTree *DT) { 27110aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands return ::SimplifySelectInst(Cond, TrueVal, FalseVal, Query (TD, TLI, DT), 27120aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands RecursionLimit); 27130aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands} 27140aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands 2715c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner/// SimplifyGEPInst - Given operands for an GetElementPtrInst, see if we can 2716c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner/// fold the result. If not, this returns null. 27170aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyGEPInst(ArrayRef<Value *> Ops, const Query &Q, unsigned) { 271885bbff6c94695f07cc1a9765b4d384ed18d2fd7cDuncan Sands // The type of the GEP pointer operand. 27191608769abeb1430dc34f31ffac0d9850f99ae36aNadav Rotem PointerType *PtrTy = dyn_cast<PointerType>(Ops[0]->getType()); 27201608769abeb1430dc34f31ffac0d9850f99ae36aNadav Rotem // The GEP pointer operand is not a pointer, it's a vector of pointers. 27211608769abeb1430dc34f31ffac0d9850f99ae36aNadav Rotem if (!PtrTy) 27221608769abeb1430dc34f31ffac0d9850f99ae36aNadav Rotem return 0; 272385bbff6c94695f07cc1a9765b4d384ed18d2fd7cDuncan Sands 2724c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner // getelementptr P -> P. 2725b9b54ebfed02f0654897d37e8a4448d3f8087558Jay Foad if (Ops.size() == 1) 2726c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner return Ops[0]; 2727c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner 272885bbff6c94695f07cc1a9765b4d384ed18d2fd7cDuncan Sands if (isa<UndefValue>(Ops[0])) { 272985bbff6c94695f07cc1a9765b4d384ed18d2fd7cDuncan Sands // Compute the (pointer) type returned by the GEP instruction. 2730a9203109f4ac95aa7e9624f2838e3d89623ec902Jay Foad Type *LastType = GetElementPtrInst::getIndexedType(PtrTy, Ops.slice(1)); 2731db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *GEPTy = PointerType::get(LastType, PtrTy->getAddressSpace()); 273285bbff6c94695f07cc1a9765b4d384ed18d2fd7cDuncan Sands return UndefValue::get(GEPTy); 273385bbff6c94695f07cc1a9765b4d384ed18d2fd7cDuncan Sands } 2734c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner 2735b9b54ebfed02f0654897d37e8a4448d3f8087558Jay Foad if (Ops.size() == 2) { 2736e60d79faf7ef7bc4847f9e5d067af00b98dced7bDuncan Sands // getelementptr P, 0 -> P. 2737c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner if (ConstantInt *C = dyn_cast<ConstantInt>(Ops[1])) 2738c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner if (C->isZero()) 2739c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner return Ops[0]; 2740e60d79faf7ef7bc4847f9e5d067af00b98dced7bDuncan Sands // getelementptr P, N -> P if P points to a type of zero size. 27410aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Q.TD) { 2742db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty = PtrTy->getElementType(); 27430aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Ty->isSized() && Q.TD->getTypeAllocSize(Ty) == 0) 2744e60d79faf7ef7bc4847f9e5d067af00b98dced7bDuncan Sands return Ops[0]; 2745e60d79faf7ef7bc4847f9e5d067af00b98dced7bDuncan Sands } 2746e60d79faf7ef7bc4847f9e5d067af00b98dced7bDuncan Sands } 274712a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2748c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner // Check to see if this is constant foldable. 2749b9b54ebfed02f0654897d37e8a4448d3f8087558Jay Foad for (unsigned i = 0, e = Ops.size(); i != e; ++i) 2750c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner if (!isa<Constant>(Ops[i])) 2751c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner return 0; 275212a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2753dab3d29605a5c83db41b28176273ef55961120c1Jay Foad return ConstantExpr::getGetElementPtr(cast<Constant>(Ops[0]), Ops.slice(1)); 2754c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner} 2755c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner 27563574eca1b02600bac4e625297f4ecf745f4c4f32Micah VillmowValue *llvm::SimplifyGEPInst(ArrayRef<Value *> Ops, const DataLayout *TD, 27570aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const TargetLibraryInfo *TLI, 27580aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const DominatorTree *DT) { 27590aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands return ::SimplifyGEPInst(Ops, Query (TD, TLI, DT), RecursionLimit); 27600aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands} 27610aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands 2762dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands/// SimplifyInsertValueInst - Given operands for an InsertValueInst, see if we 2763dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands/// can fold the result. If not, this returns null. 27640aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyInsertValueInst(Value *Agg, Value *Val, 27650aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands ArrayRef<unsigned> Idxs, const Query &Q, 27660aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands unsigned) { 2767dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands if (Constant *CAgg = dyn_cast<Constant>(Agg)) 2768dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands if (Constant *CVal = dyn_cast<Constant>(Val)) 2769dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands return ConstantFoldInsertValueInstruction(CAgg, CVal, Idxs); 2770dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands 2771dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands // insertvalue x, undef, n -> x 2772dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands if (match(Val, m_Undef())) 2773dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands return Agg; 2774dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands 2775dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands // insertvalue x, (extractvalue y, n), n 2776dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands if (ExtractValueInst *EV = dyn_cast<ExtractValueInst>(Val)) 2777ae707bd5594e52a8b385760f99ff58aa8fede948Benjamin Kramer if (EV->getAggregateOperand()->getType() == Agg->getType() && 2778ae707bd5594e52a8b385760f99ff58aa8fede948Benjamin Kramer EV->getIndices() == Idxs) { 2779dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands // insertvalue undef, (extractvalue y, n), n -> y 2780dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands if (match(Agg, m_Undef())) 2781dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands return EV->getAggregateOperand(); 2782dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands 2783dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands // insertvalue y, (extractvalue y, n), n -> y 2784dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands if (Agg == EV->getAggregateOperand()) 2785dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands return Agg; 2786dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands } 2787dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands 2788dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands return 0; 2789dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands} 2790dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands 27910aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan SandsValue *llvm::SimplifyInsertValueInst(Value *Agg, Value *Val, 27920aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands ArrayRef<unsigned> Idxs, 27933574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow const DataLayout *TD, 27940aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const TargetLibraryInfo *TLI, 27950aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const DominatorTree *DT) { 27960aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands return ::SimplifyInsertValueInst(Agg, Val, Idxs, Query (TD, TLI, DT), 27970aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands RecursionLimit); 27980aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands} 27990aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands 2800ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands/// SimplifyPHINode - See if we can fold the given phi. If not, returns null. 28010aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyPHINode(PHINode *PN, const Query &Q) { 2802ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // If all of the PHI's incoming values are the same then replace the PHI node 2803ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // with the common value. 2804ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands Value *CommonValue = 0; 2805ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands bool HasUndefInput = false; 2806ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) { 2807ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands Value *Incoming = PN->getIncomingValue(i); 2808ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // If the incoming value is the phi node itself, it can safely be skipped. 2809ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands if (Incoming == PN) continue; 2810ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands if (isa<UndefValue>(Incoming)) { 2811ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // Remember that we saw an undef value, but otherwise ignore them. 2812ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands HasUndefInput = true; 2813ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands continue; 2814ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands } 2815ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands if (CommonValue && Incoming != CommonValue) 2816ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands return 0; // Not the same, bail out. 2817ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands CommonValue = Incoming; 2818ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands } 2819ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands 2820ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // If CommonValue is null then all of the incoming values were either undef or 2821ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // equal to the phi node itself. 2822ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands if (!CommonValue) 2823ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands return UndefValue::get(PN->getType()); 2824ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands 2825ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // If we have a PHI node like phi(X, undef, X), where X is defined by some 2826ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // instruction, we cannot return X as the result of the PHI node unless it 2827ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // dominates the PHI block. 2828ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands if (HasUndefInput) 28290aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands return ValueDominatesPHI(CommonValue, PN, Q.DT) ? CommonValue : 0; 2830ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands 2831ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands return CommonValue; 2832ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands} 2833ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands 2834bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sandsstatic Value *SimplifyTruncInst(Value *Op, Type *Ty, const Query &Q, unsigned) { 2835bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands if (Constant *C = dyn_cast<Constant>(Op)) 2836bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands return ConstantFoldInstOperands(Instruction::Trunc, Ty, C, Q.TD, Q.TLI); 2837bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands 2838bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands return 0; 2839bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands} 2840bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands 28413574eca1b02600bac4e625297f4ecf745f4c4f32Micah VillmowValue *llvm::SimplifyTruncInst(Value *Op, Type *Ty, const DataLayout *TD, 2842bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands const TargetLibraryInfo *TLI, 2843bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands const DominatorTree *DT) { 2844bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands return ::SimplifyTruncInst(Op, Ty, Query (TD, TLI, DT), RecursionLimit); 2845bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands} 2846bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands 2847d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner//=== Helper functions for higher up the class hierarchy. 28489dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 2849d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner/// SimplifyBinOp - Given operands for a BinaryOperator, see if we can 2850d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner/// fold the result. If not, this returns null. 2851a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *SimplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS, 28520aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 2853d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner switch (Opcode) { 285481a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner case Instruction::Add: 2855ffeb98ad3becfbb8e26270ef8751e37e4b6b0cd1Duncan Sands return SimplifyAddInst(LHS, RHS, /*isNSW*/false, /*isNUW*/false, 28560aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse); 2857d0a0d221da55f5e2d97909991d77e7ab91e75426Michael Ilseman case Instruction::FAdd: 2858d0a0d221da55f5e2d97909991d77e7ab91e75426Michael Ilseman return SimplifyFAddInst(LHS, RHS, FastMathFlags(), Q, MaxRecurse); 2859d0a0d221da55f5e2d97909991d77e7ab91e75426Michael Ilseman 286081a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner case Instruction::Sub: 2861ffeb98ad3becfbb8e26270ef8751e37e4b6b0cd1Duncan Sands return SimplifySubInst(LHS, RHS, /*isNSW*/false, /*isNUW*/false, 28620aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse); 2863d0a0d221da55f5e2d97909991d77e7ab91e75426Michael Ilseman case Instruction::FSub: 2864d0a0d221da55f5e2d97909991d77e7ab91e75426Michael Ilseman return SimplifyFSubInst(LHS, RHS, FastMathFlags(), Q, MaxRecurse); 2865d0a0d221da55f5e2d97909991d77e7ab91e75426Michael Ilseman 28660aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands case Instruction::Mul: return SimplifyMulInst (LHS, RHS, Q, MaxRecurse); 2867d0a0d221da55f5e2d97909991d77e7ab91e75426Michael Ilseman case Instruction::FMul: 2868d0a0d221da55f5e2d97909991d77e7ab91e75426Michael Ilseman return SimplifyFMulInst (LHS, RHS, FastMathFlags(), Q, MaxRecurse); 28690aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands case Instruction::SDiv: return SimplifySDivInst(LHS, RHS, Q, MaxRecurse); 28700aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands case Instruction::UDiv: return SimplifyUDivInst(LHS, RHS, Q, MaxRecurse); 28710aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands case Instruction::FDiv: return SimplifyFDivInst(LHS, RHS, Q, MaxRecurse); 28720aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands case Instruction::SRem: return SimplifySRemInst(LHS, RHS, Q, MaxRecurse); 28730aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands case Instruction::URem: return SimplifyURemInst(LHS, RHS, Q, MaxRecurse); 28740aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands case Instruction::FRem: return SimplifyFRemInst(LHS, RHS, Q, MaxRecurse); 287581a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner case Instruction::Shl: 2876ffeb98ad3becfbb8e26270ef8751e37e4b6b0cd1Duncan Sands return SimplifyShlInst(LHS, RHS, /*isNSW*/false, /*isNUW*/false, 28770aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse); 287881a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner case Instruction::LShr: 28790aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands return SimplifyLShrInst(LHS, RHS, /*isExact*/false, Q, MaxRecurse); 288081a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner case Instruction::AShr: 28810aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands return SimplifyAShrInst(LHS, RHS, /*isExact*/false, Q, MaxRecurse); 28820aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands case Instruction::And: return SimplifyAndInst(LHS, RHS, Q, MaxRecurse); 28830aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands case Instruction::Or: return SimplifyOrInst (LHS, RHS, Q, MaxRecurse); 28840aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands case Instruction::Xor: return SimplifyXorInst(LHS, RHS, Q, MaxRecurse); 2885d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner default: 2886d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(LHS)) 2887d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CRHS = dyn_cast<Constant>(RHS)) { 2888d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Constant *COps[] = {CLHS, CRHS}; 28890aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands return ConstantFoldInstOperands(Opcode, LHS->getType(), COps, Q.TD, 28900aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q.TLI); 2891d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 2892b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 2893566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // If the operation is associative, try some generic simplifications. 2894566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Instruction::isAssociative(Opcode)) 28950aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyAssociativeBinOp(Opcode, LHS, RHS, Q, MaxRecurse)) 2896566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return V; 2897566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 28980aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands // If the operation is with the result of a select instruction check whether 2899b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // operating on either branch of the select always yields the same value. 29000312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<SelectInst>(LHS) || isa<SelectInst>(RHS)) 29010aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadBinOpOverSelect(Opcode, LHS, RHS, Q, MaxRecurse)) 2902a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return V; 2903a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 2904a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the operation is with the result of a phi instruction, check whether 2905a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // operating on all incoming values of the phi always yields the same value. 29060312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<PHINode>(LHS) || isa<PHINode>(RHS)) 29070aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadBinOpOverPHI(Opcode, LHS, RHS, Q, MaxRecurse)) 2908b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return V; 2909b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 2910d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return 0; 2911d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 2912d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner} 29139dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 291412a86f5b3199e72e6d967781acc76340f5920e46Duncan SandsValue *llvm::SimplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS, 29153574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow const DataLayout *TD, const TargetLibraryInfo *TLI, 2916618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT) { 29170aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands return ::SimplifyBinOp(Opcode, LHS, RHS, Query (TD, TLI, DT), RecursionLimit); 2918a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 2919a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 29209dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// SimplifyCmpInst - Given operands for a CmpInst, see if we can 29219dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// fold the result. 2922a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *SimplifyCmpInst(unsigned Predicate, Value *LHS, Value *RHS, 29230aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 29249dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner if (CmpInst::isIntPredicate((CmpInst::Predicate)Predicate)) 29250aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands return SimplifyICmpInst(Predicate, LHS, RHS, Q, MaxRecurse); 29260aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands return SimplifyFCmpInst(Predicate, LHS, RHS, Q, MaxRecurse); 29279dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner} 29289dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 2929a74a58c83be492b7d5b7383656f049909394cff4Duncan SandsValue *llvm::SimplifyCmpInst(unsigned Predicate, Value *LHS, Value *RHS, 29303574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow const DataLayout *TD, const TargetLibraryInfo *TLI, 2931618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT) { 29320aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands return ::SimplifyCmpInst(Predicate, LHS, RHS, Query (TD, TLI, DT), 29330aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands RecursionLimit); 2934a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 2935e34537856a544c83513e390ac9552a8bc3823346Chris Lattner 2936f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilsemanstatic bool IsIdempotent(Intrinsic::ID ID) { 2937f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman switch (ID) { 2938f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman default: return false; 2939f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman 2940f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman // Unary idempotent: f(f(x)) = f(x) 2941f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman case Intrinsic::fabs: 2942f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman case Intrinsic::floor: 2943f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman case Intrinsic::ceil: 2944f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman case Intrinsic::trunc: 2945f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman case Intrinsic::rint: 2946f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman case Intrinsic::nearbyint: 2947f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman return true; 2948f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman } 2949f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman} 2950f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman 2951f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilsemantemplate <typename IterTy> 2952f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilsemanstatic Value *SimplifyIntrinsic(Intrinsic::ID IID, IterTy ArgBegin, IterTy ArgEnd, 2953f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman const Query &Q, unsigned MaxRecurse) { 2954f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman // Perform idempotent optimizations 2955f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman if (!IsIdempotent(IID)) 2956f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman return 0; 2957f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman 2958f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman // Unary Ops 2959f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman if (std::distance(ArgBegin, ArgEnd) == 1) 2960f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(*ArgBegin)) 2961f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman if (II->getIntrinsicID() == IID) 2962f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman return II; 2963f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman 2964f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman return 0; 2965f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman} 2966f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman 2967c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruthtemplate <typename IterTy> 2968e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruthstatic Value *SimplifyCall(Value *V, IterTy ArgBegin, IterTy ArgEnd, 2969c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth const Query &Q, unsigned MaxRecurse) { 2970e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth Type *Ty = V->getType(); 2971c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth if (PointerType *PTy = dyn_cast<PointerType>(Ty)) 2972c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth Ty = PTy->getElementType(); 2973c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth FunctionType *FTy = cast<FunctionType>(Ty); 2974c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth 297571d050315704c23b235594d3fad5268c12d825e3Dan Gohman // call undef -> undef 2976e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth if (isa<UndefValue>(V)) 2977c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth return UndefValue::get(FTy->getReturnType()); 297871d050315704c23b235594d3fad5268c12d825e3Dan Gohman 2979e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth Function *F = dyn_cast<Function>(V); 2980e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth if (!F) 2981e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth return 0; 2982e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth 2983f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman if (unsigned IID = F->getIntrinsicID()) 2984f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman if (Value *Ret = 2985f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman SimplifyIntrinsic((Intrinsic::ID) IID, ArgBegin, ArgEnd, Q, MaxRecurse)) 2986f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman return Ret; 2987f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman 2988e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth if (!canConstantFoldCallTo(F)) 2989e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth return 0; 2990e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth 2991e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth SmallVector<Constant *, 4> ConstantArgs; 2992e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth ConstantArgs.reserve(ArgEnd - ArgBegin); 2993e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth for (IterTy I = ArgBegin, E = ArgEnd; I != E; ++I) { 2994e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth Constant *C = dyn_cast<Constant>(*I); 2995e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth if (!C) 2996e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth return 0; 2997e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth ConstantArgs.push_back(C); 2998e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth } 2999e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth 3000e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth return ConstantFoldCall(F, ConstantArgs, Q.TLI); 300171d050315704c23b235594d3fad5268c12d825e3Dan Gohman} 300271d050315704c23b235594d3fad5268c12d825e3Dan Gohman 3003e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler CarruthValue *llvm::SimplifyCall(Value *V, User::op_iterator ArgBegin, 3004c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth User::op_iterator ArgEnd, const DataLayout *TD, 3005c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth const TargetLibraryInfo *TLI, 3006c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth const DominatorTree *DT) { 3007e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth return ::SimplifyCall(V, ArgBegin, ArgEnd, Query(TD, TLI, DT), 3008c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth RecursionLimit); 3009c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth} 3010c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth 3011e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler CarruthValue *llvm::SimplifyCall(Value *V, ArrayRef<Value *> Args, 3012c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth const DataLayout *TD, const TargetLibraryInfo *TLI, 3013c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth const DominatorTree *DT) { 3014e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth return ::SimplifyCall(V, Args.begin(), Args.end(), Query(TD, TLI, DT), 3015c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth RecursionLimit); 3016c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth} 3017c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth 3018e34537856a544c83513e390ac9552a8bc3823346Chris Lattner/// SimplifyInstruction - See if we can compute a simplified version of this 3019e34537856a544c83513e390ac9552a8bc3823346Chris Lattner/// instruction. If not, this returns null. 30203574eca1b02600bac4e625297f4ecf745f4c4f32Micah VillmowValue *llvm::SimplifyInstruction(Instruction *I, const DataLayout *TD, 3021618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 3022eff0581583ef10e2872e9baf537a04b67d992101Duncan Sands const DominatorTree *DT) { 3023d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands Value *Result; 3024d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands 3025e34537856a544c83513e390ac9552a8bc3823346Chris Lattner switch (I->getOpcode()) { 3026e34537856a544c83513e390ac9552a8bc3823346Chris Lattner default: 3027618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Result = ConstantFoldInstruction(I, TD, TLI); 3028d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 302909ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman case Instruction::FAdd: 303009ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman Result = SimplifyFAddInst(I->getOperand(0), I->getOperand(1), 303109ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman I->getFastMathFlags(), TD, TLI, DT); 303209ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman break; 30338aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner case Instruction::Add: 3034d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands Result = SimplifyAddInst(I->getOperand(0), I->getOperand(1), 3035d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands cast<BinaryOperator>(I)->hasNoSignedWrap(), 3036d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands cast<BinaryOperator>(I)->hasNoUnsignedWrap(), 3037618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT); 3038d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 303909ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman case Instruction::FSub: 304009ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman Result = SimplifyFSubInst(I->getOperand(0), I->getOperand(1), 304109ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman I->getFastMathFlags(), TD, TLI, DT); 304209ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman break; 3043fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands case Instruction::Sub: 3044fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands Result = SimplifySubInst(I->getOperand(0), I->getOperand(1), 3045fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands cast<BinaryOperator>(I)->hasNoSignedWrap(), 3046fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands cast<BinaryOperator>(I)->hasNoUnsignedWrap(), 3047618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT); 3048fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands break; 3049eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman case Instruction::FMul: 3050eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman Result = SimplifyFMulInst(I->getOperand(0), I->getOperand(1), 3051eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman I->getFastMathFlags(), TD, TLI, DT); 3052eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman break; 305382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands case Instruction::Mul: 3054618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Result = SimplifyMulInst(I->getOperand(0), I->getOperand(1), TD, TLI, DT); 305582fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands break; 3056593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands case Instruction::SDiv: 3057618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Result = SimplifySDivInst(I->getOperand(0), I->getOperand(1), TD, TLI, DT); 3058593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands break; 3059593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands case Instruction::UDiv: 3060618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Result = SimplifyUDivInst(I->getOperand(0), I->getOperand(1), TD, TLI, DT); 3061593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands break; 30621fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel case Instruction::FDiv: 3063618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Result = SimplifyFDivInst(I->getOperand(0), I->getOperand(1), TD, TLI, DT); 30641fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel break; 3065f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands case Instruction::SRem: 3066618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Result = SimplifySRemInst(I->getOperand(0), I->getOperand(1), TD, TLI, DT); 3067f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands break; 3068f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands case Instruction::URem: 3069618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Result = SimplifyURemInst(I->getOperand(0), I->getOperand(1), TD, TLI, DT); 3070f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands break; 3071f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands case Instruction::FRem: 3072618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Result = SimplifyFRemInst(I->getOperand(0), I->getOperand(1), TD, TLI, DT); 3073f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands break; 3074c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands case Instruction::Shl: 307581a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Result = SimplifyShlInst(I->getOperand(0), I->getOperand(1), 307681a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner cast<BinaryOperator>(I)->hasNoSignedWrap(), 307781a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner cast<BinaryOperator>(I)->hasNoUnsignedWrap(), 3078618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT); 3079c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands break; 3080c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands case Instruction::LShr: 308181a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Result = SimplifyLShrInst(I->getOperand(0), I->getOperand(1), 308281a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner cast<BinaryOperator>(I)->isExact(), 3083618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT); 3084c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands break; 3085c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands case Instruction::AShr: 308681a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Result = SimplifyAShrInst(I->getOperand(0), I->getOperand(1), 308781a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner cast<BinaryOperator>(I)->isExact(), 3088618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT); 3089c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands break; 3090e34537856a544c83513e390ac9552a8bc3823346Chris Lattner case Instruction::And: 3091618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Result = SimplifyAndInst(I->getOperand(0), I->getOperand(1), TD, TLI, DT); 3092d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 3093e34537856a544c83513e390ac9552a8bc3823346Chris Lattner case Instruction::Or: 3094618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Result = SimplifyOrInst(I->getOperand(0), I->getOperand(1), TD, TLI, DT); 3095d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 30962b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands case Instruction::Xor: 3097618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Result = SimplifyXorInst(I->getOperand(0), I->getOperand(1), TD, TLI, DT); 30982b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands break; 3099e34537856a544c83513e390ac9552a8bc3823346Chris Lattner case Instruction::ICmp: 3100d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands Result = SimplifyICmpInst(cast<ICmpInst>(I)->getPredicate(), 3101618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier I->getOperand(0), I->getOperand(1), TD, TLI, DT); 3102d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 3103e34537856a544c83513e390ac9552a8bc3823346Chris Lattner case Instruction::FCmp: 3104d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands Result = SimplifyFCmpInst(cast<FCmpInst>(I)->getPredicate(), 3105618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier I->getOperand(0), I->getOperand(1), TD, TLI, DT); 3106d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 3107047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner case Instruction::Select: 3108d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands Result = SimplifySelectInst(I->getOperand(0), I->getOperand(1), 31090aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands I->getOperand(2), TD, TLI, DT); 3110d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 3111c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner case Instruction::GetElementPtr: { 3112c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner SmallVector<Value*, 8> Ops(I->op_begin(), I->op_end()); 31130aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Result = SimplifyGEPInst(Ops, TD, TLI, DT); 3114d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 3115c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner } 3116dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands case Instruction::InsertValue: { 3117dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands InsertValueInst *IV = cast<InsertValueInst>(I); 3118dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands Result = SimplifyInsertValueInst(IV->getAggregateOperand(), 3119dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands IV->getInsertedValueOperand(), 31200aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands IV->getIndices(), TD, TLI, DT); 3121dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands break; 3122dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands } 3123cd6636c737a82949ad13db2d0d918af6424fb78bDuncan Sands case Instruction::PHI: 31240aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Result = SimplifyPHINode(cast<PHINode>(I), Query (TD, TLI, DT)); 3125d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 3126c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth case Instruction::Call: { 3127c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth CallSite CS(cast<CallInst>(I)); 3128c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth Result = SimplifyCall(CS.getCalledValue(), CS.arg_begin(), CS.arg_end(), 3129c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth TD, TLI, DT); 313071d050315704c23b235594d3fad5268c12d825e3Dan Gohman break; 3131c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth } 3132bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands case Instruction::Trunc: 3133bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands Result = SimplifyTruncInst(I->getOperand(0), I->getType(), TD, TLI, DT); 3134bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands break; 3135e34537856a544c83513e390ac9552a8bc3823346Chris Lattner } 3136d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands 3137d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands /// If called on unreachable code, the above logic may report that the 3138d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands /// instruction simplified to itself. Make life easier for users by 3139f8b1a5ea9602bb65a5cf59d3d34f2851a08cdc3eDuncan Sands /// detecting that case here, returning a safe value instead. 3140f8b1a5ea9602bb65a5cf59d3d34f2851a08cdc3eDuncan Sands return Result == I ? UndefValue::get(I->getType()) : Result; 3141e34537856a544c83513e390ac9552a8bc3823346Chris Lattner} 3142e34537856a544c83513e390ac9552a8bc3823346Chris Lattner 31436b980541df5846ad335c377c8803b517968daee2Chandler Carruth/// \brief Implementation of recursive simplification through an instructions 31446b980541df5846ad335c377c8803b517968daee2Chandler Carruth/// uses. 314540d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// 31466b980541df5846ad335c377c8803b517968daee2Chandler Carruth/// This is the common implementation of the recursive simplification routines. 31476b980541df5846ad335c377c8803b517968daee2Chandler Carruth/// If we have a pre-simplified value in 'SimpleV', that is forcibly used to 31486b980541df5846ad335c377c8803b517968daee2Chandler Carruth/// replace the instruction 'I'. Otherwise, we simply add 'I' to the list of 31496b980541df5846ad335c377c8803b517968daee2Chandler Carruth/// instructions to process and attempt to simplify it using 31506b980541df5846ad335c377c8803b517968daee2Chandler Carruth/// InstructionSimplify. 31516b980541df5846ad335c377c8803b517968daee2Chandler Carruth/// 31526b980541df5846ad335c377c8803b517968daee2Chandler Carruth/// This routine returns 'true' only when *it* simplifies something. The passed 31536b980541df5846ad335c377c8803b517968daee2Chandler Carruth/// in simplified value does not count toward this. 31546b980541df5846ad335c377c8803b517968daee2Chandler Carruthstatic bool replaceAndRecursivelySimplifyImpl(Instruction *I, Value *SimpleV, 31553574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow const DataLayout *TD, 31566b980541df5846ad335c377c8803b517968daee2Chandler Carruth const TargetLibraryInfo *TLI, 31576b980541df5846ad335c377c8803b517968daee2Chandler Carruth const DominatorTree *DT) { 31586b980541df5846ad335c377c8803b517968daee2Chandler Carruth bool Simplified = false; 31596231d5be410e2d7967352b29ad01522fda15680dChandler Carruth SmallSetVector<Instruction *, 8> Worklist; 31606b980541df5846ad335c377c8803b517968daee2Chandler Carruth 31616b980541df5846ad335c377c8803b517968daee2Chandler Carruth // If we have an explicit value to collapse to, do that round of the 31626b980541df5846ad335c377c8803b517968daee2Chandler Carruth // simplification loop by hand initially. 31636b980541df5846ad335c377c8803b517968daee2Chandler Carruth if (SimpleV) { 31646b980541df5846ad335c377c8803b517968daee2Chandler Carruth for (Value::use_iterator UI = I->use_begin(), UE = I->use_end(); UI != UE; 31656b980541df5846ad335c377c8803b517968daee2Chandler Carruth ++UI) 3166c5b785b91c922bbb3d5adb4b042c976bebe00e4dChandler Carruth if (*UI != I) 31676231d5be410e2d7967352b29ad01522fda15680dChandler Carruth Worklist.insert(cast<Instruction>(*UI)); 31686b980541df5846ad335c377c8803b517968daee2Chandler Carruth 31696b980541df5846ad335c377c8803b517968daee2Chandler Carruth // Replace the instruction with its simplified value. 31706b980541df5846ad335c377c8803b517968daee2Chandler Carruth I->replaceAllUsesWith(SimpleV); 31716b980541df5846ad335c377c8803b517968daee2Chandler Carruth 31726b980541df5846ad335c377c8803b517968daee2Chandler Carruth // Gracefully handle edge cases where the instruction is not wired into any 31736b980541df5846ad335c377c8803b517968daee2Chandler Carruth // parent block. 31746b980541df5846ad335c377c8803b517968daee2Chandler Carruth if (I->getParent()) 31756b980541df5846ad335c377c8803b517968daee2Chandler Carruth I->eraseFromParent(); 31766b980541df5846ad335c377c8803b517968daee2Chandler Carruth } else { 31776231d5be410e2d7967352b29ad01522fda15680dChandler Carruth Worklist.insert(I); 31786b980541df5846ad335c377c8803b517968daee2Chandler Carruth } 317912a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 31806231d5be410e2d7967352b29ad01522fda15680dChandler Carruth // Note that we must test the size on each iteration, the worklist can grow. 31816231d5be410e2d7967352b29ad01522fda15680dChandler Carruth for (unsigned Idx = 0; Idx != Worklist.size(); ++Idx) { 31826231d5be410e2d7967352b29ad01522fda15680dChandler Carruth I = Worklist[Idx]; 318312a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 31846b980541df5846ad335c377c8803b517968daee2Chandler Carruth // See if this instruction simplifies. 31856b980541df5846ad335c377c8803b517968daee2Chandler Carruth SimpleV = SimplifyInstruction(I, TD, TLI, DT); 31866b980541df5846ad335c377c8803b517968daee2Chandler Carruth if (!SimpleV) 31876b980541df5846ad335c377c8803b517968daee2Chandler Carruth continue; 31886b980541df5846ad335c377c8803b517968daee2Chandler Carruth 31896b980541df5846ad335c377c8803b517968daee2Chandler Carruth Simplified = true; 31906b980541df5846ad335c377c8803b517968daee2Chandler Carruth 31916b980541df5846ad335c377c8803b517968daee2Chandler Carruth // Stash away all the uses of the old instruction so we can check them for 31926b980541df5846ad335c377c8803b517968daee2Chandler Carruth // recursive simplifications after a RAUW. This is cheaper than checking all 31936b980541df5846ad335c377c8803b517968daee2Chandler Carruth // uses of To on the recursive step in most cases. 31946b980541df5846ad335c377c8803b517968daee2Chandler Carruth for (Value::use_iterator UI = I->use_begin(), UE = I->use_end(); UI != UE; 31956b980541df5846ad335c377c8803b517968daee2Chandler Carruth ++UI) 31966231d5be410e2d7967352b29ad01522fda15680dChandler Carruth Worklist.insert(cast<Instruction>(*UI)); 319712a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 31986b980541df5846ad335c377c8803b517968daee2Chandler Carruth // Replace the instruction with its simplified value. 31996b980541df5846ad335c377c8803b517968daee2Chandler Carruth I->replaceAllUsesWith(SimpleV); 32006b980541df5846ad335c377c8803b517968daee2Chandler Carruth 32016b980541df5846ad335c377c8803b517968daee2Chandler Carruth // Gracefully handle edge cases where the instruction is not wired into any 32026b980541df5846ad335c377c8803b517968daee2Chandler Carruth // parent block. 32036b980541df5846ad335c377c8803b517968daee2Chandler Carruth if (I->getParent()) 32046b980541df5846ad335c377c8803b517968daee2Chandler Carruth I->eraseFromParent(); 320540d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner } 32066b980541df5846ad335c377c8803b517968daee2Chandler Carruth return Simplified; 32076b980541df5846ad335c377c8803b517968daee2Chandler Carruth} 320812a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 32096b980541df5846ad335c377c8803b517968daee2Chandler Carruthbool llvm::recursivelySimplifyInstruction(Instruction *I, 32103574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow const DataLayout *TD, 32116b980541df5846ad335c377c8803b517968daee2Chandler Carruth const TargetLibraryInfo *TLI, 32126b980541df5846ad335c377c8803b517968daee2Chandler Carruth const DominatorTree *DT) { 32136b980541df5846ad335c377c8803b517968daee2Chandler Carruth return replaceAndRecursivelySimplifyImpl(I, 0, TD, TLI, DT); 32146b980541df5846ad335c377c8803b517968daee2Chandler Carruth} 321512a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 32166b980541df5846ad335c377c8803b517968daee2Chandler Carruthbool llvm::replaceAndRecursivelySimplify(Instruction *I, Value *SimpleV, 32173574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow const DataLayout *TD, 32186b980541df5846ad335c377c8803b517968daee2Chandler Carruth const TargetLibraryInfo *TLI, 32196b980541df5846ad335c377c8803b517968daee2Chandler Carruth const DominatorTree *DT) { 32206b980541df5846ad335c377c8803b517968daee2Chandler Carruth assert(I != SimpleV && "replaceAndRecursivelySimplify(X,X) is not valid!"); 32216b980541df5846ad335c377c8803b517968daee2Chandler Carruth assert(SimpleV && "Must provide a simplified value."); 32226b980541df5846ad335c377c8803b517968daee2Chandler Carruth return replaceAndRecursivelySimplifyImpl(I, SimpleV, TD, TLI, DT); 322340d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner} 3224