InstructionSimplify.cpp revision 5b8f0ddc7e5bc3c7ffe1b2226a8316796f18b90e
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" 21fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth#include "llvm/GlobalAlias.h" 22562b84b3aea359d1f918184e355da82bf05eb290Jay Foad#include "llvm/Operator.h" 23a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands#include "llvm/ADT/Statistic.h" 249f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner#include "llvm/Analysis/InstructionSimplify.h" 25f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky#include "llvm/Analysis/AliasAnalysis.h" 269f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner#include "llvm/Analysis/ConstantFolding.h" 271845009290e4d804ad377927bd8a08cca3036adcDuncan Sands#include "llvm/Analysis/Dominators.h" 28d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands#include "llvm/Analysis/ValueTracking.h" 293a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky#include "llvm/Support/ConstantRange.h" 30fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth#include "llvm/Support/GetElementPtrTypeIterator.h" 31d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner#include "llvm/Support/PatternMatch.h" 321845009290e4d804ad377927bd8a08cca3036adcDuncan Sands#include "llvm/Support/ValueHandle.h" 33e60d79faf7ef7bc4847f9e5d067af00b98dced7bDuncan Sands#include "llvm/Target/TargetData.h" 349f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattnerusing namespace llvm; 35d06094f0682f2ede03caff4892b1a57469896d48Chris Lattnerusing namespace llvm::PatternMatch; 369f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 3781a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattnerenum { RecursionLimit = 3 }; 38a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 39a3c44a5280042dbc0cde995675c225ede4528c6eDuncan SandsSTATISTIC(NumExpand, "Number of expansions"); 40a3c44a5280042dbc0cde995675c225ede4528c6eDuncan SandsSTATISTIC(NumFactor , "Number of factorizations"); 41a3c44a5280042dbc0cde995675c225ede4528c6eDuncan SandsSTATISTIC(NumReassoc, "Number of reassociations"); 42a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands 4382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sandsstatic Value *SimplifyAndInst(Value *, Value *, const TargetData *, 44618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *, const DominatorTree *, 45618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier unsigned); 46a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *SimplifyBinOp(unsigned, Value *, Value *, const TargetData *, 47618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *, const DominatorTree *, 48618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier unsigned); 49a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *SimplifyCmpInst(unsigned, Value *, Value *, const TargetData *, 50618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *, const DominatorTree *, 51618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier unsigned); 5282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sandsstatic Value *SimplifyOrInst(Value *, Value *, const TargetData *, 53618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *, const DominatorTree *, 54618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier unsigned); 5582fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sandsstatic Value *SimplifyXorInst(Value *, Value *, const TargetData *, 56618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *, const DominatorTree *, 57618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier unsigned); 581845009290e4d804ad377927bd8a08cca3036adcDuncan Sands 59f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands/// getFalse - For a boolean type, or a vector of boolean type, return false, or 60f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands/// a vector with every element false, as appropriate for the type. 61f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sandsstatic Constant *getFalse(Type *Ty) { 6266d004ef708642bbdc38fd761507f2e9ee3970cdNick Lewycky assert(Ty->getScalarType()->isIntegerTy(1) && 63f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands "Expected i1 type or a vector of i1!"); 64f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return Constant::getNullValue(Ty); 65f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands} 66f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands 67f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands/// getTrue - For a boolean type, or a vector of boolean type, return true, or 68f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands/// a vector with every element true, as appropriate for the type. 69f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sandsstatic Constant *getTrue(Type *Ty) { 7066d004ef708642bbdc38fd761507f2e9ee3970cdNick Lewycky assert(Ty->getScalarType()->isIntegerTy(1) && 71f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands "Expected i1 type or a vector of i1!"); 72f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return Constant::getAllOnesValue(Ty); 73f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands} 74f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands 756dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands/// isSameCompare - Is V equivalent to the comparison "LHS Pred RHS"? 766dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sandsstatic bool isSameCompare(Value *V, CmpInst::Predicate Pred, Value *LHS, 776dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands Value *RHS) { 786dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands CmpInst *Cmp = dyn_cast<CmpInst>(V); 796dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (!Cmp) 806dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return false; 816dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands CmpInst::Predicate CPred = Cmp->getPredicate(); 826dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands Value *CLHS = Cmp->getOperand(0), *CRHS = Cmp->getOperand(1); 836dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (CPred == Pred && CLHS == LHS && CRHS == RHS) 846dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return true; 856dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return CPred == CmpInst::getSwappedPredicate(Pred) && CLHS == RHS && 866dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands CRHS == LHS; 876dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands} 886dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands 891845009290e4d804ad377927bd8a08cca3036adcDuncan Sands/// ValueDominatesPHI - Does the given value dominate the specified phi node? 901845009290e4d804ad377927bd8a08cca3036adcDuncan Sandsstatic bool ValueDominatesPHI(Value *V, PHINode *P, const DominatorTree *DT) { 911845009290e4d804ad377927bd8a08cca3036adcDuncan Sands Instruction *I = dyn_cast<Instruction>(V); 921845009290e4d804ad377927bd8a08cca3036adcDuncan Sands if (!I) 931845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // Arguments and constants dominate all instructions. 941845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return true; 951845009290e4d804ad377927bd8a08cca3036adcDuncan Sands 961845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // If we have a DominatorTree then do a precise test. 975b8f0ddc7e5bc3c7ffe1b2226a8316796f18b90eEli Friedman if (DT) { 985b8f0ddc7e5bc3c7ffe1b2226a8316796f18b90eEli Friedman if (!DT->isReachableFromEntry(P->getParent())) 995b8f0ddc7e5bc3c7ffe1b2226a8316796f18b90eEli Friedman return true; 1005b8f0ddc7e5bc3c7ffe1b2226a8316796f18b90eEli Friedman if (!DT->isReachableFromEntry(I->getParent())) 1015b8f0ddc7e5bc3c7ffe1b2226a8316796f18b90eEli Friedman return false; 1025b8f0ddc7e5bc3c7ffe1b2226a8316796f18b90eEli Friedman return DT->dominates(I, P); 1035b8f0ddc7e5bc3c7ffe1b2226a8316796f18b90eEli Friedman } 1041845009290e4d804ad377927bd8a08cca3036adcDuncan Sands 1051845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // Otherwise, if the instruction is in the entry block, and is not an invoke, 1061845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // then it obviously dominates all phi nodes. 1071845009290e4d804ad377927bd8a08cca3036adcDuncan Sands if (I->getParent() == &I->getParent()->getParent()->getEntryBlock() && 1081845009290e4d804ad377927bd8a08cca3036adcDuncan Sands !isa<InvokeInst>(I)) 1091845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return true; 1101845009290e4d804ad377927bd8a08cca3036adcDuncan Sands 1111845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return false; 1121845009290e4d804ad377927bd8a08cca3036adcDuncan Sands} 113a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 1143421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// ExpandBinOp - Simplify "A op (B op' C)" by distributing op over op', turning 1153421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// it into "(A op B) op' (A op C)". Here "op" is given by Opcode and "op'" is 1163421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// given by OpcodeToExpand, while "A" corresponds to LHS and "B op' C" to RHS. 1173421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// Also performs the transform "(A op' B) op C" -> "(A op C) op' (B op C)". 1183421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// Returns the simplified value, or null if no simplification was performed. 1193421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sandsstatic Value *ExpandBinOp(unsigned Opcode, Value *LHS, Value *RHS, 120e21083aa3a79506f896d95d7147c3c4627a77ef0Benjamin Kramer unsigned OpcToExpand, const TargetData *TD, 121618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, const DominatorTree *DT, 122618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier unsigned MaxRecurse) { 123e21083aa3a79506f896d95d7147c3c4627a77ef0Benjamin Kramer Instruction::BinaryOps OpcodeToExpand = (Instruction::BinaryOps)OpcToExpand; 1243421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 1253421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (!MaxRecurse--) 1263421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return 0; 1273421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1283421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Check whether the expression has the form "(A op' B) op C". 1293421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (BinaryOperator *Op0 = dyn_cast<BinaryOperator>(LHS)) 1303421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Op0->getOpcode() == OpcodeToExpand) { 1313421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // It does! Try turning it into "(A op C) op' (B op C)". 1323421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands Value *A = Op0->getOperand(0), *B = Op0->getOperand(1), *C = RHS; 1333421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Do "A op C" and "B op C" both simplify? 134618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *L = SimplifyBinOp(Opcode, A, C, TD, TLI, DT, MaxRecurse)) 135618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *R = SimplifyBinOp(Opcode, B, C, TD, TLI, DT, MaxRecurse)) { 1363421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // They do! Return "L op' R" if it simplifies or is already available. 1373421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // If "L op' R" equals "A op' B" then "L op' R" is just the LHS. 138124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if ((L == A && R == B) || (Instruction::isCommutative(OpcodeToExpand) 139124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands && L == B && R == A)) { 140a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumExpand; 1413421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return LHS; 142a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 1433421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Otherwise return "L op' R" if it simplifies. 144618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyBinOp(OpcodeToExpand, L, R, TD, TLI, DT, 145a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands MaxRecurse)) { 146a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumExpand; 1473421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 148a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 1493421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 1503421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 1513421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1523421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Check whether the expression has the form "A op (B op' C)". 1533421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (BinaryOperator *Op1 = dyn_cast<BinaryOperator>(RHS)) 1543421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Op1->getOpcode() == OpcodeToExpand) { 1553421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // It does! Try turning it into "(A op B) op' (A op C)". 1563421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands Value *A = LHS, *B = Op1->getOperand(0), *C = Op1->getOperand(1); 1573421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Do "A op B" and "A op C" both simplify? 158618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *L = SimplifyBinOp(Opcode, A, B, TD, TLI, DT, MaxRecurse)) 159618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *R = SimplifyBinOp(Opcode, A, C, TD, TLI, DT, MaxRecurse)) { 1603421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // They do! Return "L op' R" if it simplifies or is already available. 1613421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // If "L op' R" equals "B op' C" then "L op' R" is just the RHS. 162124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if ((L == B && R == C) || (Instruction::isCommutative(OpcodeToExpand) 163124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands && L == C && R == B)) { 164a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumExpand; 1653421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return RHS; 166a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 1673421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Otherwise return "L op' R" if it simplifies. 168618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyBinOp(OpcodeToExpand, L, R, TD, TLI, DT, 169a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands MaxRecurse)) { 170a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumExpand; 1713421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 172a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 1733421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 1743421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 1753421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1763421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return 0; 1773421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands} 1783421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1793421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// FactorizeBinOp - Simplify "LHS Opcode RHS" by factorizing out a common term 1803421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// using the operation OpCodeToExtract. For example, when Opcode is Add and 1813421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// OpCodeToExtract is Mul then this tries to turn "(A*B)+(A*C)" into "A*(B+C)". 1823421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// Returns the simplified value, or null if no simplification was performed. 1833421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sandsstatic Value *FactorizeBinOp(unsigned Opcode, Value *LHS, Value *RHS, 184618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier unsigned OpcToExtract, const TargetData *TD, 185618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 186618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT, 187618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier unsigned MaxRecurse) { 188e21083aa3a79506f896d95d7147c3c4627a77ef0Benjamin Kramer Instruction::BinaryOps OpcodeToExtract = (Instruction::BinaryOps)OpcToExtract; 1893421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 1903421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (!MaxRecurse--) 1913421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return 0; 1923421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1933421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands BinaryOperator *Op0 = dyn_cast<BinaryOperator>(LHS); 1943421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands BinaryOperator *Op1 = dyn_cast<BinaryOperator>(RHS); 1953421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1963421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (!Op0 || Op0->getOpcode() != OpcodeToExtract || 1973421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands !Op1 || Op1->getOpcode() != OpcodeToExtract) 1983421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return 0; 1993421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 2003421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // The expression has the form "(A op' B) op (C op' D)". 20182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands Value *A = Op0->getOperand(0), *B = Op0->getOperand(1); 20282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands Value *C = Op1->getOperand(0), *D = Op1->getOperand(1); 2033421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 2043421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Use left distributivity, i.e. "X op' (Y op Z) = (X op' Y) op (X op' Z)". 2053421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Does the instruction have the form "(A op' B) op (A op' D)" or, in the 2063421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // commutative case, "(A op' B) op (C op' A)"? 207124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (A == C || (Instruction::isCommutative(OpcodeToExtract) && A == D)) { 208124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands Value *DD = A == C ? D : C; 2093421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Form "A op' (B op DD)" if it simplifies completely. 2103421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Does "B op DD" simplify? 211618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyBinOp(Opcode, B, DD, TD, TLI, DT, MaxRecurse)) { 2123421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // It does! Return "A op' V" if it simplifies or is already available. 2131cd05bb605e3c3eee9197d3f10b628c60d0cc07aDuncan Sands // If V equals B then "A op' V" is just the LHS. If V equals DD then 2141cd05bb605e3c3eee9197d3f10b628c60d0cc07aDuncan Sands // "A op' V" is just the RHS. 215124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (V == B || V == DD) { 216a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumFactor; 217124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands return V == B ? LHS : RHS; 218a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 2193421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Otherwise return "A op' V" if it simplifies. 220618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *W = SimplifyBinOp(OpcodeToExtract, A, V, TD, TLI, DT, 221618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier MaxRecurse)) { 222a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumFactor; 2233421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return W; 224a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 2253421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 2263421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 2273421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 2283421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Use right distributivity, i.e. "(X op Y) op' Z = (X op' Z) op (Y op' Z)". 2293421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Does the instruction have the form "(A op' B) op (C op' B)" or, in the 2303421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // commutative case, "(A op' B) op (B op' D)"? 231124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (B == D || (Instruction::isCommutative(OpcodeToExtract) && B == C)) { 232124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands Value *CC = B == D ? C : D; 2333421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Form "(A op CC) op' B" if it simplifies completely.. 2343421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Does "A op CC" simplify? 235618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyBinOp(Opcode, A, CC, TD, TLI, DT, MaxRecurse)) { 2363421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // It does! Return "V op' B" if it simplifies or is already available. 2371cd05bb605e3c3eee9197d3f10b628c60d0cc07aDuncan Sands // If V equals A then "V op' B" is just the LHS. If V equals CC then 2381cd05bb605e3c3eee9197d3f10b628c60d0cc07aDuncan Sands // "V op' B" is just the RHS. 239124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (V == A || V == CC) { 240a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumFactor; 241124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands return V == A ? LHS : RHS; 242a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 2433421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Otherwise return "V op' B" if it simplifies. 244618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *W = SimplifyBinOp(OpcodeToExtract, V, B, TD, TLI, DT, 245618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier MaxRecurse)) { 246a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumFactor; 2473421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return W; 248a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 2493421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 2503421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 2513421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 2523421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return 0; 2533421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands} 2543421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 2553421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// SimplifyAssociativeBinOp - Generic simplifications for associative binary 2563421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// operations. Returns the simpler value, or null if none was found. 257e21083aa3a79506f896d95d7147c3c4627a77ef0Benjamin Kramerstatic Value *SimplifyAssociativeBinOp(unsigned Opc, Value *LHS, Value *RHS, 258566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands const TargetData *TD, 259618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 260566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands const DominatorTree *DT, 261566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands unsigned MaxRecurse) { 262e21083aa3a79506f896d95d7147c3c4627a77ef0Benjamin Kramer Instruction::BinaryOps Opcode = (Instruction::BinaryOps)Opc; 263566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands assert(Instruction::isAssociative(Opcode) && "Not an associative operation!"); 264566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 265566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 266566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (!MaxRecurse--) 267566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return 0; 268566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 269566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands BinaryOperator *Op0 = dyn_cast<BinaryOperator>(LHS); 270566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands BinaryOperator *Op1 = dyn_cast<BinaryOperator>(RHS); 271566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 272566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Transform: "(A op B) op C" ==> "A op (B op C)" if it simplifies completely. 273566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Op0 && Op0->getOpcode() == Opcode) { 274566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *A = Op0->getOperand(0); 275566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *B = Op0->getOperand(1); 276566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *C = RHS; 277566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 278566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Does "B op C" simplify? 279618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyBinOp(Opcode, B, C, TD, TLI, DT, MaxRecurse)) { 280566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // It does! Return "A op V" if it simplifies or is already available. 281566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // If V equals B then "A op V" is just the LHS. 282124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (V == B) return LHS; 283566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Otherwise return "A op V" if it simplifies. 284618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *W = SimplifyBinOp(Opcode, A, V, TD, TLI, DT, MaxRecurse)) { 285a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumReassoc; 286566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return W; 287a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 288566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 289566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 290566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 291566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Transform: "A op (B op C)" ==> "(A op B) op C" if it simplifies completely. 292566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Op1 && Op1->getOpcode() == Opcode) { 293566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *A = LHS; 294566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *B = Op1->getOperand(0); 295566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *C = Op1->getOperand(1); 296566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 297566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Does "A op B" simplify? 298618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyBinOp(Opcode, A, B, TD, TLI, DT, MaxRecurse)) { 299566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // It does! Return "V op C" if it simplifies or is already available. 300566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // If V equals B then "V op C" is just the RHS. 301124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (V == B) return RHS; 302566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Otherwise return "V op C" if it simplifies. 303618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *W = SimplifyBinOp(Opcode, V, C, TD, TLI, DT, MaxRecurse)) { 304a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumReassoc; 305566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return W; 306a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 307566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 308566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 309566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 310566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // The remaining transforms require commutativity as well as associativity. 311566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (!Instruction::isCommutative(Opcode)) 312566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return 0; 313566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 314566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Transform: "(A op B) op C" ==> "(C op A) op B" if it simplifies completely. 315566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Op0 && Op0->getOpcode() == Opcode) { 316566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *A = Op0->getOperand(0); 317566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *B = Op0->getOperand(1); 318566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *C = RHS; 319566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 320566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Does "C op A" simplify? 321618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyBinOp(Opcode, C, A, TD, TLI, DT, MaxRecurse)) { 322566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // It does! Return "V op B" if it simplifies or is already available. 323566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // If V equals A then "V op B" is just the LHS. 324124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (V == A) return LHS; 325566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Otherwise return "V op B" if it simplifies. 326618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *W = SimplifyBinOp(Opcode, V, B, TD, TLI, DT, MaxRecurse)) { 327a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumReassoc; 328566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return W; 329a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 330566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 331566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 332566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 333566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Transform: "A op (B op C)" ==> "B op (C op A)" if it simplifies completely. 334566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Op1 && Op1->getOpcode() == Opcode) { 335566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *A = LHS; 336566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *B = Op1->getOperand(0); 337566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *C = Op1->getOperand(1); 338566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 339566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Does "C op A" simplify? 340618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyBinOp(Opcode, C, A, TD, TLI, DT, MaxRecurse)) { 341566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // It does! Return "B op V" if it simplifies or is already available. 342566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // If V equals C then "B op V" is just the RHS. 343124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (V == C) return RHS; 344566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Otherwise return "B op V" if it simplifies. 345618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *W = SimplifyBinOp(Opcode, B, V, TD, TLI, DT, MaxRecurse)) { 346a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumReassoc; 347566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return W; 348a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 349566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 350566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 351566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 352566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return 0; 353566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands} 354566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 355b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// ThreadBinOpOverSelect - In the case of a binary operation with a select 356b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// instruction as an operand, try to simplify the binop by seeing whether 357b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// evaluating it on both branches of the select results in the same value. 358b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// Returns the common value if so, otherwise returns null. 359b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sandsstatic Value *ThreadBinOpOverSelect(unsigned Opcode, Value *LHS, Value *RHS, 3601845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const TargetData *TD, 361618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 3621845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const DominatorTree *DT, 3631845009290e4d804ad377927bd8a08cca3036adcDuncan Sands unsigned MaxRecurse) { 3640312a93693abc2eb682b2b101c889959888fd883Duncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 3650312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (!MaxRecurse--) 3660312a93693abc2eb682b2b101c889959888fd883Duncan Sands return 0; 3670312a93693abc2eb682b2b101c889959888fd883Duncan Sands 368b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands SelectInst *SI; 369b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (isa<SelectInst>(LHS)) { 370b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands SI = cast<SelectInst>(LHS); 371b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } else { 372b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands assert(isa<SelectInst>(RHS) && "No select instruction operand!"); 373b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands SI = cast<SelectInst>(RHS); 374b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } 375b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 376b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // Evaluate the BinOp on the true and false branches of the select. 377b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Value *TV; 378b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Value *FV; 379b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (SI == LHS) { 380618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TV = SimplifyBinOp(Opcode, SI->getTrueValue(), RHS, TD, TLI, DT, MaxRecurse); 381618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier FV = SimplifyBinOp(Opcode, SI->getFalseValue(), RHS, TD, TLI, DT, MaxRecurse); 382b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } else { 383618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TV = SimplifyBinOp(Opcode, LHS, SI->getTrueValue(), TD, TLI, DT, MaxRecurse); 384618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier FV = SimplifyBinOp(Opcode, LHS, SI->getFalseValue(), TD, TLI, DT, MaxRecurse); 385b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } 386b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 3877cf85e74e3885005ca8e5fdb155fa5351e255b85Duncan Sands // If they simplified to the same value, then return the common value. 388124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands // If they both failed to simplify then return null. 389124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (TV == FV) 390b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return TV; 391b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 392b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // If one branch simplified to undef, return the other one. 393b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (TV && isa<UndefValue>(TV)) 394b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return FV; 395b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (FV && isa<UndefValue>(FV)) 396b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return TV; 397b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 398b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // If applying the operation did not change the true and false select values, 399b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // then the result of the binop is the select itself. 400124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (TV == SI->getTrueValue() && FV == SI->getFalseValue()) 401b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return SI; 402b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 403b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // If one branch simplified and the other did not, and the simplified 404b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // value is equal to the unsimplified one, return the simplified value. 405b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // For example, select (cond, X, X & Z) & Z -> X & Z. 406b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if ((FV && !TV) || (TV && !FV)) { 407b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // Check that the simplified value has the form "X op Y" where "op" is the 408b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // same as the original operation. 409b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Instruction *Simplified = dyn_cast<Instruction>(FV ? FV : TV); 410b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (Simplified && Simplified->getOpcode() == Opcode) { 411b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // The value that didn't simplify is "UnsimplifiedLHS op UnsimplifiedRHS". 412b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // We already know that "op" is the same as for the simplified value. See 413b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // if the operands match too. If so, return the simplified value. 414b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Value *UnsimplifiedBranch = FV ? SI->getTrueValue() : SI->getFalseValue(); 415b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Value *UnsimplifiedLHS = SI == LHS ? UnsimplifiedBranch : LHS; 416b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Value *UnsimplifiedRHS = SI == LHS ? RHS : UnsimplifiedBranch; 417124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (Simplified->getOperand(0) == UnsimplifiedLHS && 418124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands Simplified->getOperand(1) == UnsimplifiedRHS) 419b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return Simplified; 420b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (Simplified->isCommutative() && 421124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands Simplified->getOperand(1) == UnsimplifiedLHS && 422124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands Simplified->getOperand(0) == UnsimplifiedRHS) 423b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return Simplified; 424b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } 425b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } 426b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 427b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return 0; 428b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands} 429b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 430b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// ThreadCmpOverSelect - In the case of a comparison with a select instruction, 431b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// try to simplify the comparison by seeing whether both branches of the select 432b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// result in the same value. Returns the common value if so, otherwise returns 433b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// null. 434b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sandsstatic Value *ThreadCmpOverSelect(CmpInst::Predicate Pred, Value *LHS, 435a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands Value *RHS, const TargetData *TD, 436618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 4371845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const DominatorTree *DT, 438a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands unsigned MaxRecurse) { 4390312a93693abc2eb682b2b101c889959888fd883Duncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 4400312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (!MaxRecurse--) 4410312a93693abc2eb682b2b101c889959888fd883Duncan Sands return 0; 4420312a93693abc2eb682b2b101c889959888fd883Duncan Sands 443b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // Make sure the select is on the LHS. 444b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (!isa<SelectInst>(LHS)) { 445b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands std::swap(LHS, RHS); 446b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Pred = CmpInst::getSwappedPredicate(Pred); 447b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } 448b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands assert(isa<SelectInst>(LHS) && "Not comparing with a select instruction!"); 449b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands SelectInst *SI = cast<SelectInst>(LHS); 4506dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands Value *Cond = SI->getCondition(); 4516dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands Value *TV = SI->getTrueValue(); 4526dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands Value *FV = SI->getFalseValue(); 453b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 45450ca4d37f7f3b460c6441eb5ad14625a7d86b5d9Duncan Sands // Now that we have "cmp select(Cond, TV, FV), RHS", analyse it. 455b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // Does "cmp TV, RHS" simplify? 456618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Value *TCmp = SimplifyCmpInst(Pred, TV, RHS, TD, TLI, DT, MaxRecurse); 4576dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (TCmp == Cond) { 4586dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // It not only simplified, it simplified to the select condition. Replace 4596dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // it with 'true'. 4606dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands TCmp = getTrue(Cond->getType()); 4616dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands } else if (!TCmp) { 4626dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // It didn't simplify. However if "cmp TV, RHS" is equal to the select 4636dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // condition then we can replace it with 'true'. Otherwise give up. 4646dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (!isSameCompare(Cond, Pred, TV, RHS)) 4656dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return 0; 4666dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands TCmp = getTrue(Cond->getType()); 46750ca4d37f7f3b460c6441eb5ad14625a7d86b5d9Duncan Sands } 46850ca4d37f7f3b460c6441eb5ad14625a7d86b5d9Duncan Sands 4696dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // Does "cmp FV, RHS" simplify? 470618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Value *FCmp = SimplifyCmpInst(Pred, FV, RHS, TD, TLI, DT, MaxRecurse); 4716dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (FCmp == Cond) { 4726dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // It not only simplified, it simplified to the select condition. Replace 4736dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // it with 'false'. 4746dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands FCmp = getFalse(Cond->getType()); 4756dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands } else if (!FCmp) { 4766dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // It didn't simplify. However if "cmp FV, RHS" is equal to the select 4776dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // condition then we can replace it with 'false'. Otherwise give up. 4786dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (!isSameCompare(Cond, Pred, FV, RHS)) 4796dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return 0; 4806dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands FCmp = getFalse(Cond->getType()); 4816dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands } 4826dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands 4836dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // If both sides simplified to the same value, then use it as the result of 4846dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // the original comparison. 4856dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (TCmp == FCmp) 4866dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return TCmp; 487aa97bb54f02784abefa0ae170af5937915bdb329Duncan Sands 488aa97bb54f02784abefa0ae170af5937915bdb329Duncan Sands // The remaining cases only make sense if the select condition has the same 489aa97bb54f02784abefa0ae170af5937915bdb329Duncan Sands // type as the result of the comparison, so bail out if this is not so. 490aa97bb54f02784abefa0ae170af5937915bdb329Duncan Sands if (Cond->getType()->isVectorTy() != RHS->getType()->isVectorTy()) 491aa97bb54f02784abefa0ae170af5937915bdb329Duncan Sands return 0; 4926dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // If the false value simplified to false, then the result of the compare 4936dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // is equal to "Cond && TCmp". This also catches the case when the false 4946dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // value simplified to false and the true value to true, returning "Cond". 4956dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (match(FCmp, m_Zero())) 496618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyAndInst(Cond, TCmp, TD, TLI, DT, MaxRecurse)) 4976dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return V; 4986dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // If the true value simplified to true, then the result of the compare 4996dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // is equal to "Cond || FCmp". 5006dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (match(TCmp, m_One())) 501618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyOrInst(Cond, FCmp, TD, TLI, DT, MaxRecurse)) 5026dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return V; 5036dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // Finally, if the false value simplified to true and the true value to 5046dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // false, then the result of the compare is equal to "!Cond". 5056dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (match(FCmp, m_One()) && match(TCmp, m_Zero())) 5066dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (Value *V = 5076dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands SimplifyXorInst(Cond, Constant::getAllOnesValue(Cond->getType()), 508618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT, MaxRecurse)) 5096dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return V; 5106dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands 511b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return 0; 512b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands} 513b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 514a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// ThreadBinOpOverPHI - In the case of a binary operation with an operand that 515a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// is a PHI instruction, try to simplify the binop by seeing whether evaluating 516a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// it on the incoming phi values yields the same result for every value. If so 517a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// returns the common value, otherwise returns null. 518a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *ThreadBinOpOverPHI(unsigned Opcode, Value *LHS, Value *RHS, 519618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, 520618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 521618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT, 5221845009290e4d804ad377927bd8a08cca3036adcDuncan Sands unsigned MaxRecurse) { 5230312a93693abc2eb682b2b101c889959888fd883Duncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 5240312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (!MaxRecurse--) 5250312a93693abc2eb682b2b101c889959888fd883Duncan Sands return 0; 5260312a93693abc2eb682b2b101c889959888fd883Duncan Sands 527a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands PHINode *PI; 528a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands if (isa<PHINode>(LHS)) { 529a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands PI = cast<PHINode>(LHS); 5301845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // Bail out if RHS and the phi may be mutually interdependent due to a loop. 5311845009290e4d804ad377927bd8a08cca3036adcDuncan Sands if (!ValueDominatesPHI(RHS, PI, DT)) 5321845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return 0; 533a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands } else { 534a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands assert(isa<PHINode>(RHS) && "No PHI instruction operand!"); 535a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands PI = cast<PHINode>(RHS); 5361845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // Bail out if LHS and the phi may be mutually interdependent due to a loop. 5371845009290e4d804ad377927bd8a08cca3036adcDuncan Sands if (!ValueDominatesPHI(LHS, PI, DT)) 5381845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return 0; 539a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands } 540a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 541a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // Evaluate the BinOp on the incoming phi values. 542a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands Value *CommonValue = 0; 543a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands for (unsigned i = 0, e = PI->getNumIncomingValues(); i != e; ++i) { 544552008946530e01efdad15044e1f621883d14a3aDuncan Sands Value *Incoming = PI->getIncomingValue(i); 545ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // If the incoming value is the phi node itself, it can safely be skipped. 546552008946530e01efdad15044e1f621883d14a3aDuncan Sands if (Incoming == PI) continue; 547a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands Value *V = PI == LHS ? 548618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier SimplifyBinOp(Opcode, Incoming, RHS, TD, TLI, DT, MaxRecurse) : 549618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier SimplifyBinOp(Opcode, LHS, Incoming, TD, TLI, DT, MaxRecurse); 550a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the operation failed to simplify, or simplified to a different value 551a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // to previously, then give up. 552a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands if (!V || (CommonValue && V != CommonValue)) 553a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return 0; 554a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands CommonValue = V; 555a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands } 556a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 557a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return CommonValue; 558a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 559a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 560a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// ThreadCmpOverPHI - In the case of a comparison with a PHI instruction, try 561a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// try to simplify the comparison by seeing whether comparing with all of the 562a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// incoming phi values yields the same result every time. If so returns the 563a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// common result, otherwise returns null. 564a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *ThreadCmpOverPHI(CmpInst::Predicate Pred, Value *LHS, Value *RHS, 565618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, 566618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 567618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT, 5681845009290e4d804ad377927bd8a08cca3036adcDuncan Sands unsigned MaxRecurse) { 5690312a93693abc2eb682b2b101c889959888fd883Duncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 5700312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (!MaxRecurse--) 5710312a93693abc2eb682b2b101c889959888fd883Duncan Sands return 0; 5720312a93693abc2eb682b2b101c889959888fd883Duncan Sands 573a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // Make sure the phi is on the LHS. 574a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands if (!isa<PHINode>(LHS)) { 575a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands std::swap(LHS, RHS); 576a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands Pred = CmpInst::getSwappedPredicate(Pred); 577a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands } 578a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands assert(isa<PHINode>(LHS) && "Not comparing with a phi instruction!"); 579a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands PHINode *PI = cast<PHINode>(LHS); 580a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 5811845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // Bail out if RHS and the phi may be mutually interdependent due to a loop. 5821845009290e4d804ad377927bd8a08cca3036adcDuncan Sands if (!ValueDominatesPHI(RHS, PI, DT)) 5831845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return 0; 5841845009290e4d804ad377927bd8a08cca3036adcDuncan Sands 585a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // Evaluate the BinOp on the incoming phi values. 586a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands Value *CommonValue = 0; 587a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands for (unsigned i = 0, e = PI->getNumIncomingValues(); i != e; ++i) { 588552008946530e01efdad15044e1f621883d14a3aDuncan Sands Value *Incoming = PI->getIncomingValue(i); 589ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // If the incoming value is the phi node itself, it can safely be skipped. 590552008946530e01efdad15044e1f621883d14a3aDuncan Sands if (Incoming == PI) continue; 591618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Value *V = SimplifyCmpInst(Pred, Incoming, RHS, TD, TLI, DT, MaxRecurse); 592a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the operation failed to simplify, or simplified to a different value 593a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // to previously, then give up. 594a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands if (!V || (CommonValue && V != CommonValue)) 595a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return 0; 596a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands CommonValue = V; 597a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands } 598a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 599a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return CommonValue; 600a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 601a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 6028aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner/// SimplifyAddInst - Given operands for an Add, see if we can 603d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner/// fold the result. If not, this returns null. 604ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sandsstatic Value *SimplifyAddInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, 605618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, 606618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 607618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT, 608ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands unsigned MaxRecurse) { 609d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 610d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 611d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Constant *Ops[] = { CLHS, CRHS }; 6128aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner return ConstantFoldInstOperands(Instruction::Add, CLHS->getType(), 613618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Ops, TD, TLI); 6148aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner } 61512a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 6168aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner // Canonicalize the constant to the RHS. 6178aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner std::swap(Op0, Op1); 6188aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner } 61912a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 620fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X + undef -> undef 621f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 622fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return Op1; 62312a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 624fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X + 0 -> X 625fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands if (match(Op1, m_Zero())) 626fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return Op0; 627fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 628fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X + (Y - X) -> Y 629fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // (Y - X) + X -> Y 630ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands // Eg: X + -X -> 0 631124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands Value *Y = 0; 632124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (match(Op1, m_Sub(m_Value(Y), m_Specific(Op0))) || 633124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands match(Op0, m_Sub(m_Value(Y), m_Specific(Op1)))) 634fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return Y; 635fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 636fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X + ~X -> -1 since ~X = -X-1 637124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (match(Op0, m_Not(m_Specific(Op1))) || 638124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands match(Op1, m_Not(m_Specific(Op0)))) 639fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return Constant::getAllOnesValue(Op0->getType()); 64087689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands 64182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands /// i1 add -> xor. 64275d289ed6201e82718343d7a36d2a2fa082f6217Duncan Sands if (MaxRecurse && Op0->getType()->isIntegerTy(1)) 643618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyXorInst(Op0, Op1, TD, TLI, DT, MaxRecurse-1)) 64407f30fbd734069b80b90c6aeea0ae645ce3880c0Duncan Sands return V; 64582fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 646566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Try some generic simplifications for associative operations. 647618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyAssociativeBinOp(Instruction::Add, Op0, Op1, TD, TLI, DT, 648566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands MaxRecurse)) 649566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return V; 650566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 6513421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Mul distributes over Add. Try some generic simplifications based on this. 6523421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = FactorizeBinOp(Instruction::Add, Op0, Op1, Instruction::Mul, 653618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT, MaxRecurse)) 6543421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 6553421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 65687689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // Threading Add over selects and phi nodes is pointless, so don't bother. 65787689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // Threading over the select in "A + select(cond, B, C)" means evaluating 65887689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // "A+B" and "A+C" and seeing if they are equal; but they are equal if and 65987689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // only if B and C are equal. If B and C are equal then (since we assume 66087689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // that operands have already been simplified) "select(cond, B, C)" should 66187689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // have been simplified to the common value of B and C already. Analysing 66287689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // "A+B" and "A+C" thus gains nothing, but costs compile time. Similarly 66387689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // for threading over phi nodes. 66487689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands 6658aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner return 0; 6668aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner} 6678aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner 668ee9a2e322af96accc9e55ed6373c0057453714b1Duncan SandsValue *llvm::SimplifyAddInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, 669618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, const TargetLibraryInfo *TLI, 670618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT) { 671618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ::SimplifyAddInst(Op0, Op1, isNSW, isNUW, TD, TLI, DT, RecursionLimit); 672ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands} 673ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands 67490c14fcb7ea3436a8b3053f8a9aa529c03011d34Chandler Carruth/// \brief Accumulate the constant integer offset a GEP represents. 675fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth/// 67690c14fcb7ea3436a8b3053f8a9aa529c03011d34Chandler Carruth/// Given a getelementptr instruction/constantexpr, accumulate the constant 67790c14fcb7ea3436a8b3053f8a9aa529c03011d34Chandler Carruth/// offset from the base pointer into the provided APInt 'Offset'. Returns true 67890c14fcb7ea3436a8b3053f8a9aa529c03011d34Chandler Carruth/// if the GEP has all-constant indices. Returns false if any non-constant 67990c14fcb7ea3436a8b3053f8a9aa529c03011d34Chandler Carruth/// index is encountered leaving the 'Offset' in an undefined state. The 68090c14fcb7ea3436a8b3053f8a9aa529c03011d34Chandler Carruth/// 'Offset' APInt must be the bitwidth of the target's pointer size. 68190c14fcb7ea3436a8b3053f8a9aa529c03011d34Chandler Carruthstatic bool accumulateGEPOffset(const TargetData &TD, GEPOperator *GEP, 68290c14fcb7ea3436a8b3053f8a9aa529c03011d34Chandler Carruth APInt &Offset) { 683fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth unsigned IntPtrWidth = TD.getPointerSizeInBits(); 68490c14fcb7ea3436a8b3053f8a9aa529c03011d34Chandler Carruth assert(IntPtrWidth == Offset.getBitWidth()); 685fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth 686fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth gep_type_iterator GTI = gep_type_begin(GEP); 687fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth for (User::op_iterator I = GEP->op_begin() + 1, E = GEP->op_end(); I != E; 688fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth ++I, ++GTI) { 689fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth ConstantInt *OpC = dyn_cast<ConstantInt>(*I); 69090c14fcb7ea3436a8b3053f8a9aa529c03011d34Chandler Carruth if (!OpC) return false; 691fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth if (OpC->isZero()) continue; 692fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth 693fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth // Handle a struct index, which adds its field offset to the pointer. 694fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth if (StructType *STy = dyn_cast<StructType>(*GTI)) { 69590c14fcb7ea3436a8b3053f8a9aa529c03011d34Chandler Carruth unsigned ElementIdx = OpC->getZExtValue(); 69690c14fcb7ea3436a8b3053f8a9aa529c03011d34Chandler Carruth const StructLayout *SL = TD.getStructLayout(STy); 69790c14fcb7ea3436a8b3053f8a9aa529c03011d34Chandler Carruth Offset += APInt(IntPtrWidth, SL->getElementOffset(ElementIdx), 69890c14fcb7ea3436a8b3053f8a9aa529c03011d34Chandler Carruth /*isSigned=*/true); 699fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth continue; 700fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth } 701fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth 70290c14fcb7ea3436a8b3053f8a9aa529c03011d34Chandler Carruth APInt TypeSize(IntPtrWidth, TD.getTypeAllocSize(GTI.getIndexedType()), 70390c14fcb7ea3436a8b3053f8a9aa529c03011d34Chandler Carruth /*isSigned=*/true); 70490c14fcb7ea3436a8b3053f8a9aa529c03011d34Chandler Carruth Offset += OpC->getValue().sextOrTrunc(IntPtrWidth) * TypeSize; 705fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth } 70690c14fcb7ea3436a8b3053f8a9aa529c03011d34Chandler Carruth return true; 707fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth} 708fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth 709fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth/// \brief Compute the base pointer and cumulative constant offsets for V. 710fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth/// 711fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth/// This strips all constant offsets off of V, leaving it the base pointer, and 712fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth/// accumulates the total constant offset applied in the returned constant. It 713fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth/// returns 0 if V is not a pointer, and returns the constant '0' if there are 714fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth/// no constant offsets applied. 715fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruthstatic Constant *stripAndComputeConstantOffsets(const TargetData &TD, 716fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth Value *&V) { 717fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth if (!V->getType()->isPointerTy()) 718fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth return 0; 719fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth 72090c14fcb7ea3436a8b3053f8a9aa529c03011d34Chandler Carruth unsigned IntPtrWidth = TD.getPointerSizeInBits(); 72190c14fcb7ea3436a8b3053f8a9aa529c03011d34Chandler Carruth APInt Offset = APInt::getNullValue(IntPtrWidth); 722fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth 723fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth // Even though we don't look through PHI nodes, we could be called on an 724fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth // instruction in an unreachable block, which may be on a cycle. 725fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth SmallPtrSet<Value *, 4> Visited; 726fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth Visited.insert(V); 727fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth do { 728fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth if (GEPOperator *GEP = dyn_cast<GEPOperator>(V)) { 72990c14fcb7ea3436a8b3053f8a9aa529c03011d34Chandler Carruth if (!accumulateGEPOffset(TD, GEP, Offset)) 730fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth break; 731fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth V = GEP->getPointerOperand(); 732fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth } else if (Operator::getOpcode(V) == Instruction::BitCast) { 733fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth V = cast<Operator>(V)->getOperand(0); 734fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth } else if (GlobalAlias *GA = dyn_cast<GlobalAlias>(V)) { 735fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth if (GA->mayBeOverridden()) 736fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth break; 737fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth V = GA->getAliasee(); 738fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth } else { 739fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth break; 740fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth } 741fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth assert(V->getType()->isPointerTy() && "Unexpected operand type!"); 742fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth } while (Visited.insert(V)); 743fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth 74490c14fcb7ea3436a8b3053f8a9aa529c03011d34Chandler Carruth Type *IntPtrTy = TD.getIntPtrType(V->getContext()); 74590c14fcb7ea3436a8b3053f8a9aa529c03011d34Chandler Carruth return ConstantInt::get(IntPtrTy, Offset); 746fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth} 747fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth 748fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth/// \brief Compute the constant difference between two pointer values. 749fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth/// If the difference is not a constant, returns zero. 750fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruthstatic Constant *computePointerDifference(const TargetData &TD, 751fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth Value *LHS, Value *RHS) { 752fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth Constant *LHSOffset = stripAndComputeConstantOffsets(TD, LHS); 753fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth if (!LHSOffset) 754fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth return 0; 755fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth Constant *RHSOffset = stripAndComputeConstantOffsets(TD, RHS); 756fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth if (!RHSOffset) 757fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth return 0; 758fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth 759fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth // If LHS and RHS are not related via constant offsets to the same base 760fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth // value, there is nothing we can do here. 761fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth if (LHS != RHS) 762fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth return 0; 763fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth 764fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth // Otherwise, the difference of LHS - RHS can be computed as: 765fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth // LHS - RHS 766fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth // = (LHSOffset + Base) - (RHSOffset + Base) 767fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth // = LHSOffset - RHSOffset 768fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth return ConstantExpr::getSub(LHSOffset, RHSOffset); 769fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth} 770fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth 771fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands/// SimplifySubInst - Given operands for a Sub, see if we can 772fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands/// fold the result. If not, this returns null. 773ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sandsstatic Value *SimplifySubInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, 774618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, 775618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 776618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT, 777ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands unsigned MaxRecurse) { 778fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands if (Constant *CLHS = dyn_cast<Constant>(Op0)) 779fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 780fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands Constant *Ops[] = { CLHS, CRHS }; 781fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return ConstantFoldInstOperands(Instruction::Sub, CLHS->getType(), 782618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Ops, TD, TLI); 783fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands } 784fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 785fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X - undef -> undef 786fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // undef - X -> undef 787f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op0, m_Undef()) || match(Op1, m_Undef())) 788fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return UndefValue::get(Op0->getType()); 789fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 790fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X - 0 -> X 791fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands if (match(Op1, m_Zero())) 792fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return Op0; 793fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 794fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X - X -> 0 795124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (Op0 == Op1) 796fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return Constant::getNullValue(Op0->getType()); 797fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 798fe02c69f84ad52d42be934e4fe702f03e4991a6aDuncan Sands // (X*2) - X -> X 799fe02c69f84ad52d42be934e4fe702f03e4991a6aDuncan Sands // (X<<1) - X -> X 800b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands Value *X = 0; 801fe02c69f84ad52d42be934e4fe702f03e4991a6aDuncan Sands if (match(Op0, m_Mul(m_Specific(Op1), m_ConstantInt<2>())) || 802fe02c69f84ad52d42be934e4fe702f03e4991a6aDuncan Sands match(Op0, m_Shl(m_Specific(Op1), m_One()))) 803fe02c69f84ad52d42be934e4fe702f03e4991a6aDuncan Sands return Op1; 804fe02c69f84ad52d42be934e4fe702f03e4991a6aDuncan Sands 805fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth if (TD) { 806fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth Value *LHSOp, *RHSOp; 807fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth if (match(Op0, m_PtrToInt(m_Value(LHSOp))) && 808fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth match(Op1, m_PtrToInt(m_Value(RHSOp)))) 809fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth if (Constant *Result = computePointerDifference(*TD, LHSOp, RHSOp)) 810fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth return ConstantExpr::getIntegerCast(Result, Op0->getType(), true); 811fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth 812fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth // trunc(p)-trunc(q) -> trunc(p-q) 813fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth if (match(Op0, m_Trunc(m_PtrToInt(m_Value(LHSOp)))) && 814fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth match(Op1, m_Trunc(m_PtrToInt(m_Value(RHSOp))))) 815fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth if (Constant *Result = computePointerDifference(*TD, LHSOp, RHSOp)) 816fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth return ConstantExpr::getIntegerCast(Result, Op0->getType(), true); 817fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth } 818fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth 819b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // (X + Y) - Z -> X + (Y - Z) or Y + (X - Z) if everything simplifies. 820b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // For example, (X + Y) - Y -> X; (Y + X) - Y -> X 821b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands Value *Y = 0, *Z = Op1; 822b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands if (MaxRecurse && match(Op0, m_Add(m_Value(X), m_Value(Y)))) { // (X + Y) - Z 823b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // See if "V === Y - Z" simplifies. 824618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyBinOp(Instruction::Sub, Y, Z, TD, TLI, DT, MaxRecurse-1)) 825b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does! Now see if "X + V" simplifies. 826618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *W = SimplifyBinOp(Instruction::Add, X, V, TD, TLI, DT, 827b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands MaxRecurse-1)) { 828b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does, we successfully reassociated! 829b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands ++NumReassoc; 830b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands return W; 831b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands } 832b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // See if "V === X - Z" simplifies. 833618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyBinOp(Instruction::Sub, X, Z, TD, TLI, DT, MaxRecurse-1)) 834b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does! Now see if "Y + V" simplifies. 835618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *W = SimplifyBinOp(Instruction::Add, Y, V, TD, TLI, DT, 836b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands MaxRecurse-1)) { 837b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does, we successfully reassociated! 838b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands ++NumReassoc; 839b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands return W; 840b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands } 841b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands } 84282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 843b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // X - (Y + Z) -> (X - Y) - Z or (X - Z) - Y if everything simplifies. 844b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // For example, X - (X + 1) -> -1 845b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands X = Op0; 846b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands if (MaxRecurse && match(Op1, m_Add(m_Value(Y), m_Value(Z)))) { // X - (Y + Z) 847b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // See if "V === X - Y" simplifies. 848618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyBinOp(Instruction::Sub, X, Y, TD, TLI, DT, MaxRecurse-1)) 849b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does! Now see if "V - Z" simplifies. 850618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *W = SimplifyBinOp(Instruction::Sub, V, Z, TD, TLI, DT, 851b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands MaxRecurse-1)) { 852b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does, we successfully reassociated! 853b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands ++NumReassoc; 854b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands return W; 855b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands } 856b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // See if "V === X - Z" simplifies. 857618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyBinOp(Instruction::Sub, X, Z, TD, TLI, DT, MaxRecurse-1)) 858b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does! Now see if "V - Y" simplifies. 859618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *W = SimplifyBinOp(Instruction::Sub, V, Y, TD, TLI, DT, 860b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands MaxRecurse-1)) { 861b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does, we successfully reassociated! 862b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands ++NumReassoc; 863b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands return W; 864b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands } 865b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands } 866b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands 867b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // Z - (X - Y) -> (Z - X) + Y if everything simplifies. 868b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // For example, X - (X - Y) -> Y. 869b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands Z = Op0; 870c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands if (MaxRecurse && match(Op1, m_Sub(m_Value(X), m_Value(Y)))) // Z - (X - Y) 871c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands // See if "V === Z - X" simplifies. 872618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyBinOp(Instruction::Sub, Z, X, TD, TLI, DT, MaxRecurse-1)) 873b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does! Now see if "V + Y" simplifies. 874618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *W = SimplifyBinOp(Instruction::Add, V, Y, TD, TLI, DT, 875c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands MaxRecurse-1)) { 876c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands // It does, we successfully reassociated! 877c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands ++NumReassoc; 878c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands return W; 879c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands } 880c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands 8813421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Mul distributes over Sub. Try some generic simplifications based on this. 8823421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = FactorizeBinOp(Instruction::Sub, Op0, Op1, Instruction::Mul, 883618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT, MaxRecurse)) 8843421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 8853421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 886b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // i1 sub -> xor. 887b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands if (MaxRecurse && Op0->getType()->isIntegerTy(1)) 888618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyXorInst(Op0, Op1, TD, TLI, DT, MaxRecurse-1)) 889b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands return V; 890b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands 891fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // Threading Sub over selects and phi nodes is pointless, so don't bother. 892fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // Threading over the select in "A - select(cond, B, C)" means evaluating 893fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // "A-B" and "A-C" and seeing if they are equal; but they are equal if and 894fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // only if B and C are equal. If B and C are equal then (since we assume 895fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // that operands have already been simplified) "select(cond, B, C)" should 896fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // have been simplified to the common value of B and C already. Analysing 897fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // "A-B" and "A-C" thus gains nothing, but costs compile time. Similarly 898fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // for threading over phi nodes. 899fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 900fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return 0; 901fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands} 902fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 903ee9a2e322af96accc9e55ed6373c0057453714b1Duncan SandsValue *llvm::SimplifySubInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, 904618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, 905618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 906618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT) { 907618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ::SimplifySubInst(Op0, Op1, isNSW, isNUW, TD, TLI, DT, RecursionLimit); 908ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands} 909ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands 91082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands/// SimplifyMulInst - Given operands for a Mul, see if we can 91182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands/// fold the result. If not, this returns null. 91282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sandsstatic Value *SimplifyMulInst(Value *Op0, Value *Op1, const TargetData *TD, 913618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 91482fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands const DominatorTree *DT, unsigned MaxRecurse) { 91582fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 91682fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 91782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands Constant *Ops[] = { CLHS, CRHS }; 91882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return ConstantFoldInstOperands(Instruction::Mul, CLHS->getType(), 919618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Ops, TD, TLI); 92082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands } 92182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 92282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // Canonicalize the constant to the RHS. 92382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands std::swap(Op0, Op1); 92482fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands } 92582fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 92682fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // X * undef -> 0 927f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 92882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return Constant::getNullValue(Op0->getType()); 92982fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 93082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // X * 0 -> 0 93182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (match(Op1, m_Zero())) 93282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return Op1; 93382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 93482fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // X * 1 -> X 93582fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (match(Op1, m_One())) 93682fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return Op0; 93782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 9381895e98ef38afbe011575cc25f4889d96e37421bDuncan Sands // (X / Y) * Y -> X if the division is exact. 93955c6d57734cd2f141dc2d6912fc22746d5eeae54Benjamin Kramer Value *X = 0; 94055c6d57734cd2f141dc2d6912fc22746d5eeae54Benjamin Kramer if (match(Op0, m_Exact(m_IDiv(m_Value(X), m_Specific(Op1)))) || // (X / Y) * Y 94155c6d57734cd2f141dc2d6912fc22746d5eeae54Benjamin Kramer match(Op1, m_Exact(m_IDiv(m_Value(X), m_Specific(Op0))))) // Y * (X / Y) 94255c6d57734cd2f141dc2d6912fc22746d5eeae54Benjamin Kramer return X; 9431895e98ef38afbe011575cc25f4889d96e37421bDuncan Sands 9445413880654585f01ea9880f24f07f27c8da56ba8Nick Lewycky // i1 mul -> and. 94575d289ed6201e82718343d7a36d2a2fa082f6217Duncan Sands if (MaxRecurse && Op0->getType()->isIntegerTy(1)) 946618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyAndInst(Op0, Op1, TD, TLI, DT, MaxRecurse-1)) 94707f30fbd734069b80b90c6aeea0ae645ce3880c0Duncan Sands return V; 94882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 94982fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // Try some generic simplifications for associative operations. 950618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyAssociativeBinOp(Instruction::Mul, Op0, Op1, TD, TLI, DT, 95182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands MaxRecurse)) 95282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return V; 95382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 95482fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // Mul distributes over Add. Try some generic simplifications based on this. 95582fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (Value *V = ExpandBinOp(Instruction::Mul, Op0, Op1, Instruction::Add, 956618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT, MaxRecurse)) 95782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return V; 95882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 95982fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // If the operation is with the result of a select instruction, check whether 96082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // operating on either branch of the select always yields the same value. 96182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) 962618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = ThreadBinOpOverSelect(Instruction::Mul, Op0, Op1, TD, TLI, DT, 96382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands MaxRecurse)) 96482fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return V; 96582fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 96682fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // If the operation is with the result of a phi instruction, check whether 96782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // operating on all incoming values of the phi always yields the same value. 96882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (isa<PHINode>(Op0) || isa<PHINode>(Op1)) 969618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = ThreadBinOpOverPHI(Instruction::Mul, Op0, Op1, TD, TLI, DT, 97082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands MaxRecurse)) 97182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return V; 97282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 97382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return 0; 97482fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands} 97582fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 97682fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan SandsValue *llvm::SimplifyMulInst(Value *Op0, Value *Op1, const TargetData *TD, 977618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 97882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands const DominatorTree *DT) { 979618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ::SimplifyMulInst(Op0, Op1, TD, TLI, DT, RecursionLimit); 98082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands} 98182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 982593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands/// SimplifyDiv - Given operands for an SDiv or UDiv, see if we can 983593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands/// fold the result. If not, this returns null. 984479b4b9ef06dd84097202ffa6aea07913cdf651cAnders Carlssonstatic Value *SimplifyDiv(Instruction::BinaryOps Opcode, Value *Op0, Value *Op1, 985618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, const TargetLibraryInfo *TLI, 986618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT, unsigned MaxRecurse) { 987593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Constant *C0 = dyn_cast<Constant>(Op0)) { 988593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Constant *C1 = dyn_cast<Constant>(Op1)) { 989593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands Constant *Ops[] = { C0, C1 }; 990618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ConstantFoldInstOperands(Opcode, C0->getType(), Ops, TD, TLI); 991593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands } 992593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands } 993593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 994a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands bool isSigned = Opcode == Instruction::SDiv; 995a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands 996593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // X / undef -> undef 997f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 998593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return Op1; 999593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1000593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // undef / X -> 0 1001f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op0, m_Undef())) 1002593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return Constant::getNullValue(Op0->getType()); 1003593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1004593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // 0 / X -> 0, we don't need to preserve faults! 1005593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (match(Op0, m_Zero())) 1006593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return Op0; 1007593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1008593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // X / 1 -> X 1009593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (match(Op1, m_One())) 1010593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return Op0; 1011593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1012593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Op0->getType()->isIntegerTy(1)) 1013593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // It can't be division by zero, hence it must be division by one. 1014593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return Op0; 1015593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1016593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // X / X -> 1 1017593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Op0 == Op1) 1018593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return ConstantInt::get(Op0->getType(), 1); 1019593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1020593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // (X * Y) / Y -> X if the multiplication does not overflow. 1021593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands Value *X = 0, *Y = 0; 1022593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (match(Op0, m_Mul(m_Value(X), m_Value(Y))) && (X == Op1 || Y == Op1)) { 1023593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Y != Op1) std::swap(X, Y); // Ensure expression is (X * Y) / Y, Y = Op1 102432a43cc0fc3cd42702d7859eaa58dd42f561a54dDuncan Sands OverflowingBinaryOperator *Mul = cast<OverflowingBinaryOperator>(Op0); 10254b720718fbda1194f925e0a9d931bc220e8b0e3aDuncan Sands // If the Mul knows it does not overflow, then we are good to go. 10264b720718fbda1194f925e0a9d931bc220e8b0e3aDuncan Sands if ((isSigned && Mul->hasNoSignedWrap()) || 10274b720718fbda1194f925e0a9d931bc220e8b0e3aDuncan Sands (!isSigned && Mul->hasNoUnsignedWrap())) 10284b720718fbda1194f925e0a9d931bc220e8b0e3aDuncan Sands return X; 1029593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // If X has the form X = A / Y then X * Y cannot overflow. 1030593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (BinaryOperator *Div = dyn_cast<BinaryOperator>(X)) 1031593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Div->getOpcode() == Opcode && Div->getOperand(1) == Y) 1032593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return X; 1033593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands } 1034593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1035a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands // (X rem Y) / Y -> 0 1036a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands if ((isSigned && match(Op0, m_SRem(m_Value(), m_Specific(Op1)))) || 1037a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands (!isSigned && match(Op0, m_URem(m_Value(), m_Specific(Op1))))) 1038a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands return Constant::getNullValue(Op0->getType()); 1039a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands 1040a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands // If the operation is with the result of a select instruction, check whether 1041a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands // operating on either branch of the select always yields the same value. 1042a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) 1043618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = ThreadBinOpOverSelect(Opcode, Op0, Op1, TD, TLI, DT, 1044618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier MaxRecurse)) 1045a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands return V; 1046a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands 1047a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands // If the operation is with the result of a phi instruction, check whether 1048a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands // operating on all incoming values of the phi always yields the same value. 1049a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands if (isa<PHINode>(Op0) || isa<PHINode>(Op1)) 1050618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = ThreadBinOpOverPHI(Opcode, Op0, Op1, TD, TLI, DT, 1051618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier MaxRecurse)) 1052a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands return V; 1053a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands 1054593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return 0; 1055593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands} 1056593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1057593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands/// SimplifySDivInst - Given operands for an SDiv, see if we can 1058593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands/// fold the result. If not, this returns null. 1059593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sandsstatic Value *SimplifySDivInst(Value *Op0, Value *Op1, const TargetData *TD, 1060618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1061593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands const DominatorTree *DT, unsigned MaxRecurse) { 1062618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyDiv(Instruction::SDiv, Op0, Op1, TD, TLI, DT, 1063618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier MaxRecurse)) 1064593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return V; 1065593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1066593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return 0; 1067593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands} 1068593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1069593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan SandsValue *llvm::SimplifySDivInst(Value *Op0, Value *Op1, const TargetData *TD, 1070618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 10711fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel const DominatorTree *DT) { 1072618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ::SimplifySDivInst(Op0, Op1, TD, TLI, DT, RecursionLimit); 1073593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands} 1074593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1075593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands/// SimplifyUDivInst - Given operands for a UDiv, see if we can 1076593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands/// fold the result. If not, this returns null. 1077593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sandsstatic Value *SimplifyUDivInst(Value *Op0, Value *Op1, const TargetData *TD, 1078618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1079593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands const DominatorTree *DT, unsigned MaxRecurse) { 1080618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyDiv(Instruction::UDiv, Op0, Op1, TD, TLI, DT, 1081618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier MaxRecurse)) 1082593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return V; 1083593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1084593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return 0; 1085593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands} 1086593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1087593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan SandsValue *llvm::SimplifyUDivInst(Value *Op0, Value *Op1, const TargetData *TD, 1088618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 10891fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel const DominatorTree *DT) { 1090618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ::SimplifyUDivInst(Op0, Op1, TD, TLI, DT, RecursionLimit); 1091593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands} 1092593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1093f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sandsstatic Value *SimplifyFDivInst(Value *Op0, Value *Op1, const TargetData *, 1094618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *, 1095f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands const DominatorTree *, unsigned) { 10961fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel // undef / X -> undef (the undef could be a snan). 1097f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op0, m_Undef())) 10981fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel return Op0; 10991fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel 11001fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel // X / undef -> undef 1101f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 11021fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel return Op1; 11031fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel 11041fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel return 0; 11051fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel} 11061fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel 11071fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van BommelValue *llvm::SimplifyFDivInst(Value *Op0, Value *Op1, const TargetData *TD, 1108618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 11091fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel const DominatorTree *DT) { 1110618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ::SimplifyFDivInst(Op0, Op1, TD, TLI, DT, RecursionLimit); 11111fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel} 11121fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel 1113f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands/// SimplifyRem - Given operands for an SRem or URem, see if we can 1114f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands/// fold the result. If not, this returns null. 1115f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sandsstatic Value *SimplifyRem(Instruction::BinaryOps Opcode, Value *Op0, Value *Op1, 1116618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, const TargetLibraryInfo *TLI, 1117618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT, unsigned MaxRecurse) { 1118f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (Constant *C0 = dyn_cast<Constant>(Op0)) { 1119f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (Constant *C1 = dyn_cast<Constant>(Op1)) { 1120f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands Constant *Ops[] = { C0, C1 }; 1121618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ConstantFoldInstOperands(Opcode, C0->getType(), Ops, TD, TLI); 1122f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands } 1123f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands } 1124f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1125f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // X % undef -> undef 1126f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op1, m_Undef())) 1127f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Op1; 1128f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1129f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // undef % X -> 0 1130f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op0, m_Undef())) 1131f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Constant::getNullValue(Op0->getType()); 1132f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1133f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // 0 % X -> 0, we don't need to preserve faults! 1134f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op0, m_Zero())) 1135f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Op0; 1136f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1137f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // X % 0 -> undef, we don't need to preserve faults! 1138f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op1, m_Zero())) 1139f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return UndefValue::get(Op0->getType()); 1140f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1141f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // X % 1 -> 0 1142f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op1, m_One())) 1143f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Constant::getNullValue(Op0->getType()); 1144f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1145f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (Op0->getType()->isIntegerTy(1)) 1146f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // It can't be remainder by zero, hence it must be remainder by one. 1147f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Constant::getNullValue(Op0->getType()); 1148f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1149f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // X % X -> 0 1150f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (Op0 == Op1) 1151f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Constant::getNullValue(Op0->getType()); 1152f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1153f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // If the operation is with the result of a select instruction, check whether 1154f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // operating on either branch of the select always yields the same value. 1155f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) 1156618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = ThreadBinOpOverSelect(Opcode, Op0, Op1, TD, TLI, DT, MaxRecurse)) 1157f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return V; 1158f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1159f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // If the operation is with the result of a phi instruction, check whether 1160f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // operating on all incoming values of the phi always yields the same value. 1161f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (isa<PHINode>(Op0) || isa<PHINode>(Op1)) 1162618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = ThreadBinOpOverPHI(Opcode, Op0, Op1, TD, TLI, DT, MaxRecurse)) 1163f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return V; 1164f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1165f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return 0; 1166f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1167f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1168f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands/// SimplifySRemInst - Given operands for an SRem, see if we can 1169f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands/// fold the result. If not, this returns null. 1170f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sandsstatic Value *SimplifySRemInst(Value *Op0, Value *Op1, const TargetData *TD, 1171618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1172618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT, 1173618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier unsigned MaxRecurse) { 1174618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyRem(Instruction::SRem, Op0, Op1, TD, TLI, DT, MaxRecurse)) 1175f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return V; 1176f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1177f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return 0; 1178f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1179f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1180f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan SandsValue *llvm::SimplifySRemInst(Value *Op0, Value *Op1, const TargetData *TD, 1181618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1182f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands const DominatorTree *DT) { 1183618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ::SimplifySRemInst(Op0, Op1, TD, TLI, DT, RecursionLimit); 1184f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1185f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1186f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands/// SimplifyURemInst - Given operands for a URem, see if we can 1187f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands/// fold the result. If not, this returns null. 1188f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sandsstatic Value *SimplifyURemInst(Value *Op0, Value *Op1, const TargetData *TD, 1189618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1190618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT, 1191618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier unsigned MaxRecurse) { 1192618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyRem(Instruction::URem, Op0, Op1, TD, TLI, DT, MaxRecurse)) 1193f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return V; 1194f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1195f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return 0; 1196f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1197f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1198f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan SandsValue *llvm::SimplifyURemInst(Value *Op0, Value *Op1, const TargetData *TD, 1199618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1200f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands const DominatorTree *DT) { 1201618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ::SimplifyURemInst(Op0, Op1, TD, TLI, DT, RecursionLimit); 1202f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1203f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1204f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sandsstatic Value *SimplifyFRemInst(Value *Op0, Value *Op1, const TargetData *, 1205618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *, 1206618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *, 1207618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier unsigned) { 1208f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // undef % X -> undef (the undef could be a snan). 1209f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op0, m_Undef())) 1210f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Op0; 1211f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1212f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // X % undef -> undef 1213f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op1, m_Undef())) 1214f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Op1; 1215f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1216f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return 0; 1217f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1218f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1219f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan SandsValue *llvm::SimplifyFRemInst(Value *Op0, Value *Op1, const TargetData *TD, 1220618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1221f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands const DominatorTree *DT) { 1222618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ::SimplifyFRemInst(Op0, Op1, TD, TLI, DT, RecursionLimit); 1223f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1224f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1225cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands/// SimplifyShift - Given operands for an Shl, LShr or AShr, see if we can 1226c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands/// fold the result. If not, this returns null. 1227cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sandsstatic Value *SimplifyShift(unsigned Opcode, Value *Op0, Value *Op1, 1228618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, const TargetLibraryInfo *TLI, 1229618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT, unsigned MaxRecurse) { 1230c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands if (Constant *C0 = dyn_cast<Constant>(Op0)) { 1231c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands if (Constant *C1 = dyn_cast<Constant>(Op1)) { 1232c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands Constant *Ops[] = { C0, C1 }; 1233618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ConstantFoldInstOperands(Opcode, C0->getType(), Ops, TD, TLI); 1234c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands } 1235c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands } 1236c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1237cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // 0 shift by X -> 0 1238c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands if (match(Op0, m_Zero())) 1239c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return Op0; 1240c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1241cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // X shift by 0 -> X 1242c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands if (match(Op1, m_Zero())) 1243c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return Op0; 1244c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1245cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // X shift by undef -> undef because it may shift by the bitwidth. 1246f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 1247c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return Op1; 1248c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1249c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands // Shifting by the bitwidth or more is undefined. 1250c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands if (ConstantInt *CI = dyn_cast<ConstantInt>(Op1)) 1251c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands if (CI->getValue().getLimitedValue() >= 1252c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands Op0->getType()->getScalarSizeInBits()) 1253c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return UndefValue::get(Op0->getType()); 1254c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1255cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // If the operation is with the result of a select instruction, check whether 1256cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // operating on either branch of the select always yields the same value. 1257cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) 1258618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = ThreadBinOpOverSelect(Opcode, Op0, Op1, TD, TLI, DT, MaxRecurse)) 1259cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return V; 1260cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands 1261cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // If the operation is with the result of a phi instruction, check whether 1262cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // operating on all incoming values of the phi always yields the same value. 1263cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands if (isa<PHINode>(Op0) || isa<PHINode>(Op1)) 1264618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = ThreadBinOpOverPHI(Opcode, Op0, Op1, TD, TLI, DT, MaxRecurse)) 1265cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return V; 1266cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands 1267cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return 0; 1268cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands} 1269cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands 1270cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands/// SimplifyShlInst - Given operands for an Shl, see if we can 1271cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands/// fold the result. If not, this returns null. 127281a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattnerstatic Value *SimplifyShlInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, 1273618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, 1274618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1275618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT, unsigned MaxRecurse) { 1276618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyShift(Instruction::Shl, Op0, Op1, TD, TLI, DT, MaxRecurse)) 1277cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return V; 1278cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands 1279cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // undef << X -> 0 1280f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op0, m_Undef())) 1281cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return Constant::getNullValue(Op0->getType()); 1282cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands 128381a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner // (X >> A) << A -> X 128481a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Value *X; 128555c6d57734cd2f141dc2d6912fc22746d5eeae54Benjamin Kramer if (match(Op0, m_Exact(m_Shr(m_Value(X), m_Specific(Op1))))) 128681a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner return X; 1287c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return 0; 1288c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands} 1289c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 129081a0dc911586c77421c2255aa417dc9b350b9e20Chris LattnerValue *llvm::SimplifyShlInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, 1291618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, const TargetLibraryInfo *TLI, 1292618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT) { 1293618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ::SimplifyShlInst(Op0, Op1, isNSW, isNUW, TD, TLI, DT, RecursionLimit); 1294c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands} 1295c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1296c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands/// SimplifyLShrInst - Given operands for an LShr, see if we can 1297c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands/// fold the result. If not, this returns null. 129881a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattnerstatic Value *SimplifyLShrInst(Value *Op0, Value *Op1, bool isExact, 1299618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, 1300618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1301618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT, 130281a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner unsigned MaxRecurse) { 1303618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyShift(Instruction::LShr, Op0, Op1, TD, TLI, DT, MaxRecurse)) 1304cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return V; 1305c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1306c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands // undef >>l X -> 0 1307f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op0, m_Undef())) 1308c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return Constant::getNullValue(Op0->getType()); 1309c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 131081a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner // (X << A) >> A -> X 131181a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Value *X; 131281a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner if (match(Op0, m_Shl(m_Value(X), m_Specific(Op1))) && 131381a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner cast<OverflowingBinaryOperator>(Op0)->hasNoUnsignedWrap()) 131481a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner return X; 131552fb846578714d14bbde9b28884a6a8729217677Duncan Sands 1316c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return 0; 1317c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands} 1318c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 131981a0dc911586c77421c2255aa417dc9b350b9e20Chris LattnerValue *llvm::SimplifyLShrInst(Value *Op0, Value *Op1, bool isExact, 1320618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, 1321618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1322618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT) { 1323618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ::SimplifyLShrInst(Op0, Op1, isExact, TD, TLI, DT, RecursionLimit); 1324c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands} 1325c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1326c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands/// SimplifyAShrInst - Given operands for an AShr, see if we can 1327c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands/// fold the result. If not, this returns null. 132881a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattnerstatic Value *SimplifyAShrInst(Value *Op0, Value *Op1, bool isExact, 1329618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, 1330618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1331618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT, 133281a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner unsigned MaxRecurse) { 1333618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyShift(Instruction::AShr, Op0, Op1, TD, TLI, DT, MaxRecurse)) 1334cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return V; 1335c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1336c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands // all ones >>a X -> all ones 1337c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands if (match(Op0, m_AllOnes())) 1338c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return Op0; 1339c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1340c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands // undef >>a X -> all ones 1341f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op0, m_Undef())) 1342c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return Constant::getAllOnesValue(Op0->getType()); 1343c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 134481a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner // (X << A) >> A -> X 134581a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Value *X; 134681a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner if (match(Op0, m_Shl(m_Value(X), m_Specific(Op1))) && 134781a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner cast<OverflowingBinaryOperator>(Op0)->hasNoSignedWrap()) 134881a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner return X; 134952fb846578714d14bbde9b28884a6a8729217677Duncan Sands 1350c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return 0; 1351c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands} 1352c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 135381a0dc911586c77421c2255aa417dc9b350b9e20Chris LattnerValue *llvm::SimplifyAShrInst(Value *Op0, Value *Op1, bool isExact, 1354618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, 1355618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1356618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT) { 1357618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ::SimplifyAShrInst(Op0, Op1, isExact, TD, TLI, DT, RecursionLimit); 1358c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands} 1359c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 13608aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner/// SimplifyAndInst - Given operands for an And, see if we can 13618aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner/// fold the result. If not, this returns null. 1362618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosierstatic Value *SimplifyAndInst(Value *Op0, Value *Op1, const TargetData *TD, 1363618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1364618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT, 1365618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier unsigned MaxRecurse) { 13668aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 13678aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 13688aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner Constant *Ops[] = { CLHS, CRHS }; 1369d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return ConstantFoldInstOperands(Instruction::And, CLHS->getType(), 1370618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Ops, TD, TLI); 1371d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 137212a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1373d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // Canonicalize the constant to the RHS. 1374d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner std::swap(Op0, Op1); 1375d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 137612a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1377d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X & undef -> 0 1378f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 1379d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Constant::getNullValue(Op0->getType()); 138012a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1381d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X & X = X 1382124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (Op0 == Op1) 1383d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 138412a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 13852b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // X & 0 = 0 13862b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (match(Op1, m_Zero())) 1387d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op1; 138812a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 13892b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // X & -1 = X 13902b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (match(Op1, m_AllOnes())) 13912b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return Op0; 139212a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1393d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // A & ~A = ~A & A = 0 139481a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner if (match(Op0, m_Not(m_Specific(Op1))) || 139581a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner match(Op1, m_Not(m_Specific(Op0)))) 1396d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Constant::getNullValue(Op0->getType()); 139712a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1398d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // (A | ?) & A = A 139981a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Value *A = 0, *B = 0; 1400d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (match(Op0, m_Or(m_Value(A), m_Value(B))) && 1401124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands (A == Op1 || B == Op1)) 1402d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op1; 140312a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1404d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // A & (A | ?) = A 1405d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (match(Op1, m_Or(m_Value(A), m_Value(B))) && 1406124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands (A == Op0 || B == Op0)) 1407d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 140812a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1409dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands // A & (-A) = A if A is a power of two or zero. 1410dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands if (match(Op0, m_Neg(m_Specific(Op1))) || 1411dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands match(Op1, m_Neg(m_Specific(Op0)))) { 1412dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands if (isPowerOfTwo(Op0, TD, /*OrZero*/true)) 1413dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands return Op0; 1414dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands if (isPowerOfTwo(Op1, TD, /*OrZero*/true)) 1415dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands return Op1; 1416dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands } 1417dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands 1418566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Try some generic simplifications for associative operations. 1419618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyAssociativeBinOp(Instruction::And, Op0, Op1, TD, TLI, 1420618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier DT, MaxRecurse)) 1421566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return V; 14226844c8ea5a67e551be7106d6b7b9e1a64eecbe51Benjamin Kramer 14233421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // And distributes over Or. Try some generic simplifications based on this. 14243421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = ExpandBinOp(Instruction::And, Op0, Op1, Instruction::Or, 1425618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT, MaxRecurse)) 14263421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 14273421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 14283421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // And distributes over Xor. Try some generic simplifications based on this. 14293421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = ExpandBinOp(Instruction::And, Op0, Op1, Instruction::Xor, 1430618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT, MaxRecurse)) 14313421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 14323421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 14333421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Or distributes over And. Try some generic simplifications based on this. 14343421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = FactorizeBinOp(Instruction::And, Op0, Op1, Instruction::Or, 1435618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT, MaxRecurse)) 14363421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 14373421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1438b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // If the operation is with the result of a select instruction, check whether 1439b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // operating on either branch of the select always yields the same value. 14400312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) 1441618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = ThreadBinOpOverSelect(Instruction::And, Op0, Op1, TD, TLI, 1442618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier DT, MaxRecurse)) 1443a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return V; 1444a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 1445a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the operation is with the result of a phi instruction, check whether 1446a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // operating on all incoming values of the phi always yields the same value. 14470312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<PHINode>(Op0) || isa<PHINode>(Op1)) 1448618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = ThreadBinOpOverPHI(Instruction::And, Op0, Op1, TD, TLI, DT, 14490312a93693abc2eb682b2b101c889959888fd883Duncan Sands MaxRecurse)) 1450b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return V; 1451b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 1452d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return 0; 1453d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner} 14549f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 14551845009290e4d804ad377927bd8a08cca3036adcDuncan SandsValue *llvm::SimplifyAndInst(Value *Op0, Value *Op1, const TargetData *TD, 1456618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 14571845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const DominatorTree *DT) { 1458618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ::SimplifyAndInst(Op0, Op1, TD, TLI, DT, RecursionLimit); 1459a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 1460a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 1461d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner/// SimplifyOrInst - Given operands for an Or, see if we can 14629f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner/// fold the result. If not, this returns null. 1463618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosierstatic Value *SimplifyOrInst(Value *Op0, Value *Op1, const TargetData *TD, 1464618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 14651845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const DominatorTree *DT, unsigned MaxRecurse) { 1466d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 1467d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 1468d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Constant *Ops[] = { CLHS, CRHS }; 1469d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return ConstantFoldInstOperands(Instruction::Or, CLHS->getType(), 1470618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Ops, TD, TLI); 1471d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 147212a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1473d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // Canonicalize the constant to the RHS. 1474d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner std::swap(Op0, Op1); 1475d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 147612a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1477d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X | undef -> -1 1478f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 1479d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Constant::getAllOnesValue(Op0->getType()); 148012a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1481d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X | X = X 1482124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (Op0 == Op1) 1483d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 1484d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 14852b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // X | 0 = X 14862b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (match(Op1, m_Zero())) 1487d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 148812a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 14892b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // X | -1 = -1 14902b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (match(Op1, m_AllOnes())) 14912b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return Op1; 149212a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1493d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // A | ~A = ~A | A = -1 149481a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner if (match(Op0, m_Not(m_Specific(Op1))) || 149581a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner match(Op1, m_Not(m_Specific(Op0)))) 1496d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Constant::getAllOnesValue(Op0->getType()); 149712a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1498d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // (A & ?) | A = A 149981a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Value *A = 0, *B = 0; 1500d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (match(Op0, m_And(m_Value(A), m_Value(B))) && 1501124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands (A == Op1 || B == Op1)) 1502d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op1; 150312a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1504d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // A | (A & ?) = A 1505d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (match(Op1, m_And(m_Value(A), m_Value(B))) && 1506124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands (A == Op0 || B == Op0)) 1507d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 150812a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 150938f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer // ~(A & ?) | A = -1 151038f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer if (match(Op0, m_Not(m_And(m_Value(A), m_Value(B)))) && 151138f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer (A == Op1 || B == Op1)) 151238f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer return Constant::getAllOnesValue(Op1->getType()); 151338f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer 151438f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer // A | ~(A & ?) = -1 151538f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer if (match(Op1, m_Not(m_And(m_Value(A), m_Value(B)))) && 151638f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer (A == Op0 || B == Op0)) 151738f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer return Constant::getAllOnesValue(Op0->getType()); 151838f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer 1519566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Try some generic simplifications for associative operations. 1520618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyAssociativeBinOp(Instruction::Or, Op0, Op1, TD, TLI, 1521618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier DT, MaxRecurse)) 1522566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return V; 15236844c8ea5a67e551be7106d6b7b9e1a64eecbe51Benjamin Kramer 15243421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Or distributes over And. Try some generic simplifications based on this. 1525618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = ExpandBinOp(Instruction::Or, Op0, Op1, Instruction::And, TD, 1526618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TLI, DT, MaxRecurse)) 15273421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 15283421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 15293421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // And distributes over Or. Try some generic simplifications based on this. 15303421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = FactorizeBinOp(Instruction::Or, Op0, Op1, Instruction::And, 1531618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT, MaxRecurse)) 15323421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 15333421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1534b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // If the operation is with the result of a select instruction, check whether 1535b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // operating on either branch of the select always yields the same value. 15360312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) 1537618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = ThreadBinOpOverSelect(Instruction::Or, Op0, Op1, TD, TLI, DT, 15380312a93693abc2eb682b2b101c889959888fd883Duncan Sands MaxRecurse)) 1539a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return V; 1540a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 1541a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the operation is with the result of a phi instruction, check whether 1542a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // operating on all incoming values of the phi always yields the same value. 15430312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<PHINode>(Op0) || isa<PHINode>(Op1)) 1544618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = ThreadBinOpOverPHI(Instruction::Or, Op0, Op1, TD, TLI, DT, 15450312a93693abc2eb682b2b101c889959888fd883Duncan Sands MaxRecurse)) 1546b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return V; 1547b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 15489f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner return 0; 15499f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner} 15509f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 15511845009290e4d804ad377927bd8a08cca3036adcDuncan SandsValue *llvm::SimplifyOrInst(Value *Op0, Value *Op1, const TargetData *TD, 1552618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 15531845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const DominatorTree *DT) { 1554618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ::SimplifyOrInst(Op0, Op1, TD, TLI, DT, RecursionLimit); 1555a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 1556d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 15572b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands/// SimplifyXorInst - Given operands for a Xor, see if we can 15582b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands/// fold the result. If not, this returns null. 15592b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sandsstatic Value *SimplifyXorInst(Value *Op0, Value *Op1, const TargetData *TD, 1560618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 15612b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands const DominatorTree *DT, unsigned MaxRecurse) { 15622b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 15632b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 15642b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands Constant *Ops[] = { CLHS, CRHS }; 15652b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return ConstantFoldInstOperands(Instruction::Xor, CLHS->getType(), 1566618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Ops, TD, TLI); 15672b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands } 15682b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 15692b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // Canonicalize the constant to the RHS. 15702b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands std::swap(Op0, Op1); 15712b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands } 15722b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 15732b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // A ^ undef -> undef 1574f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 1575f8b1a5ea9602bb65a5cf59d3d34f2851a08cdc3eDuncan Sands return Op1; 15762b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 15772b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // A ^ 0 = A 15782b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (match(Op1, m_Zero())) 15792b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return Op0; 15802b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 1581f23d4adbfaf870d5fa67c6bff0da7891d3a98f9dEli Friedman // A ^ A = 0 1582f23d4adbfaf870d5fa67c6bff0da7891d3a98f9dEli Friedman if (Op0 == Op1) 1583f23d4adbfaf870d5fa67c6bff0da7891d3a98f9dEli Friedman return Constant::getNullValue(Op0->getType()); 1584f23d4adbfaf870d5fa67c6bff0da7891d3a98f9dEli Friedman 15852b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // A ^ ~A = ~A ^ A = -1 158681a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner if (match(Op0, m_Not(m_Specific(Op1))) || 158781a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner match(Op1, m_Not(m_Specific(Op0)))) 15882b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return Constant::getAllOnesValue(Op0->getType()); 15892b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 1590566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Try some generic simplifications for associative operations. 1591618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyAssociativeBinOp(Instruction::Xor, Op0, Op1, TD, TLI, 1592618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier DT, MaxRecurse)) 1593566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return V; 15942b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 15953421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // And distributes over Xor. Try some generic simplifications based on this. 15963421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = FactorizeBinOp(Instruction::Xor, Op0, Op1, Instruction::And, 1597618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT, MaxRecurse)) 15983421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 15993421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 160087689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // Threading Xor over selects and phi nodes is pointless, so don't bother. 160187689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // Threading over the select in "A ^ select(cond, B, C)" means evaluating 160287689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // "A^B" and "A^C" and seeing if they are equal; but they are equal if and 160387689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // only if B and C are equal. If B and C are equal then (since we assume 160487689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // that operands have already been simplified) "select(cond, B, C)" should 160587689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // have been simplified to the common value of B and C already. Analysing 160687689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // "A^B" and "A^C" thus gains nothing, but costs compile time. Similarly 160787689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // for threading over phi nodes. 16082b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 16092b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return 0; 16102b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands} 16112b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 16122b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan SandsValue *llvm::SimplifyXorInst(Value *Op0, Value *Op1, const TargetData *TD, 1613618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 16142b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands const DominatorTree *DT) { 1615618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ::SimplifyXorInst(Op0, Op1, TD, TLI, DT, RecursionLimit); 16162b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands} 16172b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 1618db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattnerstatic Type *GetCompareTy(Value *Op) { 1619210c5d4880b525e064088b6fec713260128c16ebChris Lattner return CmpInst::makeCmpResultType(Op->getType()); 1620210c5d4880b525e064088b6fec713260128c16ebChris Lattner} 1621210c5d4880b525e064088b6fec713260128c16ebChris Lattner 1622e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands/// ExtractEquivalentCondition - Rummage around inside V looking for something 1623e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands/// equivalent to the comparison "LHS Pred RHS". Return such a value if found, 1624e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands/// otherwise return null. Helper function for analyzing max/min idioms. 1625e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sandsstatic Value *ExtractEquivalentCondition(Value *V, CmpInst::Predicate Pred, 1626e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands Value *LHS, Value *RHS) { 1627e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands SelectInst *SI = dyn_cast<SelectInst>(V); 1628e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (!SI) 1629e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return 0; 1630e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands CmpInst *Cmp = dyn_cast<CmpInst>(SI->getCondition()); 1631e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (!Cmp) 1632e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return 0; 1633e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands Value *CmpLHS = Cmp->getOperand(0), *CmpRHS = Cmp->getOperand(1); 1634e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Pred == Cmp->getPredicate() && LHS == CmpLHS && RHS == CmpRHS) 1635e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return Cmp; 1636e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Pred == CmpInst::getSwappedPredicate(Cmp->getPredicate()) && 1637e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands LHS == CmpRHS && RHS == CmpLHS) 1638e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return Cmp; 1639e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return 0; 1640e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands} 1641e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands 1642009e2650d69fe93bda1864340c5f000e56c52fb8Chris Lattner 16439dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// SimplifyICmpInst - Given operands for an ICmpInst, see if we can 16449dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// fold the result. If not, this returns null. 1645a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS, 1646618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, 1647618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1648618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT, 16491845009290e4d804ad377927bd8a08cca3036adcDuncan Sands unsigned MaxRecurse) { 16509f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner CmpInst::Predicate Pred = (CmpInst::Predicate)Predicate; 16519dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner assert(CmpInst::isIntPredicate(Pred) && "Not an integer compare!"); 165212a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1653d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(LHS)) { 16548f73deaa8732a556046bf4ac6207be55972e3b74Chris Lattner if (Constant *CRHS = dyn_cast<Constant>(RHS)) 1655618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ConstantFoldCompareInstOperands(Pred, CLHS, CRHS, TD, TLI); 1656d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 1657d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // If we have a constant, make sure it is on the RHS. 1658d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner std::swap(LHS, RHS); 1659d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Pred = CmpInst::getSwappedPredicate(Pred); 1660d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 166112a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1662db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *ITy = GetCompareTy(LHS); // The return type. 1663db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *OpTy = LHS->getType(); // The operand type. 166412a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1665210c5d4880b525e064088b6fec713260128c16ebChris Lattner // icmp X, X -> true/false 1666c8e14b3d37b80abb6adb4b831af0452d9ecbf2b2Chris Lattner // X icmp undef -> true/false. For example, icmp ugt %X, undef -> false 1667c8e14b3d37b80abb6adb4b831af0452d9ecbf2b2Chris Lattner // because X could be 0. 1668124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (LHS == RHS || isa<UndefValue>(RHS)) 1669210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(ITy, CmpInst::isTrueWhenEqual(Pred)); 167012a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 16716dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // Special case logic when the operands have i1 type. 167266d004ef708642bbdc38fd761507f2e9ee3970cdNick Lewycky if (OpTy->getScalarType()->isIntegerTy(1)) { 16736dc91253ab1872e118b08511a09d5c934988354eDuncan Sands switch (Pred) { 16746dc91253ab1872e118b08511a09d5c934988354eDuncan Sands default: break; 16756dc91253ab1872e118b08511a09d5c934988354eDuncan Sands case ICmpInst::ICMP_EQ: 16766dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // X == 1 -> X 16776dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (match(RHS, m_One())) 16786dc91253ab1872e118b08511a09d5c934988354eDuncan Sands return LHS; 16796dc91253ab1872e118b08511a09d5c934988354eDuncan Sands break; 16806dc91253ab1872e118b08511a09d5c934988354eDuncan Sands case ICmpInst::ICMP_NE: 16816dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // X != 0 -> X 16826dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (match(RHS, m_Zero())) 16836dc91253ab1872e118b08511a09d5c934988354eDuncan Sands return LHS; 16846dc91253ab1872e118b08511a09d5c934988354eDuncan Sands break; 16856dc91253ab1872e118b08511a09d5c934988354eDuncan Sands case ICmpInst::ICMP_UGT: 16866dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // X >u 0 -> X 16876dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (match(RHS, m_Zero())) 16886dc91253ab1872e118b08511a09d5c934988354eDuncan Sands return LHS; 16896dc91253ab1872e118b08511a09d5c934988354eDuncan Sands break; 16906dc91253ab1872e118b08511a09d5c934988354eDuncan Sands case ICmpInst::ICMP_UGE: 16916dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // X >=u 1 -> X 16926dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (match(RHS, m_One())) 16936dc91253ab1872e118b08511a09d5c934988354eDuncan Sands return LHS; 16946dc91253ab1872e118b08511a09d5c934988354eDuncan Sands break; 16956dc91253ab1872e118b08511a09d5c934988354eDuncan Sands case ICmpInst::ICMP_SLT: 16966dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // X <s 0 -> X 16976dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (match(RHS, m_Zero())) 16986dc91253ab1872e118b08511a09d5c934988354eDuncan Sands return LHS; 16996dc91253ab1872e118b08511a09d5c934988354eDuncan Sands break; 17006dc91253ab1872e118b08511a09d5c934988354eDuncan Sands case ICmpInst::ICMP_SLE: 17016dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // X <=s -1 -> X 17026dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (match(RHS, m_One())) 17036dc91253ab1872e118b08511a09d5c934988354eDuncan Sands return LHS; 17046dc91253ab1872e118b08511a09d5c934988354eDuncan Sands break; 17056dc91253ab1872e118b08511a09d5c934988354eDuncan Sands } 17066dc91253ab1872e118b08511a09d5c934988354eDuncan Sands } 170712a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1708f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky // icmp <object*>, <object*/null> - Different identified objects have 1709f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky // different addresses (unless null), and what's more the address of an 1710f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky // identified local is never equal to another argument (again, barring null). 1711f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky // Note that generalizing to the case where LHS is a global variable address 1712f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky // or null is pointless, since if both LHS and RHS are constants then we 1713f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky // already constant folded the compare, and if only one of them is then we 1714f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky // moved it to RHS already. 1715ea79b8e03ca7c7be72832c11e9d4d78f11b728b3Benjamin Kramer Value *LHSPtr = LHS->stripPointerCasts(); 1716ea79b8e03ca7c7be72832c11e9d4d78f11b728b3Benjamin Kramer Value *RHSPtr = RHS->stripPointerCasts(); 17172c3acb0e273a50a9b4eeaf9d5544f6168bda85a6Eli Friedman if (LHSPtr == RHSPtr) 17182c3acb0e273a50a9b4eeaf9d5544f6168bda85a6Eli Friedman return ConstantInt::get(ITy, CmpInst::isTrueWhenEqual(Pred)); 1719f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky 1720b053fc1c92b6b81c47d5e2c092b0f3ea04fd5b87Chris Lattner // Be more aggressive about stripping pointer adjustments when checking a 1721b053fc1c92b6b81c47d5e2c092b0f3ea04fd5b87Chris Lattner // comparison of an alloca address to another object. We can rip off all 1722b053fc1c92b6b81c47d5e2c092b0f3ea04fd5b87Chris Lattner // inbounds GEP operations, even if they are variable. 172384dfc32ff906271c373819595e60a173624e1184Chandler Carruth LHSPtr = LHSPtr->stripInBoundsOffsets(); 1724f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky if (llvm::isIdentifiedObject(LHSPtr)) { 172584dfc32ff906271c373819595e60a173624e1184Chandler Carruth RHSPtr = RHSPtr->stripInBoundsOffsets(); 1726f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky if (llvm::isKnownNonNull(LHSPtr) || llvm::isKnownNonNull(RHSPtr)) { 1727f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky // If both sides are different identified objects, they aren't equal 1728f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky // unless they're null. 1729c17731d65d2c059a71256ee995cbb057ff28a109Bill Wendling if (LHSPtr != RHSPtr && llvm::isIdentifiedObject(RHSPtr) && 1730798d013bcba198af628d2dab8448f709b96e4a75Bill Wendling Pred == CmpInst::ICMP_EQ) 1731c17731d65d2c059a71256ee995cbb057ff28a109Bill Wendling return ConstantInt::get(ITy, false); 1732f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky 1733f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky // A local identified object (alloca or noalias call) can't equal any 1734f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky // incoming argument, unless they're both null. 1735c17731d65d2c059a71256ee995cbb057ff28a109Bill Wendling if (isa<Instruction>(LHSPtr) && isa<Argument>(RHSPtr) && 1736798d013bcba198af628d2dab8448f709b96e4a75Bill Wendling Pred == CmpInst::ICMP_EQ) 1737c17731d65d2c059a71256ee995cbb057ff28a109Bill Wendling return ConstantInt::get(ITy, false); 1738f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky } 1739f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky 1740f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky // Assume that the constant null is on the right. 1741c17731d65d2c059a71256ee995cbb057ff28a109Bill Wendling if (llvm::isKnownNonNull(LHSPtr) && isa<ConstantPointerNull>(RHSPtr)) { 1742798d013bcba198af628d2dab8448f709b96e4a75Bill Wendling if (Pred == CmpInst::ICMP_EQ) 1743c17731d65d2c059a71256ee995cbb057ff28a109Bill Wendling return ConstantInt::get(ITy, false); 1744798d013bcba198af628d2dab8448f709b96e4a75Bill Wendling else if (Pred == CmpInst::ICMP_NE) 1745c17731d65d2c059a71256ee995cbb057ff28a109Bill Wendling return ConstantInt::get(ITy, true); 1746c17731d65d2c059a71256ee995cbb057ff28a109Bill Wendling } 1747f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky } else if (isa<Argument>(LHSPtr)) { 174884dfc32ff906271c373819595e60a173624e1184Chandler Carruth RHSPtr = RHSPtr->stripInBoundsOffsets(); 1749f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky // An alloca can't be equal to an argument. 1750c17731d65d2c059a71256ee995cbb057ff28a109Bill Wendling if (isa<AllocaInst>(RHSPtr)) { 1751798d013bcba198af628d2dab8448f709b96e4a75Bill Wendling if (Pred == CmpInst::ICMP_EQ) 1752c17731d65d2c059a71256ee995cbb057ff28a109Bill Wendling return ConstantInt::get(ITy, false); 1753798d013bcba198af628d2dab8448f709b96e4a75Bill Wendling else if (Pred == CmpInst::ICMP_NE) 1754c17731d65d2c059a71256ee995cbb057ff28a109Bill Wendling return ConstantInt::get(ITy, true); 1755c17731d65d2c059a71256ee995cbb057ff28a109Bill Wendling } 1756b053fc1c92b6b81c47d5e2c092b0f3ea04fd5b87Chris Lattner } 1757d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands 1758d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands // If we are comparing with zero then try hard since this is a common case. 1759d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (match(RHS, m_Zero())) { 1760d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands bool LHSKnownNonNegative, LHSKnownNegative; 1761d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands switch (Pred) { 1762858143816d43e58b17bfd11cb1b57afbd7f0f893Craig Topper default: llvm_unreachable("Unknown ICmp predicate!"); 1763d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_ULT: 1764f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 1765d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_UGE: 1766f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 1767d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_EQ: 1768d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_ULE: 1769d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (isKnownNonZero(LHS, TD)) 1770f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 1771d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands break; 1772d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_NE: 1773d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_UGT: 1774d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (isKnownNonZero(LHS, TD)) 1775f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 1776d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands break; 1777d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_SLT: 1778d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, TD); 1779d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNegative) 1780f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 1781d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNonNegative) 1782f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 1783d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands break; 1784d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_SLE: 1785d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, TD); 1786d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNegative) 1787f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 1788d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNonNegative && isKnownNonZero(LHS, TD)) 1789f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 1790d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands break; 1791d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_SGE: 1792d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, TD); 1793d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNegative) 1794f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 1795d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNonNegative) 1796f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 1797d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands break; 1798d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_SGT: 1799d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, TD); 1800d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNegative) 1801f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 1802d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNonNegative && isKnownNonZero(LHS, TD)) 1803f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 1804d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands break; 1805d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands } 1806d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands } 1807d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands 1808d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands // See if we are doing a comparison with a constant integer. 1809210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) { 18103a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // Rule out tautological comparisons (eg., ult 0 or uge 0). 18113a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky ConstantRange RHS_CR = ICmpInst::makeConstantRange(Pred, CI->getValue()); 18123a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (RHS_CR.isEmptySet()) 18133a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky return ConstantInt::getFalse(CI->getContext()); 18143a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (RHS_CR.isFullSet()) 18153a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky return ConstantInt::getTrue(CI->getContext()); 18163a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky 18173a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // Many binary operators with constant RHS have easy to compute constant 18183a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // range. Use them to check whether the comparison is a tautology. 18193a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky uint32_t Width = CI->getBitWidth(); 18203a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt Lower = APInt(Width, 0); 18213a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt Upper = APInt(Width, 0); 18223a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky ConstantInt *CI2; 18233a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (match(LHS, m_URem(m_Value(), m_ConstantInt(CI2)))) { 18243a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'urem x, CI2' produces [0, CI2). 18253a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = CI2->getValue(); 18263a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_SRem(m_Value(), m_ConstantInt(CI2)))) { 18273a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'srem x, CI2' produces (-|CI2|, |CI2|). 18283a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = CI2->getValue().abs(); 18293a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Lower = (-Upper) + 1; 1830c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands } else if (match(LHS, m_UDiv(m_ConstantInt(CI2), m_Value()))) { 1831c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands // 'udiv CI2, x' produces [0, CI2]. 18327781ae5be570940178295f6f808215089a3fe411Eli Friedman Upper = CI2->getValue() + 1; 18333a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_UDiv(m_Value(), m_ConstantInt(CI2)))) { 18343a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'udiv x, CI2' produces [0, UINT_MAX / CI2]. 18353a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt NegOne = APInt::getAllOnesValue(Width); 18363a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (!CI2->isZero()) 18373a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = NegOne.udiv(CI2->getValue()) + 1; 18383a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_SDiv(m_Value(), m_ConstantInt(CI2)))) { 18393a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'sdiv x, CI2' produces [INT_MIN / CI2, INT_MAX / CI2]. 18403a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt IntMin = APInt::getSignedMinValue(Width); 18413a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt IntMax = APInt::getSignedMaxValue(Width); 18423a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt Val = CI2->getValue().abs(); 18433a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (!Val.isMinValue()) { 18443a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Lower = IntMin.sdiv(Val); 18453a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = IntMax.sdiv(Val) + 1; 18463a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } 18473a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_LShr(m_Value(), m_ConstantInt(CI2)))) { 18483a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'lshr x, CI2' produces [0, UINT_MAX >> CI2]. 18493a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt NegOne = APInt::getAllOnesValue(Width); 18503a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (CI2->getValue().ult(Width)) 18513a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = NegOne.lshr(CI2->getValue()) + 1; 18523a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_AShr(m_Value(), m_ConstantInt(CI2)))) { 18533a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'ashr x, CI2' produces [INT_MIN >> CI2, INT_MAX >> CI2]. 18543a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt IntMin = APInt::getSignedMinValue(Width); 18553a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt IntMax = APInt::getSignedMaxValue(Width); 18563a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (CI2->getValue().ult(Width)) { 18573a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Lower = IntMin.ashr(CI2->getValue()); 18583a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = IntMax.ashr(CI2->getValue()) + 1; 18593a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } 18603a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_Or(m_Value(), m_ConstantInt(CI2)))) { 18613a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'or x, CI2' produces [CI2, UINT_MAX]. 18623a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Lower = CI2->getValue(); 18633a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_And(m_Value(), m_ConstantInt(CI2)))) { 18643a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'and x, CI2' produces [0, CI2]. 18653a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = CI2->getValue() + 1; 18663a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } 18673a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (Lower != Upper) { 18683a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky ConstantRange LHS_CR = ConstantRange(Lower, Upper); 18693a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (RHS_CR.contains(LHS_CR)) 18703a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky return ConstantInt::getTrue(RHS->getContext()); 18713a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (RHS_CR.inverse().contains(LHS_CR)) 18723a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky return ConstantInt::getFalse(RHS->getContext()); 1873210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 1874210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 18751ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands 18769d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Compare of cast, for example (zext X) != 0 -> X != 0 18779d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (isa<CastInst>(LHS) && (isa<Constant>(RHS) || isa<CastInst>(RHS))) { 18789d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Instruction *LI = cast<CastInst>(LHS); 18799d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Value *SrcOp = LI->getOperand(0); 1880db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *SrcTy = SrcOp->getType(); 1881db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *DstTy = LI->getType(); 18829d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 18839d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Turn icmp (ptrtoint x), (ptrtoint/constant) into a compare of the input 18849d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // if the integer type is the same size as the pointer type. 18859d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (MaxRecurse && TD && isa<PtrToIntInst>(LI) && 18869d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands TD->getPointerSizeInBits() == DstTy->getPrimitiveSizeInBits()) { 18879d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Constant *RHSC = dyn_cast<Constant>(RHS)) { 18889d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Transfer the cast to the constant. 18899d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(Pred, SrcOp, 18909d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantExpr::getIntToPtr(RHSC, SrcTy), 1891618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT, MaxRecurse-1)) 18929d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 18939d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } else if (PtrToIntInst *RI = dyn_cast<PtrToIntInst>(RHS)) { 18949d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (RI->getOperand(0)->getType() == SrcTy) 18959d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Compare without the cast. 18969d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(Pred, SrcOp, RI->getOperand(0), 1897618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT, MaxRecurse-1)) 18989d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 18999d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 19009d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 19019d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 19029d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (isa<ZExtInst>(LHS)) { 19039d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Turn icmp (zext X), (zext Y) into a compare of X and Y if they have the 19049d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // same type. 19059d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (ZExtInst *RI = dyn_cast<ZExtInst>(RHS)) { 19069d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (MaxRecurse && SrcTy == RI->getOperand(0)->getType()) 19079d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Compare X and Y. Note that signed predicates become unsigned. 19089d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(ICmpInst::getUnsignedPredicate(Pred), 1909618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier SrcOp, RI->getOperand(0), TD, TLI, DT, 19109d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands MaxRecurse-1)) 19119d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 19129d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 19139d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Turn icmp (zext X), Cst into a compare of X and Cst if Cst is extended 19149d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // too. If not, then try to deduce the result of the comparison. 19159d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands else if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) { 19169d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Compute the constant that would happen if we truncated to SrcTy then 19179d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // reextended to DstTy. 19189d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant *Trunc = ConstantExpr::getTrunc(CI, SrcTy); 19199d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant *RExt = ConstantExpr::getCast(CastInst::ZExt, Trunc, DstTy); 19209d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 19219d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // If the re-extended constant didn't change then this is effectively 19229d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // also a case of comparing two zero-extended values. 19239d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (RExt == CI && MaxRecurse) 19249d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(ICmpInst::getUnsignedPredicate(Pred), 19251608769abeb1430dc34f31ffac0d9850f99ae36aNadav Rotem SrcOp, Trunc, TD, TLI, DT, MaxRecurse-1)) 19269d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 19279d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 19289d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Otherwise the upper bits of LHS are zero while RHS has a non-zero bit 19299d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // there. Use this to work out the result of the comparison. 19309d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (RExt != CI) { 19319d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands switch (Pred) { 1932858143816d43e58b17bfd11cb1b57afbd7f0f893Craig Topper default: llvm_unreachable("Unknown ICmp predicate!"); 19339d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // LHS <u RHS. 19349d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_EQ: 19359d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_UGT: 19369d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_UGE: 19379d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return ConstantInt::getFalse(CI->getContext()); 19389d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 19399d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_NE: 19409d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_ULT: 19419d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_ULE: 19429d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return ConstantInt::getTrue(CI->getContext()); 19439d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 19449d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // LHS is non-negative. If RHS is negative then LHS >s LHS. If RHS 19459d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // is non-negative then LHS <s RHS. 19469d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SGT: 19479d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SGE: 19489d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return CI->getValue().isNegative() ? 19499d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getTrue(CI->getContext()) : 19509d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getFalse(CI->getContext()); 19519d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 19529d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SLT: 19539d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SLE: 19549d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return CI->getValue().isNegative() ? 19559d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getFalse(CI->getContext()) : 19569d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getTrue(CI->getContext()); 19579d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 19589d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 19599d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 19609d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 19619d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 19629d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (isa<SExtInst>(LHS)) { 19639d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Turn icmp (sext X), (sext Y) into a compare of X and Y if they have the 19649d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // same type. 19659d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (SExtInst *RI = dyn_cast<SExtInst>(RHS)) { 19669d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (MaxRecurse && SrcTy == RI->getOperand(0)->getType()) 19679d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Compare X and Y. Note that the predicate does not change. 19689d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(Pred, SrcOp, RI->getOperand(0), 1969618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT, MaxRecurse-1)) 19709d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 19719d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 19729d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Turn icmp (sext X), Cst into a compare of X and Cst if Cst is extended 19739d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // too. If not, then try to deduce the result of the comparison. 19749d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands else if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) { 19759d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Compute the constant that would happen if we truncated to SrcTy then 19769d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // reextended to DstTy. 19779d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant *Trunc = ConstantExpr::getTrunc(CI, SrcTy); 19789d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant *RExt = ConstantExpr::getCast(CastInst::SExt, Trunc, DstTy); 19799d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 19809d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // If the re-extended constant didn't change then this is effectively 19819d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // also a case of comparing two sign-extended values. 19829d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (RExt == CI && MaxRecurse) 1983618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyICmpInst(Pred, SrcOp, Trunc, TD, TLI, DT, 19849d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands MaxRecurse-1)) 19859d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 19869d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 19879d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Otherwise the upper bits of LHS are all equal, while RHS has varying 19889d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // bits there. Use this to work out the result of the comparison. 19899d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (RExt != CI) { 19909d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands switch (Pred) { 1991858143816d43e58b17bfd11cb1b57afbd7f0f893Craig Topper default: llvm_unreachable("Unknown ICmp predicate!"); 19929d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_EQ: 19939d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return ConstantInt::getFalse(CI->getContext()); 19949d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_NE: 19959d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return ConstantInt::getTrue(CI->getContext()); 19969d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 19979d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // If RHS is non-negative then LHS <s RHS. If RHS is negative then 19989d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // LHS >s RHS. 19999d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SGT: 20009d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SGE: 20019d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return CI->getValue().isNegative() ? 20029d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getTrue(CI->getContext()) : 20039d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getFalse(CI->getContext()); 20049d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SLT: 20059d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SLE: 20069d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return CI->getValue().isNegative() ? 20079d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getFalse(CI->getContext()) : 20089d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getTrue(CI->getContext()); 20099d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 20109d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // If LHS is non-negative then LHS <u RHS. If LHS is negative then 20119d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // LHS >u RHS. 20129d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_UGT: 20139d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_UGE: 20149d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Comparison is true iff the LHS <s 0. 20159d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (MaxRecurse) 20169d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(ICmpInst::ICMP_SLT, SrcOp, 20179d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant::getNullValue(SrcTy), 2018618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT, MaxRecurse-1)) 20199d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 20209d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands break; 20219d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_ULT: 20229d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_ULE: 20239d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Comparison is true iff the LHS >=s 0. 20249d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (MaxRecurse) 20259d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(ICmpInst::ICMP_SGE, SrcOp, 20269d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant::getNullValue(SrcTy), 2027618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT, MaxRecurse-1)) 20289d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 20299d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands break; 20309d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 20319d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 20329d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 20339d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 20349d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 20359d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 203652fb846578714d14bbde9b28884a6a8729217677Duncan Sands // Special logic for binary operators. 203752fb846578714d14bbde9b28884a6a8729217677Duncan Sands BinaryOperator *LBO = dyn_cast<BinaryOperator>(LHS); 203852fb846578714d14bbde9b28884a6a8729217677Duncan Sands BinaryOperator *RBO = dyn_cast<BinaryOperator>(RHS); 203952fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (MaxRecurse && (LBO || RBO)) { 204052fb846578714d14bbde9b28884a6a8729217677Duncan Sands // Analyze the case when either LHS or RHS is an add instruction. 204152fb846578714d14bbde9b28884a6a8729217677Duncan Sands Value *A = 0, *B = 0, *C = 0, *D = 0; 204252fb846578714d14bbde9b28884a6a8729217677Duncan Sands // LHS = A + B (or A and B are null); RHS = C + D (or C and D are null). 204352fb846578714d14bbde9b28884a6a8729217677Duncan Sands bool NoLHSWrapProblem = false, NoRHSWrapProblem = false; 204452fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (LBO && LBO->getOpcode() == Instruction::Add) { 204552fb846578714d14bbde9b28884a6a8729217677Duncan Sands A = LBO->getOperand(0); B = LBO->getOperand(1); 204652fb846578714d14bbde9b28884a6a8729217677Duncan Sands NoLHSWrapProblem = ICmpInst::isEquality(Pred) || 204752fb846578714d14bbde9b28884a6a8729217677Duncan Sands (CmpInst::isUnsigned(Pred) && LBO->hasNoUnsignedWrap()) || 204852fb846578714d14bbde9b28884a6a8729217677Duncan Sands (CmpInst::isSigned(Pred) && LBO->hasNoSignedWrap()); 204952fb846578714d14bbde9b28884a6a8729217677Duncan Sands } 205052fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (RBO && RBO->getOpcode() == Instruction::Add) { 205152fb846578714d14bbde9b28884a6a8729217677Duncan Sands C = RBO->getOperand(0); D = RBO->getOperand(1); 205252fb846578714d14bbde9b28884a6a8729217677Duncan Sands NoRHSWrapProblem = ICmpInst::isEquality(Pred) || 205352fb846578714d14bbde9b28884a6a8729217677Duncan Sands (CmpInst::isUnsigned(Pred) && RBO->hasNoUnsignedWrap()) || 205452fb846578714d14bbde9b28884a6a8729217677Duncan Sands (CmpInst::isSigned(Pred) && RBO->hasNoSignedWrap()); 205552fb846578714d14bbde9b28884a6a8729217677Duncan Sands } 205652fb846578714d14bbde9b28884a6a8729217677Duncan Sands 205752fb846578714d14bbde9b28884a6a8729217677Duncan Sands // icmp (X+Y), X -> icmp Y, 0 for equalities or if there is no overflow. 205852fb846578714d14bbde9b28884a6a8729217677Duncan Sands if ((A == RHS || B == RHS) && NoLHSWrapProblem) 205952fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (Value *V = SimplifyICmpInst(Pred, A == RHS ? B : A, 206052fb846578714d14bbde9b28884a6a8729217677Duncan Sands Constant::getNullValue(RHS->getType()), 2061618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT, MaxRecurse-1)) 206252fb846578714d14bbde9b28884a6a8729217677Duncan Sands return V; 206352fb846578714d14bbde9b28884a6a8729217677Duncan Sands 206452fb846578714d14bbde9b28884a6a8729217677Duncan Sands // icmp X, (X+Y) -> icmp 0, Y for equalities or if there is no overflow. 206552fb846578714d14bbde9b28884a6a8729217677Duncan Sands if ((C == LHS || D == LHS) && NoRHSWrapProblem) 206652fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (Value *V = SimplifyICmpInst(Pred, 206752fb846578714d14bbde9b28884a6a8729217677Duncan Sands Constant::getNullValue(LHS->getType()), 2068618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier C == LHS ? D : C, TD, TLI, DT, MaxRecurse-1)) 206952fb846578714d14bbde9b28884a6a8729217677Duncan Sands return V; 207052fb846578714d14bbde9b28884a6a8729217677Duncan Sands 207152fb846578714d14bbde9b28884a6a8729217677Duncan Sands // icmp (X+Y), (X+Z) -> icmp Y,Z for equalities or if there is no overflow. 207252fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (A && C && (A == C || A == D || B == C || B == D) && 207352fb846578714d14bbde9b28884a6a8729217677Duncan Sands NoLHSWrapProblem && NoRHSWrapProblem) { 207452fb846578714d14bbde9b28884a6a8729217677Duncan Sands // Determine Y and Z in the form icmp (X+Y), (X+Z). 207552fb846578714d14bbde9b28884a6a8729217677Duncan Sands Value *Y = (A == C || A == D) ? B : A; 207652fb846578714d14bbde9b28884a6a8729217677Duncan Sands Value *Z = (C == A || C == B) ? D : C; 2077618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyICmpInst(Pred, Y, Z, TD, TLI, DT, MaxRecurse-1)) 207852fb846578714d14bbde9b28884a6a8729217677Duncan Sands return V; 207952fb846578714d14bbde9b28884a6a8729217677Duncan Sands } 208052fb846578714d14bbde9b28884a6a8729217677Duncan Sands } 208152fb846578714d14bbde9b28884a6a8729217677Duncan Sands 208284dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky if (LBO && match(LBO, m_URem(m_Value(), m_Specific(RHS)))) { 2083786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky bool KnownNonNegative, KnownNegative; 208488cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky switch (Pred) { 208588cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky default: 208688cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky break; 2087786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky case ICmpInst::ICMP_SGT: 2088786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky case ICmpInst::ICMP_SGE: 2089786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky ComputeSignBit(LHS, KnownNonNegative, KnownNegative, TD); 2090786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky if (!KnownNonNegative) 2091786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky break; 2092786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky // fall-through 209388cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky case ICmpInst::ICMP_EQ: 209488cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky case ICmpInst::ICMP_UGT: 209588cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky case ICmpInst::ICMP_UGE: 2096f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 2097786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky case ICmpInst::ICMP_SLT: 2098786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky case ICmpInst::ICMP_SLE: 2099786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky ComputeSignBit(LHS, KnownNonNegative, KnownNegative, TD); 2100786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky if (!KnownNonNegative) 2101786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky break; 2102786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky // fall-through 210388cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky case ICmpInst::ICMP_NE: 210488cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky case ICmpInst::ICMP_ULT: 210588cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky case ICmpInst::ICMP_ULE: 2106f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 210788cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky } 210888cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky } 210984dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky if (RBO && match(RBO, m_URem(m_Value(), m_Specific(LHS)))) { 211084dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky bool KnownNonNegative, KnownNegative; 211184dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky switch (Pred) { 211284dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky default: 211384dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky break; 211484dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_SGT: 211584dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_SGE: 211684dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky ComputeSignBit(RHS, KnownNonNegative, KnownNegative, TD); 211784dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky if (!KnownNonNegative) 211884dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky break; 211984dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky // fall-through 2120a0e2f38b25ce7c51c22ed40d8a315fe1dd98926dNick Lewycky case ICmpInst::ICMP_NE: 212184dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_UGT: 212284dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_UGE: 2123f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 212484dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_SLT: 212584dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_SLE: 212684dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky ComputeSignBit(RHS, KnownNonNegative, KnownNegative, TD); 212784dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky if (!KnownNonNegative) 212884dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky break; 212984dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky // fall-through 2130a0e2f38b25ce7c51c22ed40d8a315fe1dd98926dNick Lewycky case ICmpInst::ICMP_EQ: 213184dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_ULT: 213284dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_ULE: 2133f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 213484dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky } 213584dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky } 213688cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky 2137c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands // x udiv y <=u x. 2138c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands if (LBO && match(LBO, m_UDiv(m_Specific(RHS), m_Value()))) { 2139c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands // icmp pred (X /u Y), X 2140c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands if (Pred == ICmpInst::ICMP_UGT) 2141c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands return getFalse(ITy); 2142c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands if (Pred == ICmpInst::ICMP_ULE) 2143c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands return getTrue(ITy); 2144c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands } 2145c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands 214658bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (MaxRecurse && LBO && RBO && LBO->getOpcode() == RBO->getOpcode() && 214758bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky LBO->getOperand(1) == RBO->getOperand(1)) { 214858bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky switch (LBO->getOpcode()) { 214958bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky default: break; 215058bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::UDiv: 215158bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::LShr: 215258bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (ICmpInst::isSigned(Pred)) 215358bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 215458bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky // fall-through 215558bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::SDiv: 215658bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::AShr: 2157b6e7cd655c6ee119dbeacc321ee92387f983edb0Eli Friedman if (!LBO->isExact() || !RBO->isExact()) 215858bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 215958bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (Value *V = SimplifyICmpInst(Pred, LBO->getOperand(0), 2160618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier RBO->getOperand(0), TD, TLI, DT, MaxRecurse-1)) 216158bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky return V; 216258bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 216358bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::Shl: { 2164c9d904ee2ca36ab6238ed93c7ad2ea67b5fd0a23Duncan Sands bool NUW = LBO->hasNoUnsignedWrap() && RBO->hasNoUnsignedWrap(); 216558bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky bool NSW = LBO->hasNoSignedWrap() && RBO->hasNoSignedWrap(); 216658bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (!NUW && !NSW) 216758bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 216858bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (!NSW && ICmpInst::isSigned(Pred)) 216958bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 217058bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (Value *V = SimplifyICmpInst(Pred, LBO->getOperand(0), 2171618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier RBO->getOperand(0), TD, TLI, DT, MaxRecurse-1)) 217258bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky return V; 217358bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 217458bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky } 217558bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky } 217658bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky } 217758bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky 2178ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Simplify comparisons involving max/min. 2179ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands Value *A, *B; 2180ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands CmpInst::Predicate P = CmpInst::BAD_ICMP_PREDICATE; 2181ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands CmpInst::Predicate EqP; // Chosen so that "A == max/min(A,B)" iff "A EqP B". 2182ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands 21838140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Signed variants on "max(a,b)>=a -> true". 2184ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (match(LHS, m_SMax(m_Value(A), m_Value(B))) && (A == RHS || B == RHS)) { 2185ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != RHS) std::swap(A, B); // smax(A, B) pred A. 2186ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands EqP = CmpInst::ICMP_SGE; // "A == smax(A, B)" iff "A sge B". 2187ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as smax(A, B) pred A. 2188ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = Pred; 2189ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } else if (match(RHS, m_SMax(m_Value(A), m_Value(B))) && 2190ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands (A == LHS || B == LHS)) { 2191ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != LHS) std::swap(A, B); // A pred smax(A, B). 2192ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands EqP = CmpInst::ICMP_SGE; // "A == smax(A, B)" iff "A sge B". 2193ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as smax(A, B) swapped-pred A. 2194ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = CmpInst::getSwappedPredicate(Pred); 2195ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } else if (match(LHS, m_SMin(m_Value(A), m_Value(B))) && 2196ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands (A == RHS || B == RHS)) { 2197ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != RHS) std::swap(A, B); // smin(A, B) pred A. 2198ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands EqP = CmpInst::ICMP_SLE; // "A == smin(A, B)" iff "A sle B". 2199ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as smax(-A, -B) swapped-pred -A. 2200ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Note that we do not need to actually form -A or -B thanks to EqP. 2201ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = CmpInst::getSwappedPredicate(Pred); 2202ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } else if (match(RHS, m_SMin(m_Value(A), m_Value(B))) && 2203ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands (A == LHS || B == LHS)) { 2204ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != LHS) std::swap(A, B); // A pred smin(A, B). 2205ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands EqP = CmpInst::ICMP_SLE; // "A == smin(A, B)" iff "A sle B". 2206ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as smax(-A, -B) pred -A. 2207ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Note that we do not need to actually form -A or -B thanks to EqP. 2208ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = Pred; 2209ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } 2210ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (P != CmpInst::BAD_ICMP_PREDICATE) { 2211ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Cases correspond to "max(A, B) p A". 2212ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands switch (P) { 2213ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands default: 2214ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands break; 2215ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_EQ: 2216ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_SLE: 2217e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Equivalent to "A EqP B". This may be the same as the condition tested 2218e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // in the max/min; if so, we can just return that. 2219e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(LHS, EqP, A, B)) 2220e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2221e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(RHS, EqP, A, B)) 2222e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2223e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Otherwise, see if "A EqP B" simplifies. 2224ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (MaxRecurse) 2225618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyICmpInst(EqP, A, B, TD, TLI, DT, MaxRecurse-1)) 2226ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands return V; 2227ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands break; 2228ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_NE: 2229e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands case CmpInst::ICMP_SGT: { 2230e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands CmpInst::Predicate InvEqP = CmpInst::getInversePredicate(EqP); 2231e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Equivalent to "A InvEqP B". This may be the same as the condition 2232e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // tested in the max/min; if so, we can just return that. 2233e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(LHS, InvEqP, A, B)) 2234e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2235e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(RHS, InvEqP, A, B)) 2236e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2237e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Otherwise, see if "A InvEqP B" simplifies. 2238ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (MaxRecurse) 2239618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyICmpInst(InvEqP, A, B, TD, TLI, DT, MaxRecurse-1)) 2240ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands return V; 2241ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands break; 2242e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands } 2243ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_SGE: 2244ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Always true. 2245f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 2246ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_SLT: 2247ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Always false. 2248f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 2249ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } 2250ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } 2251ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands 22528140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Unsigned variants on "max(a,b)>=a -> true". 2253ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = CmpInst::BAD_ICMP_PREDICATE; 2254ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (match(LHS, m_UMax(m_Value(A), m_Value(B))) && (A == RHS || B == RHS)) { 2255ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != RHS) std::swap(A, B); // umax(A, B) pred A. 2256ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands EqP = CmpInst::ICMP_UGE; // "A == umax(A, B)" iff "A uge B". 2257ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as umax(A, B) pred A. 2258ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = Pred; 2259ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } else if (match(RHS, m_UMax(m_Value(A), m_Value(B))) && 2260ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands (A == LHS || B == LHS)) { 2261ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != LHS) std::swap(A, B); // A pred umax(A, B). 2262ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands EqP = CmpInst::ICMP_UGE; // "A == umax(A, B)" iff "A uge B". 2263ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as umax(A, B) swapped-pred A. 2264ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = CmpInst::getSwappedPredicate(Pred); 2265ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } else if (match(LHS, m_UMin(m_Value(A), m_Value(B))) && 2266ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands (A == RHS || B == RHS)) { 2267ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != RHS) std::swap(A, B); // umin(A, B) pred A. 2268ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands EqP = CmpInst::ICMP_ULE; // "A == umin(A, B)" iff "A ule B". 2269ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as umax(-A, -B) swapped-pred -A. 2270ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Note that we do not need to actually form -A or -B thanks to EqP. 2271ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = CmpInst::getSwappedPredicate(Pred); 2272ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } else if (match(RHS, m_UMin(m_Value(A), m_Value(B))) && 2273ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands (A == LHS || B == LHS)) { 2274ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != LHS) std::swap(A, B); // A pred umin(A, B). 2275ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands EqP = CmpInst::ICMP_ULE; // "A == umin(A, B)" iff "A ule B". 2276ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as umax(-A, -B) pred -A. 2277ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Note that we do not need to actually form -A or -B thanks to EqP. 2278ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = Pred; 2279ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } 2280ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (P != CmpInst::BAD_ICMP_PREDICATE) { 2281ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Cases correspond to "max(A, B) p A". 2282ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands switch (P) { 2283ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands default: 2284ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands break; 2285ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_EQ: 2286ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_ULE: 2287e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Equivalent to "A EqP B". This may be the same as the condition tested 2288e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // in the max/min; if so, we can just return that. 2289e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(LHS, EqP, A, B)) 2290e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2291e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(RHS, EqP, A, B)) 2292e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2293e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Otherwise, see if "A EqP B" simplifies. 2294ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (MaxRecurse) 2295618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyICmpInst(EqP, A, B, TD, TLI, DT, MaxRecurse-1)) 2296ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands return V; 2297ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands break; 2298ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_NE: 2299e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands case CmpInst::ICMP_UGT: { 2300e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands CmpInst::Predicate InvEqP = CmpInst::getInversePredicate(EqP); 2301e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Equivalent to "A InvEqP B". This may be the same as the condition 2302e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // tested in the max/min; if so, we can just return that. 2303e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(LHS, InvEqP, A, B)) 2304e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2305e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(RHS, InvEqP, A, B)) 2306e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2307e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Otherwise, see if "A InvEqP B" simplifies. 2308ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (MaxRecurse) 2309618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyICmpInst(InvEqP, A, B, TD, TLI, DT, MaxRecurse-1)) 2310ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands return V; 2311ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands break; 2312e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands } 2313ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_UGE: 2314ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Always true. 2315f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 2316ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_ULT: 2317ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Always false. 2318f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 2319ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } 2320ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } 2321ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands 23228140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Variants on "max(x,y) >= min(x,z)". 23238140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands Value *C, *D; 23248140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (match(LHS, m_SMax(m_Value(A), m_Value(B))) && 23258140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands match(RHS, m_SMin(m_Value(C), m_Value(D))) && 23268140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands (A == C || A == D || B == C || B == D)) { 23278140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // max(x, ?) pred min(x, ?). 23288140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_SGE) 23298140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always true. 2330f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 23318140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_SLT) 23328140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always false. 2333f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 23348140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands } else if (match(LHS, m_SMin(m_Value(A), m_Value(B))) && 23358140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands match(RHS, m_SMax(m_Value(C), m_Value(D))) && 23368140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands (A == C || A == D || B == C || B == D)) { 23378140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // min(x, ?) pred max(x, ?). 23388140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_SLE) 23398140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always true. 2340f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 23418140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_SGT) 23428140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always false. 2343f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 23448140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands } else if (match(LHS, m_UMax(m_Value(A), m_Value(B))) && 23458140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands match(RHS, m_UMin(m_Value(C), m_Value(D))) && 23468140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands (A == C || A == D || B == C || B == D)) { 23478140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // max(x, ?) pred min(x, ?). 23488140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_UGE) 23498140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always true. 2350f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 23518140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_ULT) 23528140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always false. 2353f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 23548140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands } else if (match(LHS, m_UMin(m_Value(A), m_Value(B))) && 23558140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands match(RHS, m_UMax(m_Value(C), m_Value(D))) && 23568140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands (A == C || A == D || B == C || B == D)) { 23578140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // min(x, ?) pred max(x, ?). 23588140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_ULE) 23598140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always true. 2360f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 23618140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_UGT) 23628140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always false. 2363f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 23648140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands } 23658140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands 2366f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky // Simplify comparisons of GEPs. 2367f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky if (GetElementPtrInst *GLHS = dyn_cast<GetElementPtrInst>(LHS)) { 2368f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky if (GEPOperator *GRHS = dyn_cast<GEPOperator>(RHS)) { 2369f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky if (GLHS->getPointerOperand() == GRHS->getPointerOperand() && 2370f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky GLHS->hasAllConstantIndices() && GRHS->hasAllConstantIndices() && 2371f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky (ICmpInst::isEquality(Pred) || 2372f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky (GLHS->isInBounds() && GRHS->isInBounds() && 2373f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky Pred == ICmpInst::getSignedPredicate(Pred)))) { 2374f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky // The bases are equal and the indices are constant. Build a constant 2375f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky // expression GEP with the same indices and a null base pointer to see 2376f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky // what constant folding can make out of it. 2377f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky Constant *Null = Constant::getNullValue(GLHS->getPointerOperandType()); 2378f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky SmallVector<Value *, 4> IndicesLHS(GLHS->idx_begin(), GLHS->idx_end()); 2379f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky Constant *NewLHS = ConstantExpr::getGetElementPtr(Null, IndicesLHS); 2380f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky 2381f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky SmallVector<Value *, 4> IndicesRHS(GRHS->idx_begin(), GRHS->idx_end()); 2382f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky Constant *NewRHS = ConstantExpr::getGetElementPtr(Null, IndicesRHS); 2383f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky return ConstantExpr::getICmp(Pred, NewLHS, NewRHS); 2384f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky } 2385f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky } 2386f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky } 2387f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky 23881ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands // If the comparison is with the result of a select instruction, check whether 23891ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands // comparing with either branch of the select always yields the same value. 23900312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<SelectInst>(LHS) || isa<SelectInst>(RHS)) 2391618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = ThreadCmpOverSelect(Pred, LHS, RHS, TD, TLI, DT, MaxRecurse)) 2392a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return V; 2393a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 2394a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the comparison is with the result of a phi instruction, check whether 2395a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // doing the compare with each incoming phi value yields a common result. 23960312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<PHINode>(LHS) || isa<PHINode>(RHS)) 2397618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = ThreadCmpOverPHI(Pred, LHS, RHS, TD, TLI, DT, MaxRecurse)) 23983bbb0cc42b67b4bf2c488285666999963bab0f7eDuncan Sands return V; 23991ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands 24009dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner return 0; 24019dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner} 24029dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 2403a74a58c83be492b7d5b7383656f049909394cff4Duncan SandsValue *llvm::SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS, 2404618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, 2405618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 2406618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT) { 2407618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ::SimplifyICmpInst(Predicate, LHS, RHS, TD, TLI, DT, RecursionLimit); 2408a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 2409a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 24109dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// SimplifyFCmpInst - Given operands for an FCmpInst, see if we can 24119dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// fold the result. If not, this returns null. 2412a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *SimplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS, 2413618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, 2414618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 2415618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT, 24161845009290e4d804ad377927bd8a08cca3036adcDuncan Sands unsigned MaxRecurse) { 24179dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner CmpInst::Predicate Pred = (CmpInst::Predicate)Predicate; 24189dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner assert(CmpInst::isFPPredicate(Pred) && "Not an FP compare!"); 24199dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 2420d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(LHS)) { 24219dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner if (Constant *CRHS = dyn_cast<Constant>(RHS)) 2422618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ConstantFoldCompareInstOperands(Pred, CLHS, CRHS, TD, TLI); 242312a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2424d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // If we have a constant, make sure it is on the RHS. 2425d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner std::swap(LHS, RHS); 2426d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Pred = CmpInst::getSwappedPredicate(Pred); 2427d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 242812a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2429210c5d4880b525e064088b6fec713260128c16ebChris Lattner // Fold trivial predicates. 2430210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (Pred == FCmpInst::FCMP_FALSE) 2431210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(GetCompareTy(LHS), 0); 2432210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (Pred == FCmpInst::FCMP_TRUE) 2433210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(GetCompareTy(LHS), 1); 2434210c5d4880b525e064088b6fec713260128c16ebChris Lattner 2435210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (isa<UndefValue>(RHS)) // fcmp pred X, undef -> undef 2436210c5d4880b525e064088b6fec713260128c16ebChris Lattner return UndefValue::get(GetCompareTy(LHS)); 2437210c5d4880b525e064088b6fec713260128c16ebChris Lattner 2438210c5d4880b525e064088b6fec713260128c16ebChris Lattner // fcmp x,x -> true/false. Not all compares are foldable. 2439124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (LHS == RHS) { 2440210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (CmpInst::isTrueWhenEqual(Pred)) 2441210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(GetCompareTy(LHS), 1); 2442210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (CmpInst::isFalseWhenEqual(Pred)) 2443210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(GetCompareTy(LHS), 0); 2444210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 244512a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2446210c5d4880b525e064088b6fec713260128c16ebChris Lattner // Handle fcmp with constant RHS 2447210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (Constant *RHSC = dyn_cast<Constant>(RHS)) { 2448210c5d4880b525e064088b6fec713260128c16ebChris Lattner // If the constant is a nan, see if we can fold the comparison based on it. 2449210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (ConstantFP *CFP = dyn_cast<ConstantFP>(RHSC)) { 2450210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (CFP->getValueAPF().isNaN()) { 2451210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (FCmpInst::isOrdered(Pred)) // True "if ordered and foo" 2452210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::getFalse(CFP->getContext()); 2453210c5d4880b525e064088b6fec713260128c16ebChris Lattner assert(FCmpInst::isUnordered(Pred) && 2454210c5d4880b525e064088b6fec713260128c16ebChris Lattner "Comparison must be either ordered or unordered!"); 2455210c5d4880b525e064088b6fec713260128c16ebChris Lattner // True if unordered. 2456210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::getTrue(CFP->getContext()); 2457210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 24586b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // Check whether the constant is an infinity. 24596b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman if (CFP->getValueAPF().isInfinity()) { 24606b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman if (CFP->getValueAPF().isNegative()) { 24616b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman switch (Pred) { 24626b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman case FCmpInst::FCMP_OLT: 24636b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // No value is ordered and less than negative infinity. 24646b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman return ConstantInt::getFalse(CFP->getContext()); 24656b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman case FCmpInst::FCMP_UGE: 24666b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // All values are unordered with or at least negative infinity. 24676b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman return ConstantInt::getTrue(CFP->getContext()); 24686b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman default: 24696b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman break; 24706b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } 24716b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } else { 24726b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman switch (Pred) { 24736b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman case FCmpInst::FCMP_OGT: 24746b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // No value is ordered and greater than infinity. 24756b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman return ConstantInt::getFalse(CFP->getContext()); 24766b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman case FCmpInst::FCMP_ULE: 24776b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // All values are unordered with and at most infinity. 24786b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman return ConstantInt::getTrue(CFP->getContext()); 24796b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman default: 24806b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman break; 24816b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } 24826b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } 24836b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } 2484210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 2485210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 248612a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 248792826def593df7a422c7b07f09342febce81ddd3Duncan Sands // If the comparison is with the result of a select instruction, check whether 248892826def593df7a422c7b07f09342febce81ddd3Duncan Sands // comparing with either branch of the select always yields the same value. 24890312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<SelectInst>(LHS) || isa<SelectInst>(RHS)) 2490618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = ThreadCmpOverSelect(Pred, LHS, RHS, TD, TLI, DT, MaxRecurse)) 2491a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return V; 2492a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 2493a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the comparison is with the result of a phi instruction, check whether 2494a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // doing the compare with each incoming phi value yields a common result. 24950312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<PHINode>(LHS) || isa<PHINode>(RHS)) 2496618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = ThreadCmpOverPHI(Pred, LHS, RHS, TD, TLI, DT, MaxRecurse)) 24973bbb0cc42b67b4bf2c488285666999963bab0f7eDuncan Sands return V; 249892826def593df7a422c7b07f09342febce81ddd3Duncan Sands 24999f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner return 0; 25009f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner} 25019f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 2502a74a58c83be492b7d5b7383656f049909394cff4Duncan SandsValue *llvm::SimplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS, 2503618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, 2504618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 2505618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT) { 2506618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ::SimplifyFCmpInst(Predicate, LHS, RHS, TD, TLI, DT, RecursionLimit); 2507a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 2508a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 2509047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner/// SimplifySelectInst - Given operands for a SelectInst, see if we can fold 2510047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner/// the result. If not, this returns null. 2511124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan SandsValue *llvm::SimplifySelectInst(Value *CondVal, Value *TrueVal, Value *FalseVal, 2512124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands const TargetData *TD, const DominatorTree *) { 2513047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner // select true, X, Y -> X 2514047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner // select false, X, Y -> Y 2515047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner if (ConstantInt *CB = dyn_cast<ConstantInt>(CondVal)) 2516047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return CB->getZExtValue() ? TrueVal : FalseVal; 251712a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2518047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner // select C, X, X -> X 2519124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (TrueVal == FalseVal) 2520047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return TrueVal; 252112a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2522047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner if (isa<UndefValue>(CondVal)) { // select undef, X, Y -> X or Y 2523047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner if (isa<Constant>(TrueVal)) 2524047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return TrueVal; 2525047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return FalseVal; 2526047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner } 252768c0dbc14fb7599987fb3e27be4e12c1ac36535eDan Gohman if (isa<UndefValue>(TrueVal)) // select C, undef, X -> X 252868c0dbc14fb7599987fb3e27be4e12c1ac36535eDan Gohman return FalseVal; 252968c0dbc14fb7599987fb3e27be4e12c1ac36535eDan Gohman if (isa<UndefValue>(FalseVal)) // select C, X, undef -> X 253068c0dbc14fb7599987fb3e27be4e12c1ac36535eDan Gohman return TrueVal; 253112a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2532047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return 0; 2533047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner} 2534047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner 2535c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner/// SimplifyGEPInst - Given operands for an GetElementPtrInst, see if we can 2536c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner/// fold the result. If not, this returns null. 2537618c1dbd293d15ee19f61b1156ab8086ad28311aChad RosierValue *llvm::SimplifyGEPInst(ArrayRef<Value *> Ops, const TargetData *TD, 2538618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *) { 253985bbff6c94695f07cc1a9765b4d384ed18d2fd7cDuncan Sands // The type of the GEP pointer operand. 25401608769abeb1430dc34f31ffac0d9850f99ae36aNadav Rotem PointerType *PtrTy = dyn_cast<PointerType>(Ops[0]->getType()); 25411608769abeb1430dc34f31ffac0d9850f99ae36aNadav Rotem // The GEP pointer operand is not a pointer, it's a vector of pointers. 25421608769abeb1430dc34f31ffac0d9850f99ae36aNadav Rotem if (!PtrTy) 25431608769abeb1430dc34f31ffac0d9850f99ae36aNadav Rotem return 0; 254485bbff6c94695f07cc1a9765b4d384ed18d2fd7cDuncan Sands 2545c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner // getelementptr P -> P. 2546b9b54ebfed02f0654897d37e8a4448d3f8087558Jay Foad if (Ops.size() == 1) 2547c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner return Ops[0]; 2548c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner 254985bbff6c94695f07cc1a9765b4d384ed18d2fd7cDuncan Sands if (isa<UndefValue>(Ops[0])) { 255085bbff6c94695f07cc1a9765b4d384ed18d2fd7cDuncan Sands // Compute the (pointer) type returned by the GEP instruction. 2551a9203109f4ac95aa7e9624f2838e3d89623ec902Jay Foad Type *LastType = GetElementPtrInst::getIndexedType(PtrTy, Ops.slice(1)); 2552db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *GEPTy = PointerType::get(LastType, PtrTy->getAddressSpace()); 255385bbff6c94695f07cc1a9765b4d384ed18d2fd7cDuncan Sands return UndefValue::get(GEPTy); 255485bbff6c94695f07cc1a9765b4d384ed18d2fd7cDuncan Sands } 2555c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner 2556b9b54ebfed02f0654897d37e8a4448d3f8087558Jay Foad if (Ops.size() == 2) { 2557e60d79faf7ef7bc4847f9e5d067af00b98dced7bDuncan Sands // getelementptr P, 0 -> P. 2558c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner if (ConstantInt *C = dyn_cast<ConstantInt>(Ops[1])) 2559c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner if (C->isZero()) 2560c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner return Ops[0]; 2561e60d79faf7ef7bc4847f9e5d067af00b98dced7bDuncan Sands // getelementptr P, N -> P if P points to a type of zero size. 2562e60d79faf7ef7bc4847f9e5d067af00b98dced7bDuncan Sands if (TD) { 2563db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty = PtrTy->getElementType(); 2564a63395a30f9227bde826749d3480046301b47332Duncan Sands if (Ty->isSized() && TD->getTypeAllocSize(Ty) == 0) 2565e60d79faf7ef7bc4847f9e5d067af00b98dced7bDuncan Sands return Ops[0]; 2566e60d79faf7ef7bc4847f9e5d067af00b98dced7bDuncan Sands } 2567e60d79faf7ef7bc4847f9e5d067af00b98dced7bDuncan Sands } 256812a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2569c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner // Check to see if this is constant foldable. 2570b9b54ebfed02f0654897d37e8a4448d3f8087558Jay Foad for (unsigned i = 0, e = Ops.size(); i != e; ++i) 2571c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner if (!isa<Constant>(Ops[i])) 2572c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner return 0; 257312a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2574dab3d29605a5c83db41b28176273ef55961120c1Jay Foad return ConstantExpr::getGetElementPtr(cast<Constant>(Ops[0]), Ops.slice(1)); 2575c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner} 2576c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner 2577dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands/// SimplifyInsertValueInst - Given operands for an InsertValueInst, see if we 2578dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands/// can fold the result. If not, this returns null. 2579dabc2806726a286b00313419fac8461ebe0f774cDuncan SandsValue *llvm::SimplifyInsertValueInst(Value *Agg, Value *Val, 2580dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands ArrayRef<unsigned> Idxs, 2581dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands const TargetData *, 2582dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands const DominatorTree *) { 2583dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands if (Constant *CAgg = dyn_cast<Constant>(Agg)) 2584dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands if (Constant *CVal = dyn_cast<Constant>(Val)) 2585dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands return ConstantFoldInsertValueInstruction(CAgg, CVal, Idxs); 2586dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands 2587dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands // insertvalue x, undef, n -> x 2588dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands if (match(Val, m_Undef())) 2589dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands return Agg; 2590dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands 2591dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands // insertvalue x, (extractvalue y, n), n 2592dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands if (ExtractValueInst *EV = dyn_cast<ExtractValueInst>(Val)) 2593ae707bd5594e52a8b385760f99ff58aa8fede948Benjamin Kramer if (EV->getAggregateOperand()->getType() == Agg->getType() && 2594ae707bd5594e52a8b385760f99ff58aa8fede948Benjamin Kramer EV->getIndices() == Idxs) { 2595dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands // insertvalue undef, (extractvalue y, n), n -> y 2596dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands if (match(Agg, m_Undef())) 2597dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands return EV->getAggregateOperand(); 2598dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands 2599dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands // insertvalue y, (extractvalue y, n), n -> y 2600dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands if (Agg == EV->getAggregateOperand()) 2601dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands return Agg; 2602dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands } 2603dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands 2604dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands return 0; 2605dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands} 2606dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands 2607ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands/// SimplifyPHINode - See if we can fold the given phi. If not, returns null. 2608ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sandsstatic Value *SimplifyPHINode(PHINode *PN, const DominatorTree *DT) { 2609ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // If all of the PHI's incoming values are the same then replace the PHI node 2610ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // with the common value. 2611ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands Value *CommonValue = 0; 2612ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands bool HasUndefInput = false; 2613ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) { 2614ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands Value *Incoming = PN->getIncomingValue(i); 2615ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // If the incoming value is the phi node itself, it can safely be skipped. 2616ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands if (Incoming == PN) continue; 2617ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands if (isa<UndefValue>(Incoming)) { 2618ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // Remember that we saw an undef value, but otherwise ignore them. 2619ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands HasUndefInput = true; 2620ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands continue; 2621ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands } 2622ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands if (CommonValue && Incoming != CommonValue) 2623ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands return 0; // Not the same, bail out. 2624ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands CommonValue = Incoming; 2625ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands } 2626ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands 2627ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // If CommonValue is null then all of the incoming values were either undef or 2628ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // equal to the phi node itself. 2629ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands if (!CommonValue) 2630ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands return UndefValue::get(PN->getType()); 2631ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands 2632ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // If we have a PHI node like phi(X, undef, X), where X is defined by some 2633ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // instruction, we cannot return X as the result of the PHI node unless it 2634ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // dominates the PHI block. 2635ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands if (HasUndefInput) 2636ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands return ValueDominatesPHI(CommonValue, PN, DT) ? CommonValue : 0; 2637ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands 2638ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands return CommonValue; 2639ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands} 2640ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands 2641d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner//=== Helper functions for higher up the class hierarchy. 26429dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 2643d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner/// SimplifyBinOp - Given operands for a BinaryOperator, see if we can 2644d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner/// fold the result. If not, this returns null. 2645a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *SimplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS, 2646618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, 2647618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 2648618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT, 26491845009290e4d804ad377927bd8a08cca3036adcDuncan Sands unsigned MaxRecurse) { 2650d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner switch (Opcode) { 265181a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner case Instruction::Add: 2652ffeb98ad3becfbb8e26270ef8751e37e4b6b0cd1Duncan Sands return SimplifyAddInst(LHS, RHS, /*isNSW*/false, /*isNUW*/false, 2653618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT, MaxRecurse); 265481a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner case Instruction::Sub: 2655ffeb98ad3becfbb8e26270ef8751e37e4b6b0cd1Duncan Sands return SimplifySubInst(LHS, RHS, /*isNSW*/false, /*isNUW*/false, 2656618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT, MaxRecurse); 2657618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier case Instruction::Mul: return SimplifyMulInst (LHS, RHS, TD, TLI, DT, 2658618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier MaxRecurse); 2659618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier case Instruction::SDiv: return SimplifySDivInst(LHS, RHS, TD, TLI, DT, 2660618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier MaxRecurse); 2661618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier case Instruction::UDiv: return SimplifyUDivInst(LHS, RHS, TD, TLI, DT, 2662618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier MaxRecurse); 2663618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier case Instruction::FDiv: return SimplifyFDivInst(LHS, RHS, TD, TLI, DT, 2664618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier MaxRecurse); 2665618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier case Instruction::SRem: return SimplifySRemInst(LHS, RHS, TD, TLI, DT, 2666618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier MaxRecurse); 2667618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier case Instruction::URem: return SimplifyURemInst(LHS, RHS, TD, TLI, DT, 2668618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier MaxRecurse); 2669618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier case Instruction::FRem: return SimplifyFRemInst(LHS, RHS, TD, TLI, DT, 2670618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier MaxRecurse); 267181a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner case Instruction::Shl: 2672ffeb98ad3becfbb8e26270ef8751e37e4b6b0cd1Duncan Sands return SimplifyShlInst(LHS, RHS, /*isNSW*/false, /*isNUW*/false, 2673618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT, MaxRecurse); 267481a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner case Instruction::LShr: 2675618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return SimplifyLShrInst(LHS, RHS, /*isExact*/false, TD, TLI, DT, 2676618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier MaxRecurse); 267781a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner case Instruction::AShr: 2678618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return SimplifyAShrInst(LHS, RHS, /*isExact*/false, TD, TLI, DT, 2679618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier MaxRecurse); 2680618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier case Instruction::And: return SimplifyAndInst(LHS, RHS, TD, TLI, DT, 2681618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier MaxRecurse); 2682618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier case Instruction::Or: return SimplifyOrInst (LHS, RHS, TD, TLI, DT, 2683618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier MaxRecurse); 2684618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier case Instruction::Xor: return SimplifyXorInst(LHS, RHS, TD, TLI, DT, 2685618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier MaxRecurse); 2686d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner default: 2687d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(LHS)) 2688d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CRHS = dyn_cast<Constant>(RHS)) { 2689d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Constant *COps[] = {CLHS, CRHS}; 2690618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ConstantFoldInstOperands(Opcode, LHS->getType(), COps, TD, TLI); 2691d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 2692b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 2693566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // If the operation is associative, try some generic simplifications. 2694566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Instruction::isAssociative(Opcode)) 2695618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyAssociativeBinOp(Opcode, LHS, RHS, TD, TLI, DT, 2696566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands MaxRecurse)) 2697566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return V; 2698566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 2699b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // If the operation is with the result of a select instruction, check whether 2700b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // operating on either branch of the select always yields the same value. 27010312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<SelectInst>(LHS) || isa<SelectInst>(RHS)) 2702618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = ThreadBinOpOverSelect(Opcode, LHS, RHS, TD, TLI, DT, 27030312a93693abc2eb682b2b101c889959888fd883Duncan Sands MaxRecurse)) 2704a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return V; 2705a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 2706a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the operation is with the result of a phi instruction, check whether 2707a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // operating on all incoming values of the phi always yields the same value. 27080312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<PHINode>(LHS) || isa<PHINode>(RHS)) 2709618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = ThreadBinOpOverPHI(Opcode, LHS, RHS, TD, TLI, DT, 2710618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier MaxRecurse)) 2711b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return V; 2712b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 2713d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return 0; 2714d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 2715d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner} 27169dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 271712a86f5b3199e72e6d967781acc76340f5920e46Duncan SandsValue *llvm::SimplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS, 2718618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, const TargetLibraryInfo *TLI, 2719618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT) { 2720618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ::SimplifyBinOp(Opcode, LHS, RHS, TD, TLI, DT, RecursionLimit); 2721a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 2722a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 27239dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// SimplifyCmpInst - Given operands for a CmpInst, see if we can 27249dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// fold the result. 2725a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *SimplifyCmpInst(unsigned Predicate, Value *LHS, Value *RHS, 2726618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, 2727618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 2728618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT, 27291845009290e4d804ad377927bd8a08cca3036adcDuncan Sands unsigned MaxRecurse) { 27309dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner if (CmpInst::isIntPredicate((CmpInst::Predicate)Predicate)) 2731618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return SimplifyICmpInst(Predicate, LHS, RHS, TD, TLI, DT, MaxRecurse); 2732618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return SimplifyFCmpInst(Predicate, LHS, RHS, TD, TLI, DT, MaxRecurse); 27339dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner} 27349dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 2735a74a58c83be492b7d5b7383656f049909394cff4Duncan SandsValue *llvm::SimplifyCmpInst(unsigned Predicate, Value *LHS, Value *RHS, 2736618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, const TargetLibraryInfo *TLI, 2737618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT) { 2738618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ::SimplifyCmpInst(Predicate, LHS, RHS, TD, TLI, DT, RecursionLimit); 2739a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 2740e34537856a544c83513e390ac9552a8bc3823346Chris Lattner 274171d050315704c23b235594d3fad5268c12d825e3Dan Gohmanstatic Value *SimplifyCallInst(CallInst *CI) { 274271d050315704c23b235594d3fad5268c12d825e3Dan Gohman // call undef -> undef 274371d050315704c23b235594d3fad5268c12d825e3Dan Gohman if (isa<UndefValue>(CI->getCalledValue())) 274471d050315704c23b235594d3fad5268c12d825e3Dan Gohman return UndefValue::get(CI->getType()); 274571d050315704c23b235594d3fad5268c12d825e3Dan Gohman 274671d050315704c23b235594d3fad5268c12d825e3Dan Gohman return 0; 274771d050315704c23b235594d3fad5268c12d825e3Dan Gohman} 274871d050315704c23b235594d3fad5268c12d825e3Dan Gohman 2749e34537856a544c83513e390ac9552a8bc3823346Chris Lattner/// SimplifyInstruction - See if we can compute a simplified version of this 2750e34537856a544c83513e390ac9552a8bc3823346Chris Lattner/// instruction. If not, this returns null. 2751eff0581583ef10e2872e9baf537a04b67d992101Duncan SandsValue *llvm::SimplifyInstruction(Instruction *I, const TargetData *TD, 2752618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 2753eff0581583ef10e2872e9baf537a04b67d992101Duncan Sands const DominatorTree *DT) { 2754d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands Value *Result; 2755d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands 2756e34537856a544c83513e390ac9552a8bc3823346Chris Lattner switch (I->getOpcode()) { 2757e34537856a544c83513e390ac9552a8bc3823346Chris Lattner default: 2758618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Result = ConstantFoldInstruction(I, TD, TLI); 2759d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 27608aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner case Instruction::Add: 2761d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands Result = SimplifyAddInst(I->getOperand(0), I->getOperand(1), 2762d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands cast<BinaryOperator>(I)->hasNoSignedWrap(), 2763d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands cast<BinaryOperator>(I)->hasNoUnsignedWrap(), 2764618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT); 2765d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 2766fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands case Instruction::Sub: 2767fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands Result = SimplifySubInst(I->getOperand(0), I->getOperand(1), 2768fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands cast<BinaryOperator>(I)->hasNoSignedWrap(), 2769fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands cast<BinaryOperator>(I)->hasNoUnsignedWrap(), 2770618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT); 2771fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands break; 277282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands case Instruction::Mul: 2773618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Result = SimplifyMulInst(I->getOperand(0), I->getOperand(1), TD, TLI, DT); 277482fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands break; 2775593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands case Instruction::SDiv: 2776618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Result = SimplifySDivInst(I->getOperand(0), I->getOperand(1), TD, TLI, DT); 2777593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands break; 2778593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands case Instruction::UDiv: 2779618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Result = SimplifyUDivInst(I->getOperand(0), I->getOperand(1), TD, TLI, DT); 2780593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands break; 27811fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel case Instruction::FDiv: 2782618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Result = SimplifyFDivInst(I->getOperand(0), I->getOperand(1), TD, TLI, DT); 27831fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel break; 2784f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands case Instruction::SRem: 2785618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Result = SimplifySRemInst(I->getOperand(0), I->getOperand(1), TD, TLI, DT); 2786f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands break; 2787f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands case Instruction::URem: 2788618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Result = SimplifyURemInst(I->getOperand(0), I->getOperand(1), TD, TLI, DT); 2789f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands break; 2790f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands case Instruction::FRem: 2791618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Result = SimplifyFRemInst(I->getOperand(0), I->getOperand(1), TD, TLI, DT); 2792f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands break; 2793c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands case Instruction::Shl: 279481a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Result = SimplifyShlInst(I->getOperand(0), I->getOperand(1), 279581a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner cast<BinaryOperator>(I)->hasNoSignedWrap(), 279681a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner cast<BinaryOperator>(I)->hasNoUnsignedWrap(), 2797618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT); 2798c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands break; 2799c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands case Instruction::LShr: 280081a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Result = SimplifyLShrInst(I->getOperand(0), I->getOperand(1), 280181a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner cast<BinaryOperator>(I)->isExact(), 2802618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT); 2803c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands break; 2804c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands case Instruction::AShr: 280581a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Result = SimplifyAShrInst(I->getOperand(0), I->getOperand(1), 280681a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner cast<BinaryOperator>(I)->isExact(), 2807618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT); 2808c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands break; 2809e34537856a544c83513e390ac9552a8bc3823346Chris Lattner case Instruction::And: 2810618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Result = SimplifyAndInst(I->getOperand(0), I->getOperand(1), TD, TLI, DT); 2811d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 2812e34537856a544c83513e390ac9552a8bc3823346Chris Lattner case Instruction::Or: 2813618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Result = SimplifyOrInst(I->getOperand(0), I->getOperand(1), TD, TLI, DT); 2814d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 28152b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands case Instruction::Xor: 2816618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Result = SimplifyXorInst(I->getOperand(0), I->getOperand(1), TD, TLI, DT); 28172b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands break; 2818e34537856a544c83513e390ac9552a8bc3823346Chris Lattner case Instruction::ICmp: 2819d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands Result = SimplifyICmpInst(cast<ICmpInst>(I)->getPredicate(), 2820618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier I->getOperand(0), I->getOperand(1), TD, TLI, DT); 2821d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 2822e34537856a544c83513e390ac9552a8bc3823346Chris Lattner case Instruction::FCmp: 2823d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands Result = SimplifyFCmpInst(cast<FCmpInst>(I)->getPredicate(), 2824618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier I->getOperand(0), I->getOperand(1), TD, TLI, DT); 2825d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 2826047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner case Instruction::Select: 2827d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands Result = SimplifySelectInst(I->getOperand(0), I->getOperand(1), 2828d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands I->getOperand(2), TD, DT); 2829d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 2830c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner case Instruction::GetElementPtr: { 2831c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner SmallVector<Value*, 8> Ops(I->op_begin(), I->op_end()); 2832b9b54ebfed02f0654897d37e8a4448d3f8087558Jay Foad Result = SimplifyGEPInst(Ops, TD, DT); 2833d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 2834c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner } 2835dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands case Instruction::InsertValue: { 2836dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands InsertValueInst *IV = cast<InsertValueInst>(I); 2837dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands Result = SimplifyInsertValueInst(IV->getAggregateOperand(), 2838dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands IV->getInsertedValueOperand(), 2839dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands IV->getIndices(), TD, DT); 2840dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands break; 2841dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands } 2842cd6636c737a82949ad13db2d0d918af6424fb78bDuncan Sands case Instruction::PHI: 2843d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands Result = SimplifyPHINode(cast<PHINode>(I), DT); 2844d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 284571d050315704c23b235594d3fad5268c12d825e3Dan Gohman case Instruction::Call: 284671d050315704c23b235594d3fad5268c12d825e3Dan Gohman Result = SimplifyCallInst(cast<CallInst>(I)); 284771d050315704c23b235594d3fad5268c12d825e3Dan Gohman break; 2848e34537856a544c83513e390ac9552a8bc3823346Chris Lattner } 2849d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands 2850d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands /// If called on unreachable code, the above logic may report that the 2851d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands /// instruction simplified to itself. Make life easier for users by 2852f8b1a5ea9602bb65a5cf59d3d34f2851a08cdc3eDuncan Sands /// detecting that case here, returning a safe value instead. 2853f8b1a5ea9602bb65a5cf59d3d34f2851a08cdc3eDuncan Sands return Result == I ? UndefValue::get(I->getType()) : Result; 2854e34537856a544c83513e390ac9552a8bc3823346Chris Lattner} 2855e34537856a544c83513e390ac9552a8bc3823346Chris Lattner 285640d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// ReplaceAndSimplifyAllUses - Perform From->replaceAllUsesWith(To) and then 285740d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// delete the From instruction. In addition to a basic RAUW, this does a 285840d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// recursive simplification of the newly formed instructions. This catches 285940d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// things where one simplification exposes other opportunities. This only 286040d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// simplifies and deletes scalar operations, it does not change the CFG. 286140d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// 286240d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattnervoid llvm::ReplaceAndSimplifyAllUses(Instruction *From, Value *To, 2863eff0581583ef10e2872e9baf537a04b67d992101Duncan Sands const TargetData *TD, 2864618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 2865eff0581583ef10e2872e9baf537a04b67d992101Duncan Sands const DominatorTree *DT) { 286640d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner assert(From != To && "ReplaceAndSimplifyAllUses(X,X) is not valid!"); 286712a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2868d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // FromHandle/ToHandle - This keeps a WeakVH on the from/to values so that 2869d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // we can know if it gets deleted out from under us or replaced in a 2870d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // recursive simplification. 287140d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner WeakVH FromHandle(From); 2872d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner WeakVH ToHandle(To); 287312a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 287440d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner while (!From->use_empty()) { 287540d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner // Update the instruction to use the new value. 2876d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner Use &TheUse = From->use_begin().getUse(); 2877d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner Instruction *User = cast<Instruction>(TheUse.getUser()); 2878d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner TheUse = To; 2879d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner 2880d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // Check to see if the instruction can be folded due to the operand 2881d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // replacement. For example changing (or X, Y) into (or X, -1) can replace 2882d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // the 'or' with -1. 2883d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner Value *SimplifiedVal; 2884d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner { 2885d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // Sanity check to make sure 'User' doesn't dangle across 2886d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // SimplifyInstruction. 2887d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner AssertingVH<> UserHandle(User); 288812a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2889618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier SimplifiedVal = SimplifyInstruction(User, TD, TLI, DT); 2890d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner if (SimplifiedVal == 0) continue; 289140d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner } 289212a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2893d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // Recursively simplify this user to the new value. 2894618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier ReplaceAndSimplifyAllUses(User, SimplifiedVal, TD, TLI, DT); 2895d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner From = dyn_cast_or_null<Instruction>((Value*)FromHandle); 2896d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner To = ToHandle; 289712a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2898d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner assert(ToHandle && "To value deleted by recursive simplification?"); 289912a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2900d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // If the recursive simplification ended up revisiting and deleting 2901d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // 'From' then we're done. 2902d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner if (From == 0) 2903d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner return; 290440d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner } 290512a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2906d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // If 'From' has value handles referring to it, do a real RAUW to update them. 2907d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner From->replaceAllUsesWith(To); 290812a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 290940d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner From->eraseFromParent(); 291040d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner} 2911