InstructionSimplify.cpp revision 618c1dbd293d15ee19f61b1156ab8086ad28311a
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" 21562b84b3aea359d1f918184e355da82bf05eb290Jay Foad#include "llvm/Operator.h" 22a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands#include "llvm/ADT/Statistic.h" 239f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner#include "llvm/Analysis/InstructionSimplify.h" 249f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner#include "llvm/Analysis/ConstantFolding.h" 251845009290e4d804ad377927bd8a08cca3036adcDuncan Sands#include "llvm/Analysis/Dominators.h" 26d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands#include "llvm/Analysis/ValueTracking.h" 273a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky#include "llvm/Support/ConstantRange.h" 28d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner#include "llvm/Support/PatternMatch.h" 291845009290e4d804ad377927bd8a08cca3036adcDuncan Sands#include "llvm/Support/ValueHandle.h" 30e60d79faf7ef7bc4847f9e5d067af00b98dced7bDuncan Sands#include "llvm/Target/TargetData.h" 319f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattnerusing namespace llvm; 32d06094f0682f2ede03caff4892b1a57469896d48Chris Lattnerusing namespace llvm::PatternMatch; 339f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 3481a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattnerenum { RecursionLimit = 3 }; 35a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 36a3c44a5280042dbc0cde995675c225ede4528c6eDuncan SandsSTATISTIC(NumExpand, "Number of expansions"); 37a3c44a5280042dbc0cde995675c225ede4528c6eDuncan SandsSTATISTIC(NumFactor , "Number of factorizations"); 38a3c44a5280042dbc0cde995675c225ede4528c6eDuncan SandsSTATISTIC(NumReassoc, "Number of reassociations"); 39a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands 4082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sandsstatic Value *SimplifyAndInst(Value *, Value *, const TargetData *, 41618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *, const DominatorTree *, 42618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier unsigned); 43a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *SimplifyBinOp(unsigned, Value *, Value *, const TargetData *, 44618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *, const DominatorTree *, 45618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier unsigned); 46a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *SimplifyCmpInst(unsigned, Value *, Value *, const TargetData *, 47618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *, const DominatorTree *, 48618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier unsigned); 4982fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sandsstatic Value *SimplifyOrInst(Value *, Value *, const TargetData *, 50618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *, const DominatorTree *, 51618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier unsigned); 5282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sandsstatic Value *SimplifyXorInst(Value *, Value *, const TargetData *, 53618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *, const DominatorTree *, 54618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier unsigned); 551845009290e4d804ad377927bd8a08cca3036adcDuncan Sands 56f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands/// getFalse - For a boolean type, or a vector of boolean type, return false, or 57f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands/// a vector with every element false, as appropriate for the type. 58f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sandsstatic Constant *getFalse(Type *Ty) { 5966d004ef708642bbdc38fd761507f2e9ee3970cdNick Lewycky assert(Ty->getScalarType()->isIntegerTy(1) && 60f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands "Expected i1 type or a vector of i1!"); 61f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return Constant::getNullValue(Ty); 62f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands} 63f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands 64f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands/// getTrue - For a boolean type, or a vector of boolean type, return true, or 65f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands/// a vector with every element true, as appropriate for the type. 66f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sandsstatic Constant *getTrue(Type *Ty) { 6766d004ef708642bbdc38fd761507f2e9ee3970cdNick Lewycky assert(Ty->getScalarType()->isIntegerTy(1) && 68f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands "Expected i1 type or a vector of i1!"); 69f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return Constant::getAllOnesValue(Ty); 70f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands} 71f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands 726dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands/// isSameCompare - Is V equivalent to the comparison "LHS Pred RHS"? 736dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sandsstatic bool isSameCompare(Value *V, CmpInst::Predicate Pred, Value *LHS, 746dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands Value *RHS) { 756dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands CmpInst *Cmp = dyn_cast<CmpInst>(V); 766dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (!Cmp) 776dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return false; 786dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands CmpInst::Predicate CPred = Cmp->getPredicate(); 796dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands Value *CLHS = Cmp->getOperand(0), *CRHS = Cmp->getOperand(1); 806dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (CPred == Pred && CLHS == LHS && CRHS == RHS) 816dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return true; 826dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return CPred == CmpInst::getSwappedPredicate(Pred) && CLHS == RHS && 836dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands CRHS == LHS; 846dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands} 856dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands 861845009290e4d804ad377927bd8a08cca3036adcDuncan Sands/// ValueDominatesPHI - Does the given value dominate the specified phi node? 871845009290e4d804ad377927bd8a08cca3036adcDuncan Sandsstatic bool ValueDominatesPHI(Value *V, PHINode *P, const DominatorTree *DT) { 881845009290e4d804ad377927bd8a08cca3036adcDuncan Sands Instruction *I = dyn_cast<Instruction>(V); 891845009290e4d804ad377927bd8a08cca3036adcDuncan Sands if (!I) 901845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // Arguments and constants dominate all instructions. 911845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return true; 921845009290e4d804ad377927bd8a08cca3036adcDuncan Sands 931845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // If we have a DominatorTree then do a precise test. 941845009290e4d804ad377927bd8a08cca3036adcDuncan Sands if (DT) 951845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return DT->dominates(I, P); 961845009290e4d804ad377927bd8a08cca3036adcDuncan Sands 971845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // Otherwise, if the instruction is in the entry block, and is not an invoke, 981845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // then it obviously dominates all phi nodes. 991845009290e4d804ad377927bd8a08cca3036adcDuncan Sands if (I->getParent() == &I->getParent()->getParent()->getEntryBlock() && 1001845009290e4d804ad377927bd8a08cca3036adcDuncan Sands !isa<InvokeInst>(I)) 1011845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return true; 1021845009290e4d804ad377927bd8a08cca3036adcDuncan Sands 1031845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return false; 1041845009290e4d804ad377927bd8a08cca3036adcDuncan Sands} 105a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 1063421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// ExpandBinOp - Simplify "A op (B op' C)" by distributing op over op', turning 1073421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// it into "(A op B) op' (A op C)". Here "op" is given by Opcode and "op'" is 1083421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// given by OpcodeToExpand, while "A" corresponds to LHS and "B op' C" to RHS. 1093421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// Also performs the transform "(A op' B) op C" -> "(A op C) op' (B op C)". 1103421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// Returns the simplified value, or null if no simplification was performed. 1113421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sandsstatic Value *ExpandBinOp(unsigned Opcode, Value *LHS, Value *RHS, 112e21083aa3a79506f896d95d7147c3c4627a77ef0Benjamin Kramer unsigned OpcToExpand, const TargetData *TD, 113618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, const DominatorTree *DT, 114618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier unsigned MaxRecurse) { 115e21083aa3a79506f896d95d7147c3c4627a77ef0Benjamin Kramer Instruction::BinaryOps OpcodeToExpand = (Instruction::BinaryOps)OpcToExpand; 1163421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 1173421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (!MaxRecurse--) 1183421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return 0; 1193421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1203421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Check whether the expression has the form "(A op' B) op C". 1213421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (BinaryOperator *Op0 = dyn_cast<BinaryOperator>(LHS)) 1223421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Op0->getOpcode() == OpcodeToExpand) { 1233421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // It does! Try turning it into "(A op C) op' (B op C)". 1243421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands Value *A = Op0->getOperand(0), *B = Op0->getOperand(1), *C = RHS; 1253421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Do "A op C" and "B op C" both simplify? 126618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *L = SimplifyBinOp(Opcode, A, C, TD, TLI, DT, MaxRecurse)) 127618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *R = SimplifyBinOp(Opcode, B, C, TD, TLI, DT, MaxRecurse)) { 1283421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // They do! Return "L op' R" if it simplifies or is already available. 1293421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // If "L op' R" equals "A op' B" then "L op' R" is just the LHS. 130124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if ((L == A && R == B) || (Instruction::isCommutative(OpcodeToExpand) 131124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands && L == B && R == A)) { 132a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumExpand; 1333421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return LHS; 134a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 1353421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Otherwise return "L op' R" if it simplifies. 136618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyBinOp(OpcodeToExpand, L, R, TD, TLI, DT, 137a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands MaxRecurse)) { 138a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumExpand; 1393421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 140a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 1413421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 1423421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 1433421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1443421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Check whether the expression has the form "A op (B op' C)". 1453421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (BinaryOperator *Op1 = dyn_cast<BinaryOperator>(RHS)) 1463421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Op1->getOpcode() == OpcodeToExpand) { 1473421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // It does! Try turning it into "(A op B) op' (A op C)". 1483421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands Value *A = LHS, *B = Op1->getOperand(0), *C = Op1->getOperand(1); 1493421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Do "A op B" and "A op C" both simplify? 150618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *L = SimplifyBinOp(Opcode, A, B, TD, TLI, DT, MaxRecurse)) 151618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *R = SimplifyBinOp(Opcode, A, C, TD, TLI, DT, MaxRecurse)) { 1523421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // They do! Return "L op' R" if it simplifies or is already available. 1533421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // If "L op' R" equals "B op' C" then "L op' R" is just the RHS. 154124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if ((L == B && R == C) || (Instruction::isCommutative(OpcodeToExpand) 155124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands && L == C && R == B)) { 156a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumExpand; 1573421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return RHS; 158a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 1593421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Otherwise return "L op' R" if it simplifies. 160618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyBinOp(OpcodeToExpand, L, R, TD, TLI, DT, 161a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands MaxRecurse)) { 162a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumExpand; 1633421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 164a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 1653421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 1663421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 1673421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1683421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return 0; 1693421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands} 1703421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1713421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// FactorizeBinOp - Simplify "LHS Opcode RHS" by factorizing out a common term 1723421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// using the operation OpCodeToExtract. For example, when Opcode is Add and 1733421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// OpCodeToExtract is Mul then this tries to turn "(A*B)+(A*C)" into "A*(B+C)". 1743421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// Returns the simplified value, or null if no simplification was performed. 1753421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sandsstatic Value *FactorizeBinOp(unsigned Opcode, Value *LHS, Value *RHS, 176618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier unsigned OpcToExtract, const TargetData *TD, 177618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 178618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT, 179618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier unsigned MaxRecurse) { 180e21083aa3a79506f896d95d7147c3c4627a77ef0Benjamin Kramer Instruction::BinaryOps OpcodeToExtract = (Instruction::BinaryOps)OpcToExtract; 1813421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 1823421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (!MaxRecurse--) 1833421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return 0; 1843421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1853421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands BinaryOperator *Op0 = dyn_cast<BinaryOperator>(LHS); 1863421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands BinaryOperator *Op1 = dyn_cast<BinaryOperator>(RHS); 1873421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1883421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (!Op0 || Op0->getOpcode() != OpcodeToExtract || 1893421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands !Op1 || Op1->getOpcode() != OpcodeToExtract) 1903421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return 0; 1913421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1923421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // The expression has the form "(A op' B) op (C op' D)". 19382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands Value *A = Op0->getOperand(0), *B = Op0->getOperand(1); 19482fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands Value *C = Op1->getOperand(0), *D = Op1->getOperand(1); 1953421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1963421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Use left distributivity, i.e. "X op' (Y op Z) = (X op' Y) op (X op' Z)". 1973421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Does the instruction have the form "(A op' B) op (A op' D)" or, in the 1983421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // commutative case, "(A op' B) op (C op' A)"? 199124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (A == C || (Instruction::isCommutative(OpcodeToExtract) && A == D)) { 200124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands Value *DD = A == C ? D : C; 2013421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Form "A op' (B op DD)" if it simplifies completely. 2023421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Does "B op DD" simplify? 203618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyBinOp(Opcode, B, DD, TD, TLI, DT, MaxRecurse)) { 2043421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // It does! Return "A op' V" if it simplifies or is already available. 2051cd05bb605e3c3eee9197d3f10b628c60d0cc07aDuncan Sands // If V equals B then "A op' V" is just the LHS. If V equals DD then 2061cd05bb605e3c3eee9197d3f10b628c60d0cc07aDuncan Sands // "A op' V" is just the RHS. 207124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (V == B || V == DD) { 208a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumFactor; 209124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands return V == B ? LHS : RHS; 210a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 2113421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Otherwise return "A op' V" if it simplifies. 212618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *W = SimplifyBinOp(OpcodeToExtract, A, V, TD, TLI, DT, 213618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier MaxRecurse)) { 214a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumFactor; 2153421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return W; 216a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 2173421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 2183421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 2193421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 2203421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Use right distributivity, i.e. "(X op Y) op' Z = (X op' Z) op (Y op' Z)". 2213421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Does the instruction have the form "(A op' B) op (C op' B)" or, in the 2223421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // commutative case, "(A op' B) op (B op' D)"? 223124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (B == D || (Instruction::isCommutative(OpcodeToExtract) && B == C)) { 224124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands Value *CC = B == D ? C : D; 2253421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Form "(A op CC) op' B" if it simplifies completely.. 2263421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Does "A op CC" simplify? 227618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyBinOp(Opcode, A, CC, TD, TLI, DT, MaxRecurse)) { 2283421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // It does! Return "V op' B" if it simplifies or is already available. 2291cd05bb605e3c3eee9197d3f10b628c60d0cc07aDuncan Sands // If V equals A then "V op' B" is just the LHS. If V equals CC then 2301cd05bb605e3c3eee9197d3f10b628c60d0cc07aDuncan Sands // "V op' B" is just the RHS. 231124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (V == A || V == CC) { 232a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumFactor; 233124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands return V == A ? LHS : RHS; 234a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 2353421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Otherwise return "V op' B" if it simplifies. 236618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *W = SimplifyBinOp(OpcodeToExtract, V, B, TD, TLI, DT, 237618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier MaxRecurse)) { 238a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumFactor; 2393421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return W; 240a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 2413421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 2423421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 2433421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 2443421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return 0; 2453421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands} 2463421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 2473421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// SimplifyAssociativeBinOp - Generic simplifications for associative binary 2483421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// operations. Returns the simpler value, or null if none was found. 249e21083aa3a79506f896d95d7147c3c4627a77ef0Benjamin Kramerstatic Value *SimplifyAssociativeBinOp(unsigned Opc, Value *LHS, Value *RHS, 250566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands const TargetData *TD, 251618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 252566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands const DominatorTree *DT, 253566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands unsigned MaxRecurse) { 254e21083aa3a79506f896d95d7147c3c4627a77ef0Benjamin Kramer Instruction::BinaryOps Opcode = (Instruction::BinaryOps)Opc; 255566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands assert(Instruction::isAssociative(Opcode) && "Not an associative operation!"); 256566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 257566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 258566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (!MaxRecurse--) 259566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return 0; 260566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 261566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands BinaryOperator *Op0 = dyn_cast<BinaryOperator>(LHS); 262566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands BinaryOperator *Op1 = dyn_cast<BinaryOperator>(RHS); 263566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 264566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Transform: "(A op B) op C" ==> "A op (B op C)" if it simplifies completely. 265566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Op0 && Op0->getOpcode() == Opcode) { 266566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *A = Op0->getOperand(0); 267566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *B = Op0->getOperand(1); 268566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *C = RHS; 269566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 270566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Does "B op C" simplify? 271618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyBinOp(Opcode, B, C, TD, TLI, DT, MaxRecurse)) { 272566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // It does! Return "A op V" if it simplifies or is already available. 273566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // If V equals B then "A op V" is just the LHS. 274124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (V == B) return LHS; 275566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Otherwise return "A op V" if it simplifies. 276618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *W = SimplifyBinOp(Opcode, A, V, TD, TLI, DT, MaxRecurse)) { 277a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumReassoc; 278566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return W; 279a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 280566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 281566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 282566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 283566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Transform: "A op (B op C)" ==> "(A op B) op C" if it simplifies completely. 284566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Op1 && Op1->getOpcode() == Opcode) { 285566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *A = LHS; 286566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *B = Op1->getOperand(0); 287566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *C = Op1->getOperand(1); 288566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 289566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Does "A op B" simplify? 290618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyBinOp(Opcode, A, B, TD, TLI, DT, MaxRecurse)) { 291566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // It does! Return "V op C" if it simplifies or is already available. 292566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // If V equals B then "V op C" is just the RHS. 293124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (V == B) return RHS; 294566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Otherwise return "V op C" if it simplifies. 295618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *W = SimplifyBinOp(Opcode, V, C, TD, TLI, DT, MaxRecurse)) { 296a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumReassoc; 297566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return W; 298a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 299566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 300566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 301566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 302566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // The remaining transforms require commutativity as well as associativity. 303566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (!Instruction::isCommutative(Opcode)) 304566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return 0; 305566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 306566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Transform: "(A op B) op C" ==> "(C op A) op B" if it simplifies completely. 307566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Op0 && Op0->getOpcode() == Opcode) { 308566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *A = Op0->getOperand(0); 309566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *B = Op0->getOperand(1); 310566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *C = RHS; 311566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 312566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Does "C op A" simplify? 313618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyBinOp(Opcode, C, A, TD, TLI, DT, MaxRecurse)) { 314566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // It does! Return "V op B" if it simplifies or is already available. 315566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // If V equals A then "V op B" is just the LHS. 316124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (V == A) return LHS; 317566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Otherwise return "V op B" if it simplifies. 318618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *W = SimplifyBinOp(Opcode, V, B, TD, TLI, DT, MaxRecurse)) { 319a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumReassoc; 320566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return W; 321a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 322566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 323566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 324566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 325566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Transform: "A op (B op C)" ==> "B op (C op A)" if it simplifies completely. 326566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Op1 && Op1->getOpcode() == Opcode) { 327566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *A = LHS; 328566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *B = Op1->getOperand(0); 329566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *C = Op1->getOperand(1); 330566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 331566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Does "C op A" simplify? 332618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyBinOp(Opcode, C, A, TD, TLI, DT, MaxRecurse)) { 333566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // It does! Return "B op V" if it simplifies or is already available. 334566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // If V equals C then "B op V" is just the RHS. 335124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (V == C) return RHS; 336566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Otherwise return "B op V" if it simplifies. 337618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *W = SimplifyBinOp(Opcode, B, V, TD, TLI, DT, MaxRecurse)) { 338a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumReassoc; 339566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return W; 340a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 341566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 342566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 343566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 344566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return 0; 345566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands} 346566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 347b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// ThreadBinOpOverSelect - In the case of a binary operation with a select 348b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// instruction as an operand, try to simplify the binop by seeing whether 349b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// evaluating it on both branches of the select results in the same value. 350b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// Returns the common value if so, otherwise returns null. 351b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sandsstatic Value *ThreadBinOpOverSelect(unsigned Opcode, Value *LHS, Value *RHS, 3521845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const TargetData *TD, 353618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 3541845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const DominatorTree *DT, 3551845009290e4d804ad377927bd8a08cca3036adcDuncan Sands unsigned MaxRecurse) { 3560312a93693abc2eb682b2b101c889959888fd883Duncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 3570312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (!MaxRecurse--) 3580312a93693abc2eb682b2b101c889959888fd883Duncan Sands return 0; 3590312a93693abc2eb682b2b101c889959888fd883Duncan Sands 360b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands SelectInst *SI; 361b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (isa<SelectInst>(LHS)) { 362b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands SI = cast<SelectInst>(LHS); 363b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } else { 364b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands assert(isa<SelectInst>(RHS) && "No select instruction operand!"); 365b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands SI = cast<SelectInst>(RHS); 366b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } 367b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 368b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // Evaluate the BinOp on the true and false branches of the select. 369b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Value *TV; 370b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Value *FV; 371b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (SI == LHS) { 372618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TV = SimplifyBinOp(Opcode, SI->getTrueValue(), RHS, TD, TLI, DT, MaxRecurse); 373618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier FV = SimplifyBinOp(Opcode, SI->getFalseValue(), RHS, TD, TLI, DT, MaxRecurse); 374b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } else { 375618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TV = SimplifyBinOp(Opcode, LHS, SI->getTrueValue(), TD, TLI, DT, MaxRecurse); 376618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier FV = SimplifyBinOp(Opcode, LHS, SI->getFalseValue(), TD, TLI, DT, MaxRecurse); 377b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } 378b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 3797cf85e74e3885005ca8e5fdb155fa5351e255b85Duncan Sands // If they simplified to the same value, then return the common value. 380124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands // If they both failed to simplify then return null. 381124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (TV == FV) 382b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return TV; 383b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 384b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // If one branch simplified to undef, return the other one. 385b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (TV && isa<UndefValue>(TV)) 386b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return FV; 387b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (FV && isa<UndefValue>(FV)) 388b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return TV; 389b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 390b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // If applying the operation did not change the true and false select values, 391b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // then the result of the binop is the select itself. 392124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (TV == SI->getTrueValue() && FV == SI->getFalseValue()) 393b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return SI; 394b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 395b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // If one branch simplified and the other did not, and the simplified 396b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // value is equal to the unsimplified one, return the simplified value. 397b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // For example, select (cond, X, X & Z) & Z -> X & Z. 398b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if ((FV && !TV) || (TV && !FV)) { 399b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // Check that the simplified value has the form "X op Y" where "op" is the 400b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // same as the original operation. 401b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Instruction *Simplified = dyn_cast<Instruction>(FV ? FV : TV); 402b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (Simplified && Simplified->getOpcode() == Opcode) { 403b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // The value that didn't simplify is "UnsimplifiedLHS op UnsimplifiedRHS". 404b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // We already know that "op" is the same as for the simplified value. See 405b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // if the operands match too. If so, return the simplified value. 406b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Value *UnsimplifiedBranch = FV ? SI->getTrueValue() : SI->getFalseValue(); 407b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Value *UnsimplifiedLHS = SI == LHS ? UnsimplifiedBranch : LHS; 408b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Value *UnsimplifiedRHS = SI == LHS ? RHS : UnsimplifiedBranch; 409124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (Simplified->getOperand(0) == UnsimplifiedLHS && 410124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands Simplified->getOperand(1) == UnsimplifiedRHS) 411b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return Simplified; 412b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (Simplified->isCommutative() && 413124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands Simplified->getOperand(1) == UnsimplifiedLHS && 414124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands Simplified->getOperand(0) == UnsimplifiedRHS) 415b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return Simplified; 416b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } 417b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } 418b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 419b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return 0; 420b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands} 421b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 422b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// ThreadCmpOverSelect - In the case of a comparison with a select instruction, 423b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// try to simplify the comparison by seeing whether both branches of the select 424b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// result in the same value. Returns the common value if so, otherwise returns 425b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// null. 426b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sandsstatic Value *ThreadCmpOverSelect(CmpInst::Predicate Pred, Value *LHS, 427a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands Value *RHS, const TargetData *TD, 428618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 4291845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const DominatorTree *DT, 430a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands unsigned MaxRecurse) { 4310312a93693abc2eb682b2b101c889959888fd883Duncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 4320312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (!MaxRecurse--) 4330312a93693abc2eb682b2b101c889959888fd883Duncan Sands return 0; 4340312a93693abc2eb682b2b101c889959888fd883Duncan Sands 435b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // Make sure the select is on the LHS. 436b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (!isa<SelectInst>(LHS)) { 437b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands std::swap(LHS, RHS); 438b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Pred = CmpInst::getSwappedPredicate(Pred); 439b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } 440b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands assert(isa<SelectInst>(LHS) && "Not comparing with a select instruction!"); 441b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands SelectInst *SI = cast<SelectInst>(LHS); 4426dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands Value *Cond = SI->getCondition(); 4436dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands Value *TV = SI->getTrueValue(); 4446dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands Value *FV = SI->getFalseValue(); 445b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 44650ca4d37f7f3b460c6441eb5ad14625a7d86b5d9Duncan Sands // Now that we have "cmp select(Cond, TV, FV), RHS", analyse it. 447b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // Does "cmp TV, RHS" simplify? 448618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Value *TCmp = SimplifyCmpInst(Pred, TV, RHS, TD, TLI, DT, MaxRecurse); 4496dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (TCmp == Cond) { 4506dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // It not only simplified, it simplified to the select condition. Replace 4516dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // it with 'true'. 4526dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands TCmp = getTrue(Cond->getType()); 4536dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands } else if (!TCmp) { 4546dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // It didn't simplify. However if "cmp TV, RHS" is equal to the select 4556dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // condition then we can replace it with 'true'. Otherwise give up. 4566dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (!isSameCompare(Cond, Pred, TV, RHS)) 4576dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return 0; 4586dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands TCmp = getTrue(Cond->getType()); 45950ca4d37f7f3b460c6441eb5ad14625a7d86b5d9Duncan Sands } 46050ca4d37f7f3b460c6441eb5ad14625a7d86b5d9Duncan Sands 4616dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // Does "cmp FV, RHS" simplify? 462618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Value *FCmp = SimplifyCmpInst(Pred, FV, RHS, TD, TLI, DT, MaxRecurse); 4636dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (FCmp == Cond) { 4646dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // It not only simplified, it simplified to the select condition. Replace 4656dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // it with 'false'. 4666dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands FCmp = getFalse(Cond->getType()); 4676dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands } else if (!FCmp) { 4686dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // It didn't simplify. However if "cmp FV, RHS" is equal to the select 4696dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // condition then we can replace it with 'false'. Otherwise give up. 4706dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (!isSameCompare(Cond, Pred, FV, RHS)) 4716dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return 0; 4726dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands FCmp = getFalse(Cond->getType()); 4736dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands } 4746dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands 4756dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // If both sides simplified to the same value, then use it as the result of 4766dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // the original comparison. 4776dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (TCmp == FCmp) 4786dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return TCmp; 4796dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // If the false value simplified to false, then the result of the compare 4806dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // is equal to "Cond && TCmp". This also catches the case when the false 4816dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // value simplified to false and the true value to true, returning "Cond". 4826dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (match(FCmp, m_Zero())) 483618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyAndInst(Cond, TCmp, TD, TLI, DT, MaxRecurse)) 4846dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return V; 4856dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // If the true value simplified to true, then the result of the compare 4866dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // is equal to "Cond || FCmp". 4876dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (match(TCmp, m_One())) 488618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyOrInst(Cond, FCmp, TD, TLI, DT, MaxRecurse)) 4896dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return V; 4906dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // Finally, if the false value simplified to true and the true value to 4916dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // false, then the result of the compare is equal to "!Cond". 4926dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (match(FCmp, m_One()) && match(TCmp, m_Zero())) 4936dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (Value *V = 4946dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands SimplifyXorInst(Cond, Constant::getAllOnesValue(Cond->getType()), 495618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT, MaxRecurse)) 4966dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return V; 4976dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands 498b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return 0; 499b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands} 500b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 501a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// ThreadBinOpOverPHI - In the case of a binary operation with an operand that 502a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// is a PHI instruction, try to simplify the binop by seeing whether evaluating 503a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// it on the incoming phi values yields the same result for every value. If so 504a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// returns the common value, otherwise returns null. 505a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *ThreadBinOpOverPHI(unsigned Opcode, Value *LHS, Value *RHS, 506618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, 507618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 508618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT, 5091845009290e4d804ad377927bd8a08cca3036adcDuncan Sands unsigned MaxRecurse) { 5100312a93693abc2eb682b2b101c889959888fd883Duncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 5110312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (!MaxRecurse--) 5120312a93693abc2eb682b2b101c889959888fd883Duncan Sands return 0; 5130312a93693abc2eb682b2b101c889959888fd883Duncan Sands 514a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands PHINode *PI; 515a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands if (isa<PHINode>(LHS)) { 516a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands PI = cast<PHINode>(LHS); 5171845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // Bail out if RHS and the phi may be mutually interdependent due to a loop. 5181845009290e4d804ad377927bd8a08cca3036adcDuncan Sands if (!ValueDominatesPHI(RHS, PI, DT)) 5191845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return 0; 520a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands } else { 521a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands assert(isa<PHINode>(RHS) && "No PHI instruction operand!"); 522a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands PI = cast<PHINode>(RHS); 5231845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // Bail out if LHS and the phi may be mutually interdependent due to a loop. 5241845009290e4d804ad377927bd8a08cca3036adcDuncan Sands if (!ValueDominatesPHI(LHS, PI, DT)) 5251845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return 0; 526a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands } 527a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 528a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // Evaluate the BinOp on the incoming phi values. 529a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands Value *CommonValue = 0; 530a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands for (unsigned i = 0, e = PI->getNumIncomingValues(); i != e; ++i) { 531552008946530e01efdad15044e1f621883d14a3aDuncan Sands Value *Incoming = PI->getIncomingValue(i); 532ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // If the incoming value is the phi node itself, it can safely be skipped. 533552008946530e01efdad15044e1f621883d14a3aDuncan Sands if (Incoming == PI) continue; 534a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands Value *V = PI == LHS ? 535618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier SimplifyBinOp(Opcode, Incoming, RHS, TD, TLI, DT, MaxRecurse) : 536618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier SimplifyBinOp(Opcode, LHS, Incoming, TD, TLI, DT, MaxRecurse); 537a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the operation failed to simplify, or simplified to a different value 538a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // to previously, then give up. 539a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands if (!V || (CommonValue && V != CommonValue)) 540a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return 0; 541a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands CommonValue = V; 542a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands } 543a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 544a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return CommonValue; 545a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 546a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 547a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// ThreadCmpOverPHI - In the case of a comparison with a PHI instruction, try 548a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// try to simplify the comparison by seeing whether comparing with all of the 549a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// incoming phi values yields the same result every time. If so returns the 550a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// common result, otherwise returns null. 551a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *ThreadCmpOverPHI(CmpInst::Predicate Pred, Value *LHS, Value *RHS, 552618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, 553618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 554618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT, 5551845009290e4d804ad377927bd8a08cca3036adcDuncan Sands unsigned MaxRecurse) { 5560312a93693abc2eb682b2b101c889959888fd883Duncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 5570312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (!MaxRecurse--) 5580312a93693abc2eb682b2b101c889959888fd883Duncan Sands return 0; 5590312a93693abc2eb682b2b101c889959888fd883Duncan Sands 560a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // Make sure the phi is on the LHS. 561a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands if (!isa<PHINode>(LHS)) { 562a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands std::swap(LHS, RHS); 563a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands Pred = CmpInst::getSwappedPredicate(Pred); 564a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands } 565a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands assert(isa<PHINode>(LHS) && "Not comparing with a phi instruction!"); 566a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands PHINode *PI = cast<PHINode>(LHS); 567a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 5681845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // Bail out if RHS and the phi may be mutually interdependent due to a loop. 5691845009290e4d804ad377927bd8a08cca3036adcDuncan Sands if (!ValueDominatesPHI(RHS, PI, DT)) 5701845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return 0; 5711845009290e4d804ad377927bd8a08cca3036adcDuncan Sands 572a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // Evaluate the BinOp on the incoming phi values. 573a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands Value *CommonValue = 0; 574a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands for (unsigned i = 0, e = PI->getNumIncomingValues(); i != e; ++i) { 575552008946530e01efdad15044e1f621883d14a3aDuncan Sands Value *Incoming = PI->getIncomingValue(i); 576ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // If the incoming value is the phi node itself, it can safely be skipped. 577552008946530e01efdad15044e1f621883d14a3aDuncan Sands if (Incoming == PI) continue; 578618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Value *V = SimplifyCmpInst(Pred, Incoming, RHS, TD, TLI, DT, MaxRecurse); 579a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the operation failed to simplify, or simplified to a different value 580a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // to previously, then give up. 581a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands if (!V || (CommonValue && V != CommonValue)) 582a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return 0; 583a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands CommonValue = V; 584a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands } 585a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 586a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return CommonValue; 587a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 588a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 5898aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner/// SimplifyAddInst - Given operands for an Add, see if we can 590d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner/// fold the result. If not, this returns null. 591ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sandsstatic Value *SimplifyAddInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, 592618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, 593618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 594618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT, 595ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands unsigned MaxRecurse) { 596d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 597d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 598d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Constant *Ops[] = { CLHS, CRHS }; 5998aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner return ConstantFoldInstOperands(Instruction::Add, CLHS->getType(), 600618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Ops, TD, TLI); 6018aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner } 60212a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 6038aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner // Canonicalize the constant to the RHS. 6048aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner std::swap(Op0, Op1); 6058aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner } 60612a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 607fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X + undef -> undef 608f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 609fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return Op1; 61012a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 611fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X + 0 -> X 612fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands if (match(Op1, m_Zero())) 613fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return Op0; 614fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 615fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X + (Y - X) -> Y 616fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // (Y - X) + X -> Y 617ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands // Eg: X + -X -> 0 618124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands Value *Y = 0; 619124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (match(Op1, m_Sub(m_Value(Y), m_Specific(Op0))) || 620124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands match(Op0, m_Sub(m_Value(Y), m_Specific(Op1)))) 621fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return Y; 622fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 623fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X + ~X -> -1 since ~X = -X-1 624124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (match(Op0, m_Not(m_Specific(Op1))) || 625124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands match(Op1, m_Not(m_Specific(Op0)))) 626fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return Constant::getAllOnesValue(Op0->getType()); 62787689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands 62882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands /// i1 add -> xor. 62975d289ed6201e82718343d7a36d2a2fa082f6217Duncan Sands if (MaxRecurse && Op0->getType()->isIntegerTy(1)) 630618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyXorInst(Op0, Op1, TD, TLI, DT, MaxRecurse-1)) 63107f30fbd734069b80b90c6aeea0ae645ce3880c0Duncan Sands return V; 63282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 633566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Try some generic simplifications for associative operations. 634618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyAssociativeBinOp(Instruction::Add, Op0, Op1, TD, TLI, DT, 635566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands MaxRecurse)) 636566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return V; 637566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 6383421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Mul distributes over Add. Try some generic simplifications based on this. 6393421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = FactorizeBinOp(Instruction::Add, Op0, Op1, Instruction::Mul, 640618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT, MaxRecurse)) 6413421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 6423421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 64387689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // Threading Add over selects and phi nodes is pointless, so don't bother. 64487689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // Threading over the select in "A + select(cond, B, C)" means evaluating 64587689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // "A+B" and "A+C" and seeing if they are equal; but they are equal if and 64687689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // only if B and C are equal. If B and C are equal then (since we assume 64787689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // that operands have already been simplified) "select(cond, B, C)" should 64887689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // have been simplified to the common value of B and C already. Analysing 64987689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // "A+B" and "A+C" thus gains nothing, but costs compile time. Similarly 65087689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // for threading over phi nodes. 65187689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands 6528aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner return 0; 6538aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner} 6548aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner 655ee9a2e322af96accc9e55ed6373c0057453714b1Duncan SandsValue *llvm::SimplifyAddInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, 656618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, const TargetLibraryInfo *TLI, 657618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT) { 658618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ::SimplifyAddInst(Op0, Op1, isNSW, isNUW, TD, TLI, DT, RecursionLimit); 659ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands} 660ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands 661fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands/// SimplifySubInst - Given operands for a Sub, see if we can 662fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands/// fold the result. If not, this returns null. 663ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sandsstatic Value *SimplifySubInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, 664618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, 665618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 666618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT, 667ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands unsigned MaxRecurse) { 668fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands if (Constant *CLHS = dyn_cast<Constant>(Op0)) 669fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 670fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands Constant *Ops[] = { CLHS, CRHS }; 671fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return ConstantFoldInstOperands(Instruction::Sub, CLHS->getType(), 672618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Ops, TD, TLI); 673fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands } 674fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 675fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X - undef -> undef 676fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // undef - X -> undef 677f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op0, m_Undef()) || match(Op1, m_Undef())) 678fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return UndefValue::get(Op0->getType()); 679fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 680fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X - 0 -> X 681fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands if (match(Op1, m_Zero())) 682fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return Op0; 683fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 684fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X - X -> 0 685124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (Op0 == Op1) 686fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return Constant::getNullValue(Op0->getType()); 687fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 688fe02c69f84ad52d42be934e4fe702f03e4991a6aDuncan Sands // (X*2) - X -> X 689fe02c69f84ad52d42be934e4fe702f03e4991a6aDuncan Sands // (X<<1) - X -> X 690b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands Value *X = 0; 691fe02c69f84ad52d42be934e4fe702f03e4991a6aDuncan Sands if (match(Op0, m_Mul(m_Specific(Op1), m_ConstantInt<2>())) || 692fe02c69f84ad52d42be934e4fe702f03e4991a6aDuncan Sands match(Op0, m_Shl(m_Specific(Op1), m_One()))) 693fe02c69f84ad52d42be934e4fe702f03e4991a6aDuncan Sands return Op1; 694fe02c69f84ad52d42be934e4fe702f03e4991a6aDuncan Sands 695b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // (X + Y) - Z -> X + (Y - Z) or Y + (X - Z) if everything simplifies. 696b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // For example, (X + Y) - Y -> X; (Y + X) - Y -> X 697b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands Value *Y = 0, *Z = Op1; 698b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands if (MaxRecurse && match(Op0, m_Add(m_Value(X), m_Value(Y)))) { // (X + Y) - Z 699b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // See if "V === Y - Z" simplifies. 700618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyBinOp(Instruction::Sub, Y, Z, TD, TLI, DT, MaxRecurse-1)) 701b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does! Now see if "X + V" simplifies. 702618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *W = SimplifyBinOp(Instruction::Add, X, V, TD, TLI, DT, 703b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands MaxRecurse-1)) { 704b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does, we successfully reassociated! 705b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands ++NumReassoc; 706b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands return W; 707b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands } 708b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // See if "V === X - Z" simplifies. 709618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyBinOp(Instruction::Sub, X, Z, TD, TLI, DT, MaxRecurse-1)) 710b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does! Now see if "Y + V" simplifies. 711618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *W = SimplifyBinOp(Instruction::Add, Y, V, TD, TLI, DT, 712b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands MaxRecurse-1)) { 713b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does, we successfully reassociated! 714b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands ++NumReassoc; 715b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands return W; 716b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands } 717b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands } 71882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 719b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // X - (Y + Z) -> (X - Y) - Z or (X - Z) - Y if everything simplifies. 720b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // For example, X - (X + 1) -> -1 721b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands X = Op0; 722b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands if (MaxRecurse && match(Op1, m_Add(m_Value(Y), m_Value(Z)))) { // X - (Y + Z) 723b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // See if "V === X - Y" simplifies. 724618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyBinOp(Instruction::Sub, X, Y, TD, TLI, DT, MaxRecurse-1)) 725b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does! Now see if "V - Z" simplifies. 726618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *W = SimplifyBinOp(Instruction::Sub, V, Z, TD, TLI, DT, 727b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands MaxRecurse-1)) { 728b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does, we successfully reassociated! 729b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands ++NumReassoc; 730b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands return W; 731b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands } 732b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // See if "V === X - Z" simplifies. 733618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyBinOp(Instruction::Sub, X, Z, TD, TLI, DT, MaxRecurse-1)) 734b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does! Now see if "V - Y" simplifies. 735618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *W = SimplifyBinOp(Instruction::Sub, V, Y, TD, TLI, DT, 736b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands MaxRecurse-1)) { 737b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does, we successfully reassociated! 738b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands ++NumReassoc; 739b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands return W; 740b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands } 741b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands } 742b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands 743b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // Z - (X - Y) -> (Z - X) + Y if everything simplifies. 744b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // For example, X - (X - Y) -> Y. 745b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands Z = Op0; 746c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands if (MaxRecurse && match(Op1, m_Sub(m_Value(X), m_Value(Y)))) // Z - (X - Y) 747c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands // See if "V === Z - X" simplifies. 748618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyBinOp(Instruction::Sub, Z, X, TD, TLI, DT, MaxRecurse-1)) 749b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does! Now see if "V + Y" simplifies. 750618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *W = SimplifyBinOp(Instruction::Add, V, Y, TD, TLI, DT, 751c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands MaxRecurse-1)) { 752c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands // It does, we successfully reassociated! 753c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands ++NumReassoc; 754c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands return W; 755c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands } 756c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands 7573421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Mul distributes over Sub. Try some generic simplifications based on this. 7583421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = FactorizeBinOp(Instruction::Sub, Op0, Op1, Instruction::Mul, 759618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT, MaxRecurse)) 7603421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 7613421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 762b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // i1 sub -> xor. 763b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands if (MaxRecurse && Op0->getType()->isIntegerTy(1)) 764618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyXorInst(Op0, Op1, TD, TLI, DT, MaxRecurse-1)) 765b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands return V; 766b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands 767fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // Threading Sub over selects and phi nodes is pointless, so don't bother. 768fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // Threading over the select in "A - select(cond, B, C)" means evaluating 769fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // "A-B" and "A-C" and seeing if they are equal; but they are equal if and 770fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // only if B and C are equal. If B and C are equal then (since we assume 771fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // that operands have already been simplified) "select(cond, B, C)" should 772fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // have been simplified to the common value of B and C already. Analysing 773fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // "A-B" and "A-C" thus gains nothing, but costs compile time. Similarly 774fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // for threading over phi nodes. 775fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 776fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return 0; 777fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands} 778fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 779ee9a2e322af96accc9e55ed6373c0057453714b1Duncan SandsValue *llvm::SimplifySubInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, 780618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, 781618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 782618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT) { 783618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ::SimplifySubInst(Op0, Op1, isNSW, isNUW, TD, TLI, DT, RecursionLimit); 784ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands} 785ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands 78682fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands/// SimplifyMulInst - Given operands for a Mul, see if we can 78782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands/// fold the result. If not, this returns null. 78882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sandsstatic Value *SimplifyMulInst(Value *Op0, Value *Op1, const TargetData *TD, 789618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 79082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands const DominatorTree *DT, unsigned MaxRecurse) { 79182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 79282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 79382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands Constant *Ops[] = { CLHS, CRHS }; 79482fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return ConstantFoldInstOperands(Instruction::Mul, CLHS->getType(), 795618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Ops, TD, TLI); 79682fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands } 79782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 79882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // Canonicalize the constant to the RHS. 79982fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands std::swap(Op0, Op1); 80082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands } 80182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 80282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // X * undef -> 0 803f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 80482fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return Constant::getNullValue(Op0->getType()); 80582fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 80682fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // X * 0 -> 0 80782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (match(Op1, m_Zero())) 80882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return Op1; 80982fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 81082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // X * 1 -> X 81182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (match(Op1, m_One())) 81282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return Op0; 81382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 8141895e98ef38afbe011575cc25f4889d96e37421bDuncan Sands // (X / Y) * Y -> X if the division is exact. 8151895e98ef38afbe011575cc25f4889d96e37421bDuncan Sands Value *X = 0, *Y = 0; 816aeaf3d484b4d4c35e8794378c4b6cfbbde718dd1Chris Lattner if ((match(Op0, m_IDiv(m_Value(X), m_Value(Y))) && Y == Op1) || // (X / Y) * Y 817aeaf3d484b4d4c35e8794378c4b6cfbbde718dd1Chris Lattner (match(Op1, m_IDiv(m_Value(X), m_Value(Y))) && Y == Op0)) { // Y * (X / Y) 81832a43cc0fc3cd42702d7859eaa58dd42f561a54dDuncan Sands PossiblyExactOperator *Div = 81932a43cc0fc3cd42702d7859eaa58dd42f561a54dDuncan Sands cast<PossiblyExactOperator>(Y == Op1 ? Op0 : Op1); 820c6ee9181a51fdfa3c07e1e53695681c55aa98ce4Chris Lattner if (Div->isExact()) 8211895e98ef38afbe011575cc25f4889d96e37421bDuncan Sands return X; 8221895e98ef38afbe011575cc25f4889d96e37421bDuncan Sands } 8231895e98ef38afbe011575cc25f4889d96e37421bDuncan Sands 8245413880654585f01ea9880f24f07f27c8da56ba8Nick Lewycky // i1 mul -> and. 82575d289ed6201e82718343d7a36d2a2fa082f6217Duncan Sands if (MaxRecurse && Op0->getType()->isIntegerTy(1)) 826618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyAndInst(Op0, Op1, TD, TLI, DT, MaxRecurse-1)) 82707f30fbd734069b80b90c6aeea0ae645ce3880c0Duncan Sands return V; 82882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 82982fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // Try some generic simplifications for associative operations. 830618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyAssociativeBinOp(Instruction::Mul, Op0, Op1, TD, TLI, DT, 83182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands MaxRecurse)) 83282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return V; 83382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 83482fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // Mul distributes over Add. Try some generic simplifications based on this. 83582fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (Value *V = ExpandBinOp(Instruction::Mul, Op0, Op1, Instruction::Add, 836618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT, MaxRecurse)) 83782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return V; 83882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 83982fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // If the operation is with the result of a select instruction, check whether 84082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // operating on either branch of the select always yields the same value. 84182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) 842618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = ThreadBinOpOverSelect(Instruction::Mul, Op0, Op1, TD, TLI, DT, 84382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands MaxRecurse)) 84482fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return V; 84582fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 84682fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // If the operation is with the result of a phi instruction, check whether 84782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // operating on all incoming values of the phi always yields the same value. 84882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (isa<PHINode>(Op0) || isa<PHINode>(Op1)) 849618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = ThreadBinOpOverPHI(Instruction::Mul, Op0, Op1, TD, TLI, DT, 85082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands MaxRecurse)) 85182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return V; 85282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 85382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return 0; 85482fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands} 85582fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 85682fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan SandsValue *llvm::SimplifyMulInst(Value *Op0, Value *Op1, const TargetData *TD, 857618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 85882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands const DominatorTree *DT) { 859618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ::SimplifyMulInst(Op0, Op1, TD, TLI, DT, RecursionLimit); 86082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands} 86182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 862593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands/// SimplifyDiv - Given operands for an SDiv or UDiv, see if we can 863593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands/// fold the result. If not, this returns null. 864479b4b9ef06dd84097202ffa6aea07913cdf651cAnders Carlssonstatic Value *SimplifyDiv(Instruction::BinaryOps Opcode, Value *Op0, Value *Op1, 865618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, const TargetLibraryInfo *TLI, 866618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT, unsigned MaxRecurse) { 867593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Constant *C0 = dyn_cast<Constant>(Op0)) { 868593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Constant *C1 = dyn_cast<Constant>(Op1)) { 869593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands Constant *Ops[] = { C0, C1 }; 870618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ConstantFoldInstOperands(Opcode, C0->getType(), Ops, TD, TLI); 871593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands } 872593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands } 873593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 874a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands bool isSigned = Opcode == Instruction::SDiv; 875a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands 876593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // X / undef -> undef 877f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 878593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return Op1; 879593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 880593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // undef / X -> 0 881f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op0, m_Undef())) 882593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return Constant::getNullValue(Op0->getType()); 883593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 884593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // 0 / X -> 0, we don't need to preserve faults! 885593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (match(Op0, m_Zero())) 886593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return Op0; 887593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 888593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // X / 1 -> X 889593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (match(Op1, m_One())) 890593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return Op0; 891593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 892593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Op0->getType()->isIntegerTy(1)) 893593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // It can't be division by zero, hence it must be division by one. 894593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return Op0; 895593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 896593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // X / X -> 1 897593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Op0 == Op1) 898593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return ConstantInt::get(Op0->getType(), 1); 899593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 900593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // (X * Y) / Y -> X if the multiplication does not overflow. 901593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands Value *X = 0, *Y = 0; 902593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (match(Op0, m_Mul(m_Value(X), m_Value(Y))) && (X == Op1 || Y == Op1)) { 903593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Y != Op1) std::swap(X, Y); // Ensure expression is (X * Y) / Y, Y = Op1 90432a43cc0fc3cd42702d7859eaa58dd42f561a54dDuncan Sands OverflowingBinaryOperator *Mul = cast<OverflowingBinaryOperator>(Op0); 9054b720718fbda1194f925e0a9d931bc220e8b0e3aDuncan Sands // If the Mul knows it does not overflow, then we are good to go. 9064b720718fbda1194f925e0a9d931bc220e8b0e3aDuncan Sands if ((isSigned && Mul->hasNoSignedWrap()) || 9074b720718fbda1194f925e0a9d931bc220e8b0e3aDuncan Sands (!isSigned && Mul->hasNoUnsignedWrap())) 9084b720718fbda1194f925e0a9d931bc220e8b0e3aDuncan Sands return X; 909593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // If X has the form X = A / Y then X * Y cannot overflow. 910593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (BinaryOperator *Div = dyn_cast<BinaryOperator>(X)) 911593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Div->getOpcode() == Opcode && Div->getOperand(1) == Y) 912593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return X; 913593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands } 914593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 915a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands // (X rem Y) / Y -> 0 916a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands if ((isSigned && match(Op0, m_SRem(m_Value(), m_Specific(Op1)))) || 917a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands (!isSigned && match(Op0, m_URem(m_Value(), m_Specific(Op1))))) 918a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands return Constant::getNullValue(Op0->getType()); 919a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands 920a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands // If the operation is with the result of a select instruction, check whether 921a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands // operating on either branch of the select always yields the same value. 922a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) 923618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = ThreadBinOpOverSelect(Opcode, Op0, Op1, TD, TLI, DT, 924618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier MaxRecurse)) 925a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands return V; 926a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands 927a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands // If the operation is with the result of a phi instruction, check whether 928a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands // operating on all incoming values of the phi always yields the same value. 929a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands if (isa<PHINode>(Op0) || isa<PHINode>(Op1)) 930618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = ThreadBinOpOverPHI(Opcode, Op0, Op1, TD, TLI, DT, 931618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier MaxRecurse)) 932a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands return V; 933a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands 934593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return 0; 935593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands} 936593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 937593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands/// SimplifySDivInst - Given operands for an SDiv, see if we can 938593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands/// fold the result. If not, this returns null. 939593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sandsstatic Value *SimplifySDivInst(Value *Op0, Value *Op1, const TargetData *TD, 940618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 941593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands const DominatorTree *DT, unsigned MaxRecurse) { 942618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyDiv(Instruction::SDiv, Op0, Op1, TD, TLI, DT, 943618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier MaxRecurse)) 944593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return V; 945593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 946593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return 0; 947593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands} 948593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 949593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan SandsValue *llvm::SimplifySDivInst(Value *Op0, Value *Op1, const TargetData *TD, 950618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 9511fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel const DominatorTree *DT) { 952618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ::SimplifySDivInst(Op0, Op1, TD, TLI, DT, RecursionLimit); 953593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands} 954593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 955593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands/// SimplifyUDivInst - Given operands for a UDiv, see if we can 956593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands/// fold the result. If not, this returns null. 957593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sandsstatic Value *SimplifyUDivInst(Value *Op0, Value *Op1, const TargetData *TD, 958618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 959593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands const DominatorTree *DT, unsigned MaxRecurse) { 960618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyDiv(Instruction::UDiv, Op0, Op1, TD, TLI, DT, 961618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier MaxRecurse)) 962593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return V; 963593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 964593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return 0; 965593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands} 966593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 967593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan SandsValue *llvm::SimplifyUDivInst(Value *Op0, Value *Op1, const TargetData *TD, 968618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 9691fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel const DominatorTree *DT) { 970618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ::SimplifyUDivInst(Op0, Op1, TD, TLI, DT, RecursionLimit); 971593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands} 972593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 973f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sandsstatic Value *SimplifyFDivInst(Value *Op0, Value *Op1, const TargetData *, 974618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *, 975f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands const DominatorTree *, unsigned) { 9761fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel // undef / X -> undef (the undef could be a snan). 977f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op0, m_Undef())) 9781fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel return Op0; 9791fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel 9801fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel // X / undef -> undef 981f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 9821fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel return Op1; 9831fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel 9841fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel return 0; 9851fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel} 9861fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel 9871fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van BommelValue *llvm::SimplifyFDivInst(Value *Op0, Value *Op1, const TargetData *TD, 988618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 9891fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel const DominatorTree *DT) { 990618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ::SimplifyFDivInst(Op0, Op1, TD, TLI, DT, RecursionLimit); 9911fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel} 9921fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel 993f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands/// SimplifyRem - Given operands for an SRem or URem, see if we can 994f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands/// fold the result. If not, this returns null. 995f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sandsstatic Value *SimplifyRem(Instruction::BinaryOps Opcode, Value *Op0, Value *Op1, 996618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, const TargetLibraryInfo *TLI, 997618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT, unsigned MaxRecurse) { 998f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (Constant *C0 = dyn_cast<Constant>(Op0)) { 999f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (Constant *C1 = dyn_cast<Constant>(Op1)) { 1000f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands Constant *Ops[] = { C0, C1 }; 1001618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ConstantFoldInstOperands(Opcode, C0->getType(), Ops, TD, TLI); 1002f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands } 1003f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands } 1004f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1005f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // X % undef -> undef 1006f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op1, m_Undef())) 1007f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Op1; 1008f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1009f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // undef % X -> 0 1010f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op0, m_Undef())) 1011f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Constant::getNullValue(Op0->getType()); 1012f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1013f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // 0 % X -> 0, we don't need to preserve faults! 1014f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op0, m_Zero())) 1015f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Op0; 1016f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1017f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // X % 0 -> undef, we don't need to preserve faults! 1018f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op1, m_Zero())) 1019f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return UndefValue::get(Op0->getType()); 1020f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1021f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // X % 1 -> 0 1022f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op1, m_One())) 1023f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Constant::getNullValue(Op0->getType()); 1024f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1025f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (Op0->getType()->isIntegerTy(1)) 1026f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // It can't be remainder by zero, hence it must be remainder by one. 1027f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Constant::getNullValue(Op0->getType()); 1028f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1029f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // X % X -> 0 1030f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (Op0 == Op1) 1031f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Constant::getNullValue(Op0->getType()); 1032f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1033f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // If the operation is with the result of a select instruction, check whether 1034f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // operating on either branch of the select always yields the same value. 1035f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) 1036618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = ThreadBinOpOverSelect(Opcode, Op0, Op1, TD, TLI, DT, MaxRecurse)) 1037f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return V; 1038f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1039f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // If the operation is with the result of a phi instruction, check whether 1040f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // operating on all incoming values of the phi always yields the same value. 1041f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (isa<PHINode>(Op0) || isa<PHINode>(Op1)) 1042618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = ThreadBinOpOverPHI(Opcode, Op0, Op1, TD, TLI, DT, MaxRecurse)) 1043f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return V; 1044f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1045f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return 0; 1046f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1047f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1048f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands/// SimplifySRemInst - Given operands for an SRem, see if we can 1049f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands/// fold the result. If not, this returns null. 1050f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sandsstatic Value *SimplifySRemInst(Value *Op0, Value *Op1, const TargetData *TD, 1051618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1052618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT, 1053618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier unsigned MaxRecurse) { 1054618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyRem(Instruction::SRem, Op0, Op1, TD, TLI, DT, MaxRecurse)) 1055f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return V; 1056f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1057f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return 0; 1058f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1059f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1060f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan SandsValue *llvm::SimplifySRemInst(Value *Op0, Value *Op1, const TargetData *TD, 1061618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1062f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands const DominatorTree *DT) { 1063618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ::SimplifySRemInst(Op0, Op1, TD, TLI, DT, RecursionLimit); 1064f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1065f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1066f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands/// SimplifyURemInst - Given operands for a URem, see if we can 1067f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands/// fold the result. If not, this returns null. 1068f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sandsstatic Value *SimplifyURemInst(Value *Op0, Value *Op1, const TargetData *TD, 1069618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1070618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT, 1071618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier unsigned MaxRecurse) { 1072618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyRem(Instruction::URem, Op0, Op1, TD, TLI, DT, MaxRecurse)) 1073f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return V; 1074f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1075f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return 0; 1076f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1077f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1078f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan SandsValue *llvm::SimplifyURemInst(Value *Op0, Value *Op1, const TargetData *TD, 1079618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1080f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands const DominatorTree *DT) { 1081618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ::SimplifyURemInst(Op0, Op1, TD, TLI, DT, RecursionLimit); 1082f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1083f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1084f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sandsstatic Value *SimplifyFRemInst(Value *Op0, Value *Op1, const TargetData *, 1085618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *, 1086618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *, 1087618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier unsigned) { 1088f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // undef % X -> undef (the undef could be a snan). 1089f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op0, m_Undef())) 1090f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Op0; 1091f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1092f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // X % undef -> undef 1093f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op1, m_Undef())) 1094f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Op1; 1095f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1096f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return 0; 1097f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1098f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1099f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan SandsValue *llvm::SimplifyFRemInst(Value *Op0, Value *Op1, const TargetData *TD, 1100618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1101f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands const DominatorTree *DT) { 1102618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ::SimplifyFRemInst(Op0, Op1, TD, TLI, DT, RecursionLimit); 1103f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1104f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1105cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands/// SimplifyShift - Given operands for an Shl, LShr or AShr, see if we can 1106c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands/// fold the result. If not, this returns null. 1107cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sandsstatic Value *SimplifyShift(unsigned Opcode, Value *Op0, Value *Op1, 1108618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, const TargetLibraryInfo *TLI, 1109618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT, unsigned MaxRecurse) { 1110c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands if (Constant *C0 = dyn_cast<Constant>(Op0)) { 1111c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands if (Constant *C1 = dyn_cast<Constant>(Op1)) { 1112c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands Constant *Ops[] = { C0, C1 }; 1113618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ConstantFoldInstOperands(Opcode, C0->getType(), Ops, TD, TLI); 1114c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands } 1115c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands } 1116c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1117cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // 0 shift by X -> 0 1118c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands if (match(Op0, m_Zero())) 1119c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return Op0; 1120c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1121cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // X shift by 0 -> X 1122c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands if (match(Op1, m_Zero())) 1123c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return Op0; 1124c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1125cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // X shift by undef -> undef because it may shift by the bitwidth. 1126f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 1127c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return Op1; 1128c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1129c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands // Shifting by the bitwidth or more is undefined. 1130c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands if (ConstantInt *CI = dyn_cast<ConstantInt>(Op1)) 1131c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands if (CI->getValue().getLimitedValue() >= 1132c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands Op0->getType()->getScalarSizeInBits()) 1133c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return UndefValue::get(Op0->getType()); 1134c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1135cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // If the operation is with the result of a select instruction, check whether 1136cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // operating on either branch of the select always yields the same value. 1137cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) 1138618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = ThreadBinOpOverSelect(Opcode, Op0, Op1, TD, TLI, DT, MaxRecurse)) 1139cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return V; 1140cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands 1141cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // If the operation is with the result of a phi instruction, check whether 1142cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // operating on all incoming values of the phi always yields the same value. 1143cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands if (isa<PHINode>(Op0) || isa<PHINode>(Op1)) 1144618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = ThreadBinOpOverPHI(Opcode, Op0, Op1, TD, TLI, DT, MaxRecurse)) 1145cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return V; 1146cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands 1147cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return 0; 1148cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands} 1149cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands 1150cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands/// SimplifyShlInst - Given operands for an Shl, see if we can 1151cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands/// fold the result. If not, this returns null. 115281a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattnerstatic Value *SimplifyShlInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, 1153618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, 1154618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1155618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT, unsigned MaxRecurse) { 1156618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyShift(Instruction::Shl, Op0, Op1, TD, TLI, DT, MaxRecurse)) 1157cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return V; 1158cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands 1159cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // undef << X -> 0 1160f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op0, m_Undef())) 1161cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return Constant::getNullValue(Op0->getType()); 1162cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands 116381a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner // (X >> A) << A -> X 116481a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Value *X; 116581a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner if (match(Op0, m_Shr(m_Value(X), m_Specific(Op1))) && 116681a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner cast<PossiblyExactOperator>(Op0)->isExact()) 116781a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner return X; 1168c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return 0; 1169c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands} 1170c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 117181a0dc911586c77421c2255aa417dc9b350b9e20Chris LattnerValue *llvm::SimplifyShlInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, 1172618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, const TargetLibraryInfo *TLI, 1173618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT) { 1174618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ::SimplifyShlInst(Op0, Op1, isNSW, isNUW, TD, TLI, DT, RecursionLimit); 1175c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands} 1176c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1177c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands/// SimplifyLShrInst - Given operands for an LShr, see if we can 1178c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands/// fold the result. If not, this returns null. 117981a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattnerstatic Value *SimplifyLShrInst(Value *Op0, Value *Op1, bool isExact, 1180618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, 1181618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1182618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT, 118381a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner unsigned MaxRecurse) { 1184618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyShift(Instruction::LShr, Op0, Op1, TD, TLI, DT, MaxRecurse)) 1185cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return V; 1186c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1187c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands // undef >>l X -> 0 1188f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op0, m_Undef())) 1189c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return Constant::getNullValue(Op0->getType()); 1190c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 119181a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner // (X << A) >> A -> X 119281a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Value *X; 119381a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner if (match(Op0, m_Shl(m_Value(X), m_Specific(Op1))) && 119481a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner cast<OverflowingBinaryOperator>(Op0)->hasNoUnsignedWrap()) 119581a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner return X; 119652fb846578714d14bbde9b28884a6a8729217677Duncan Sands 1197c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return 0; 1198c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands} 1199c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 120081a0dc911586c77421c2255aa417dc9b350b9e20Chris LattnerValue *llvm::SimplifyLShrInst(Value *Op0, Value *Op1, bool isExact, 1201618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, 1202618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1203618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT) { 1204618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ::SimplifyLShrInst(Op0, Op1, isExact, TD, TLI, DT, RecursionLimit); 1205c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands} 1206c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1207c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands/// SimplifyAShrInst - Given operands for an AShr, see if we can 1208c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands/// fold the result. If not, this returns null. 120981a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattnerstatic Value *SimplifyAShrInst(Value *Op0, Value *Op1, bool isExact, 1210618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, 1211618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1212618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT, 121381a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner unsigned MaxRecurse) { 1214618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyShift(Instruction::AShr, Op0, Op1, TD, TLI, DT, MaxRecurse)) 1215cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return V; 1216c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1217c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands // all ones >>a X -> all ones 1218c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands if (match(Op0, m_AllOnes())) 1219c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return Op0; 1220c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1221c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands // undef >>a X -> all ones 1222f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op0, m_Undef())) 1223c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return Constant::getAllOnesValue(Op0->getType()); 1224c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 122581a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner // (X << A) >> A -> X 122681a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Value *X; 122781a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner if (match(Op0, m_Shl(m_Value(X), m_Specific(Op1))) && 122881a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner cast<OverflowingBinaryOperator>(Op0)->hasNoSignedWrap()) 122981a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner return X; 123052fb846578714d14bbde9b28884a6a8729217677Duncan Sands 1231c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return 0; 1232c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands} 1233c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 123481a0dc911586c77421c2255aa417dc9b350b9e20Chris LattnerValue *llvm::SimplifyAShrInst(Value *Op0, Value *Op1, bool isExact, 1235618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, 1236618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1237618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT) { 1238618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ::SimplifyAShrInst(Op0, Op1, isExact, TD, TLI, DT, RecursionLimit); 1239c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands} 1240c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 12418aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner/// SimplifyAndInst - Given operands for an And, see if we can 12428aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner/// fold the result. If not, this returns null. 1243618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosierstatic Value *SimplifyAndInst(Value *Op0, Value *Op1, const TargetData *TD, 1244618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1245618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT, 1246618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier unsigned MaxRecurse) { 12478aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 12488aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 12498aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner Constant *Ops[] = { CLHS, CRHS }; 1250d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return ConstantFoldInstOperands(Instruction::And, CLHS->getType(), 1251618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Ops, TD, TLI); 1252d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 125312a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1254d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // Canonicalize the constant to the RHS. 1255d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner std::swap(Op0, Op1); 1256d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 125712a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1258d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X & undef -> 0 1259f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 1260d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Constant::getNullValue(Op0->getType()); 126112a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1262d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X & X = X 1263124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (Op0 == Op1) 1264d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 126512a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 12662b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // X & 0 = 0 12672b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (match(Op1, m_Zero())) 1268d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op1; 126912a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 12702b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // X & -1 = X 12712b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (match(Op1, m_AllOnes())) 12722b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return Op0; 127312a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1274d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // A & ~A = ~A & A = 0 127581a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner if (match(Op0, m_Not(m_Specific(Op1))) || 127681a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner match(Op1, m_Not(m_Specific(Op0)))) 1277d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Constant::getNullValue(Op0->getType()); 127812a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1279d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // (A | ?) & A = A 128081a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Value *A = 0, *B = 0; 1281d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (match(Op0, m_Or(m_Value(A), m_Value(B))) && 1282124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands (A == Op1 || B == Op1)) 1283d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op1; 128412a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1285d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // A & (A | ?) = A 1286d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (match(Op1, m_Or(m_Value(A), m_Value(B))) && 1287124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands (A == Op0 || B == Op0)) 1288d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 128912a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1290dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands // A & (-A) = A if A is a power of two or zero. 1291dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands if (match(Op0, m_Neg(m_Specific(Op1))) || 1292dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands match(Op1, m_Neg(m_Specific(Op0)))) { 1293dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands if (isPowerOfTwo(Op0, TD, /*OrZero*/true)) 1294dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands return Op0; 1295dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands if (isPowerOfTwo(Op1, TD, /*OrZero*/true)) 1296dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands return Op1; 1297dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands } 1298dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands 1299566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Try some generic simplifications for associative operations. 1300618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyAssociativeBinOp(Instruction::And, Op0, Op1, TD, TLI, 1301618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier DT, MaxRecurse)) 1302566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return V; 13036844c8ea5a67e551be7106d6b7b9e1a64eecbe51Benjamin Kramer 13043421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // And distributes over Or. Try some generic simplifications based on this. 13053421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = ExpandBinOp(Instruction::And, Op0, Op1, Instruction::Or, 1306618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT, MaxRecurse)) 13073421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 13083421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 13093421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // And distributes over Xor. Try some generic simplifications based on this. 13103421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = ExpandBinOp(Instruction::And, Op0, Op1, Instruction::Xor, 1311618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT, MaxRecurse)) 13123421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 13133421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 13143421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Or distributes over And. Try some generic simplifications based on this. 13153421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = FactorizeBinOp(Instruction::And, Op0, Op1, Instruction::Or, 1316618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT, MaxRecurse)) 13173421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 13183421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1319b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // If the operation is with the result of a select instruction, check whether 1320b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // operating on either branch of the select always yields the same value. 13210312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) 1322618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = ThreadBinOpOverSelect(Instruction::And, Op0, Op1, TD, TLI, 1323618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier DT, MaxRecurse)) 1324a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return V; 1325a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 1326a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the operation is with the result of a phi instruction, check whether 1327a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // operating on all incoming values of the phi always yields the same value. 13280312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<PHINode>(Op0) || isa<PHINode>(Op1)) 1329618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = ThreadBinOpOverPHI(Instruction::And, Op0, Op1, TD, TLI, DT, 13300312a93693abc2eb682b2b101c889959888fd883Duncan Sands MaxRecurse)) 1331b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return V; 1332b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 1333d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return 0; 1334d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner} 13359f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 13361845009290e4d804ad377927bd8a08cca3036adcDuncan SandsValue *llvm::SimplifyAndInst(Value *Op0, Value *Op1, const TargetData *TD, 1337618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 13381845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const DominatorTree *DT) { 1339618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ::SimplifyAndInst(Op0, Op1, TD, TLI, DT, RecursionLimit); 1340a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 1341a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 1342d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner/// SimplifyOrInst - Given operands for an Or, see if we can 13439f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner/// fold the result. If not, this returns null. 1344618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosierstatic Value *SimplifyOrInst(Value *Op0, Value *Op1, const TargetData *TD, 1345618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 13461845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const DominatorTree *DT, unsigned MaxRecurse) { 1347d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 1348d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 1349d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Constant *Ops[] = { CLHS, CRHS }; 1350d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return ConstantFoldInstOperands(Instruction::Or, CLHS->getType(), 1351618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Ops, TD, TLI); 1352d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 135312a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1354d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // Canonicalize the constant to the RHS. 1355d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner std::swap(Op0, Op1); 1356d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 135712a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1358d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X | undef -> -1 1359f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 1360d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Constant::getAllOnesValue(Op0->getType()); 136112a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1362d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X | X = X 1363124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (Op0 == Op1) 1364d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 1365d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 13662b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // X | 0 = X 13672b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (match(Op1, m_Zero())) 1368d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 136912a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 13702b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // X | -1 = -1 13712b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (match(Op1, m_AllOnes())) 13722b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return Op1; 137312a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1374d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // A | ~A = ~A | A = -1 137581a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner if (match(Op0, m_Not(m_Specific(Op1))) || 137681a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner match(Op1, m_Not(m_Specific(Op0)))) 1377d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Constant::getAllOnesValue(Op0->getType()); 137812a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1379d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // (A & ?) | A = A 138081a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Value *A = 0, *B = 0; 1381d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (match(Op0, m_And(m_Value(A), m_Value(B))) && 1382124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands (A == Op1 || B == Op1)) 1383d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op1; 138412a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1385d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // A | (A & ?) = A 1386d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (match(Op1, m_And(m_Value(A), m_Value(B))) && 1387124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands (A == Op0 || B == Op0)) 1388d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 138912a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 139038f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer // ~(A & ?) | A = -1 139138f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer if (match(Op0, m_Not(m_And(m_Value(A), m_Value(B)))) && 139238f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer (A == Op1 || B == Op1)) 139338f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer return Constant::getAllOnesValue(Op1->getType()); 139438f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer 139538f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer // A | ~(A & ?) = -1 139638f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer if (match(Op1, m_Not(m_And(m_Value(A), m_Value(B)))) && 139738f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer (A == Op0 || B == Op0)) 139838f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer return Constant::getAllOnesValue(Op0->getType()); 139938f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer 1400566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Try some generic simplifications for associative operations. 1401618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyAssociativeBinOp(Instruction::Or, Op0, Op1, TD, TLI, 1402618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier DT, MaxRecurse)) 1403566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return V; 14046844c8ea5a67e551be7106d6b7b9e1a64eecbe51Benjamin Kramer 14053421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Or distributes over And. Try some generic simplifications based on this. 1406618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = ExpandBinOp(Instruction::Or, Op0, Op1, Instruction::And, TD, 1407618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TLI, DT, MaxRecurse)) 14083421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 14093421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 14103421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // And distributes over Or. Try some generic simplifications based on this. 14113421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = FactorizeBinOp(Instruction::Or, Op0, Op1, Instruction::And, 1412618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT, MaxRecurse)) 14133421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 14143421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1415b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // If the operation is with the result of a select instruction, check whether 1416b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // operating on either branch of the select always yields the same value. 14170312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) 1418618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = ThreadBinOpOverSelect(Instruction::Or, Op0, Op1, TD, TLI, DT, 14190312a93693abc2eb682b2b101c889959888fd883Duncan Sands MaxRecurse)) 1420a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return V; 1421a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 1422a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the operation is with the result of a phi instruction, check whether 1423a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // operating on all incoming values of the phi always yields the same value. 14240312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<PHINode>(Op0) || isa<PHINode>(Op1)) 1425618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = ThreadBinOpOverPHI(Instruction::Or, Op0, Op1, TD, TLI, DT, 14260312a93693abc2eb682b2b101c889959888fd883Duncan Sands MaxRecurse)) 1427b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return V; 1428b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 14299f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner return 0; 14309f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner} 14319f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 14321845009290e4d804ad377927bd8a08cca3036adcDuncan SandsValue *llvm::SimplifyOrInst(Value *Op0, Value *Op1, const TargetData *TD, 1433618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 14341845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const DominatorTree *DT) { 1435618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ::SimplifyOrInst(Op0, Op1, TD, TLI, DT, RecursionLimit); 1436a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 1437d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 14382b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands/// SimplifyXorInst - Given operands for a Xor, see if we can 14392b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands/// fold the result. If not, this returns null. 14402b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sandsstatic Value *SimplifyXorInst(Value *Op0, Value *Op1, const TargetData *TD, 1441618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 14422b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands const DominatorTree *DT, unsigned MaxRecurse) { 14432b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 14442b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 14452b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands Constant *Ops[] = { CLHS, CRHS }; 14462b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return ConstantFoldInstOperands(Instruction::Xor, CLHS->getType(), 1447618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Ops, TD, TLI); 14482b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands } 14492b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 14502b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // Canonicalize the constant to the RHS. 14512b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands std::swap(Op0, Op1); 14522b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands } 14532b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 14542b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // A ^ undef -> undef 1455f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 1456f8b1a5ea9602bb65a5cf59d3d34f2851a08cdc3eDuncan Sands return Op1; 14572b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 14582b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // A ^ 0 = A 14592b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (match(Op1, m_Zero())) 14602b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return Op0; 14612b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 1462f23d4adbfaf870d5fa67c6bff0da7891d3a98f9dEli Friedman // A ^ A = 0 1463f23d4adbfaf870d5fa67c6bff0da7891d3a98f9dEli Friedman if (Op0 == Op1) 1464f23d4adbfaf870d5fa67c6bff0da7891d3a98f9dEli Friedman return Constant::getNullValue(Op0->getType()); 1465f23d4adbfaf870d5fa67c6bff0da7891d3a98f9dEli Friedman 14662b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // A ^ ~A = ~A ^ A = -1 146781a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner if (match(Op0, m_Not(m_Specific(Op1))) || 146881a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner match(Op1, m_Not(m_Specific(Op0)))) 14692b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return Constant::getAllOnesValue(Op0->getType()); 14702b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 1471566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Try some generic simplifications for associative operations. 1472618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyAssociativeBinOp(Instruction::Xor, Op0, Op1, TD, TLI, 1473618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier DT, MaxRecurse)) 1474566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return V; 14752b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 14763421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // And distributes over Xor. Try some generic simplifications based on this. 14773421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = FactorizeBinOp(Instruction::Xor, Op0, Op1, Instruction::And, 1478618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT, MaxRecurse)) 14793421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 14803421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 148187689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // Threading Xor over selects and phi nodes is pointless, so don't bother. 148287689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // Threading over the select in "A ^ select(cond, B, C)" means evaluating 148387689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // "A^B" and "A^C" and seeing if they are equal; but they are equal if and 148487689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // only if B and C are equal. If B and C are equal then (since we assume 148587689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // that operands have already been simplified) "select(cond, B, C)" should 148687689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // have been simplified to the common value of B and C already. Analysing 148787689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // "A^B" and "A^C" thus gains nothing, but costs compile time. Similarly 148887689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // for threading over phi nodes. 14892b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 14902b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return 0; 14912b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands} 14922b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 14932b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan SandsValue *llvm::SimplifyXorInst(Value *Op0, Value *Op1, const TargetData *TD, 1494618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 14952b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands const DominatorTree *DT) { 1496618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ::SimplifyXorInst(Op0, Op1, TD, TLI, DT, RecursionLimit); 14972b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands} 14982b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 1499db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattnerstatic Type *GetCompareTy(Value *Op) { 1500210c5d4880b525e064088b6fec713260128c16ebChris Lattner return CmpInst::makeCmpResultType(Op->getType()); 1501210c5d4880b525e064088b6fec713260128c16ebChris Lattner} 1502210c5d4880b525e064088b6fec713260128c16ebChris Lattner 1503e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands/// ExtractEquivalentCondition - Rummage around inside V looking for something 1504e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands/// equivalent to the comparison "LHS Pred RHS". Return such a value if found, 1505e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands/// otherwise return null. Helper function for analyzing max/min idioms. 1506e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sandsstatic Value *ExtractEquivalentCondition(Value *V, CmpInst::Predicate Pred, 1507e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands Value *LHS, Value *RHS) { 1508e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands SelectInst *SI = dyn_cast<SelectInst>(V); 1509e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (!SI) 1510e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return 0; 1511e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands CmpInst *Cmp = dyn_cast<CmpInst>(SI->getCondition()); 1512e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (!Cmp) 1513e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return 0; 1514e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands Value *CmpLHS = Cmp->getOperand(0), *CmpRHS = Cmp->getOperand(1); 1515e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Pred == Cmp->getPredicate() && LHS == CmpLHS && RHS == CmpRHS) 1516e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return Cmp; 1517e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Pred == CmpInst::getSwappedPredicate(Cmp->getPredicate()) && 1518e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands LHS == CmpRHS && RHS == CmpLHS) 1519e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return Cmp; 1520e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return 0; 1521e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands} 1522e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands 15239dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// SimplifyICmpInst - Given operands for an ICmpInst, see if we can 15249dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// fold the result. If not, this returns null. 1525a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS, 1526618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, 1527618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1528618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT, 15291845009290e4d804ad377927bd8a08cca3036adcDuncan Sands unsigned MaxRecurse) { 15309f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner CmpInst::Predicate Pred = (CmpInst::Predicate)Predicate; 15319dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner assert(CmpInst::isIntPredicate(Pred) && "Not an integer compare!"); 153212a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1533d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(LHS)) { 15348f73deaa8732a556046bf4ac6207be55972e3b74Chris Lattner if (Constant *CRHS = dyn_cast<Constant>(RHS)) 1535618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ConstantFoldCompareInstOperands(Pred, CLHS, CRHS, TD, TLI); 1536d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 1537d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // If we have a constant, make sure it is on the RHS. 1538d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner std::swap(LHS, RHS); 1539d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Pred = CmpInst::getSwappedPredicate(Pred); 1540d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 154112a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1542db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *ITy = GetCompareTy(LHS); // The return type. 1543db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *OpTy = LHS->getType(); // The operand type. 154412a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1545210c5d4880b525e064088b6fec713260128c16ebChris Lattner // icmp X, X -> true/false 1546c8e14b3d37b80abb6adb4b831af0452d9ecbf2b2Chris Lattner // X icmp undef -> true/false. For example, icmp ugt %X, undef -> false 1547c8e14b3d37b80abb6adb4b831af0452d9ecbf2b2Chris Lattner // because X could be 0. 1548124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (LHS == RHS || isa<UndefValue>(RHS)) 1549210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(ITy, CmpInst::isTrueWhenEqual(Pred)); 155012a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 15516dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // Special case logic when the operands have i1 type. 155266d004ef708642bbdc38fd761507f2e9ee3970cdNick Lewycky if (OpTy->getScalarType()->isIntegerTy(1)) { 15536dc91253ab1872e118b08511a09d5c934988354eDuncan Sands switch (Pred) { 15546dc91253ab1872e118b08511a09d5c934988354eDuncan Sands default: break; 15556dc91253ab1872e118b08511a09d5c934988354eDuncan Sands case ICmpInst::ICMP_EQ: 15566dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // X == 1 -> X 15576dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (match(RHS, m_One())) 15586dc91253ab1872e118b08511a09d5c934988354eDuncan Sands return LHS; 15596dc91253ab1872e118b08511a09d5c934988354eDuncan Sands break; 15606dc91253ab1872e118b08511a09d5c934988354eDuncan Sands case ICmpInst::ICMP_NE: 15616dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // X != 0 -> X 15626dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (match(RHS, m_Zero())) 15636dc91253ab1872e118b08511a09d5c934988354eDuncan Sands return LHS; 15646dc91253ab1872e118b08511a09d5c934988354eDuncan Sands break; 15656dc91253ab1872e118b08511a09d5c934988354eDuncan Sands case ICmpInst::ICMP_UGT: 15666dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // X >u 0 -> X 15676dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (match(RHS, m_Zero())) 15686dc91253ab1872e118b08511a09d5c934988354eDuncan Sands return LHS; 15696dc91253ab1872e118b08511a09d5c934988354eDuncan Sands break; 15706dc91253ab1872e118b08511a09d5c934988354eDuncan Sands case ICmpInst::ICMP_UGE: 15716dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // X >=u 1 -> X 15726dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (match(RHS, m_One())) 15736dc91253ab1872e118b08511a09d5c934988354eDuncan Sands return LHS; 15746dc91253ab1872e118b08511a09d5c934988354eDuncan Sands break; 15756dc91253ab1872e118b08511a09d5c934988354eDuncan Sands case ICmpInst::ICMP_SLT: 15766dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // X <s 0 -> X 15776dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (match(RHS, m_Zero())) 15786dc91253ab1872e118b08511a09d5c934988354eDuncan Sands return LHS; 15796dc91253ab1872e118b08511a09d5c934988354eDuncan Sands break; 15806dc91253ab1872e118b08511a09d5c934988354eDuncan Sands case ICmpInst::ICMP_SLE: 15816dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // X <=s -1 -> X 15826dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (match(RHS, m_One())) 15836dc91253ab1872e118b08511a09d5c934988354eDuncan Sands return LHS; 15846dc91253ab1872e118b08511a09d5c934988354eDuncan Sands break; 15856dc91253ab1872e118b08511a09d5c934988354eDuncan Sands } 15866dc91253ab1872e118b08511a09d5c934988354eDuncan Sands } 158712a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1588d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands // icmp <alloca*>, <global/alloca*/null> - Different stack variables have 1589d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands // different addresses, and what's more the address of a stack variable is 1590d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands // never null or equal to the address of a global. Note that generalizing 1591d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands // to the case where LHS is a global variable address or null is pointless, 1592d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands // since if both LHS and RHS are constants then we already constant folded 1593d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands // the compare, and if only one of them is then we moved it to RHS already. 1594d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (isa<AllocaInst>(LHS) && (isa<GlobalValue>(RHS) || isa<AllocaInst>(RHS) || 1595d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands isa<ConstantPointerNull>(RHS))) 159658bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky // We already know that LHS != RHS. 1597d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands return ConstantInt::get(ITy, CmpInst::isFalseWhenEqual(Pred)); 1598d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands 1599d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands // If we are comparing with zero then try hard since this is a common case. 1600d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (match(RHS, m_Zero())) { 1601d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands bool LHSKnownNonNegative, LHSKnownNegative; 1602d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands switch (Pred) { 1603d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands default: 1604d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands assert(false && "Unknown ICmp predicate!"); 1605d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_ULT: 1606f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 1607d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_UGE: 1608f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 1609d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_EQ: 1610d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_ULE: 1611d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (isKnownNonZero(LHS, TD)) 1612f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 1613d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands break; 1614d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_NE: 1615d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_UGT: 1616d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (isKnownNonZero(LHS, TD)) 1617f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 1618d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands break; 1619d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_SLT: 1620d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, TD); 1621d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNegative) 1622f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 1623d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNonNegative) 1624f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 1625d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands break; 1626d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_SLE: 1627d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, TD); 1628d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNegative) 1629f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 1630d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNonNegative && isKnownNonZero(LHS, TD)) 1631f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 1632d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands break; 1633d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_SGE: 1634d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, TD); 1635d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNegative) 1636f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 1637d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNonNegative) 1638f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 1639d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands break; 1640d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_SGT: 1641d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, TD); 1642d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNegative) 1643f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 1644d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNonNegative && isKnownNonZero(LHS, TD)) 1645f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 1646d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands break; 1647d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands } 1648d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands } 1649d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands 1650d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands // See if we are doing a comparison with a constant integer. 1651210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) { 16523a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // Rule out tautological comparisons (eg., ult 0 or uge 0). 16533a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky ConstantRange RHS_CR = ICmpInst::makeConstantRange(Pred, CI->getValue()); 16543a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (RHS_CR.isEmptySet()) 16553a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky return ConstantInt::getFalse(CI->getContext()); 16563a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (RHS_CR.isFullSet()) 16573a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky return ConstantInt::getTrue(CI->getContext()); 16583a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky 16593a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // Many binary operators with constant RHS have easy to compute constant 16603a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // range. Use them to check whether the comparison is a tautology. 16613a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky uint32_t Width = CI->getBitWidth(); 16623a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt Lower = APInt(Width, 0); 16633a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt Upper = APInt(Width, 0); 16643a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky ConstantInt *CI2; 16653a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (match(LHS, m_URem(m_Value(), m_ConstantInt(CI2)))) { 16663a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'urem x, CI2' produces [0, CI2). 16673a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = CI2->getValue(); 16683a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_SRem(m_Value(), m_ConstantInt(CI2)))) { 16693a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'srem x, CI2' produces (-|CI2|, |CI2|). 16703a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = CI2->getValue().abs(); 16713a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Lower = (-Upper) + 1; 1672c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands } else if (match(LHS, m_UDiv(m_ConstantInt(CI2), m_Value()))) { 1673c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands // 'udiv CI2, x' produces [0, CI2]. 16747781ae5be570940178295f6f808215089a3fe411Eli Friedman Upper = CI2->getValue() + 1; 16753a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_UDiv(m_Value(), m_ConstantInt(CI2)))) { 16763a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'udiv x, CI2' produces [0, UINT_MAX / CI2]. 16773a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt NegOne = APInt::getAllOnesValue(Width); 16783a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (!CI2->isZero()) 16793a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = NegOne.udiv(CI2->getValue()) + 1; 16803a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_SDiv(m_Value(), m_ConstantInt(CI2)))) { 16813a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'sdiv x, CI2' produces [INT_MIN / CI2, INT_MAX / CI2]. 16823a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt IntMin = APInt::getSignedMinValue(Width); 16833a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt IntMax = APInt::getSignedMaxValue(Width); 16843a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt Val = CI2->getValue().abs(); 16853a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (!Val.isMinValue()) { 16863a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Lower = IntMin.sdiv(Val); 16873a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = IntMax.sdiv(Val) + 1; 16883a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } 16893a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_LShr(m_Value(), m_ConstantInt(CI2)))) { 16903a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'lshr x, CI2' produces [0, UINT_MAX >> CI2]. 16913a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt NegOne = APInt::getAllOnesValue(Width); 16923a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (CI2->getValue().ult(Width)) 16933a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = NegOne.lshr(CI2->getValue()) + 1; 16943a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_AShr(m_Value(), m_ConstantInt(CI2)))) { 16953a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'ashr x, CI2' produces [INT_MIN >> CI2, INT_MAX >> CI2]. 16963a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt IntMin = APInt::getSignedMinValue(Width); 16973a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt IntMax = APInt::getSignedMaxValue(Width); 16983a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (CI2->getValue().ult(Width)) { 16993a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Lower = IntMin.ashr(CI2->getValue()); 17003a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = IntMax.ashr(CI2->getValue()) + 1; 17013a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } 17023a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_Or(m_Value(), m_ConstantInt(CI2)))) { 17033a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'or x, CI2' produces [CI2, UINT_MAX]. 17043a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Lower = CI2->getValue(); 17053a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_And(m_Value(), m_ConstantInt(CI2)))) { 17063a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'and x, CI2' produces [0, CI2]. 17073a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = CI2->getValue() + 1; 17083a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } 17093a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (Lower != Upper) { 17103a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky ConstantRange LHS_CR = ConstantRange(Lower, Upper); 17113a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (RHS_CR.contains(LHS_CR)) 17123a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky return ConstantInt::getTrue(RHS->getContext()); 17133a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (RHS_CR.inverse().contains(LHS_CR)) 17143a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky return ConstantInt::getFalse(RHS->getContext()); 1715210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 1716210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 17171ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands 17189d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Compare of cast, for example (zext X) != 0 -> X != 0 17199d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (isa<CastInst>(LHS) && (isa<Constant>(RHS) || isa<CastInst>(RHS))) { 17209d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Instruction *LI = cast<CastInst>(LHS); 17219d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Value *SrcOp = LI->getOperand(0); 1722db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *SrcTy = SrcOp->getType(); 1723db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *DstTy = LI->getType(); 17249d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 17259d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Turn icmp (ptrtoint x), (ptrtoint/constant) into a compare of the input 17269d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // if the integer type is the same size as the pointer type. 17279d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (MaxRecurse && TD && isa<PtrToIntInst>(LI) && 17289d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands TD->getPointerSizeInBits() == DstTy->getPrimitiveSizeInBits()) { 17299d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Constant *RHSC = dyn_cast<Constant>(RHS)) { 17309d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Transfer the cast to the constant. 17319d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(Pred, SrcOp, 17329d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantExpr::getIntToPtr(RHSC, SrcTy), 1733618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT, MaxRecurse-1)) 17349d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 17359d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } else if (PtrToIntInst *RI = dyn_cast<PtrToIntInst>(RHS)) { 17369d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (RI->getOperand(0)->getType() == SrcTy) 17379d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Compare without the cast. 17389d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(Pred, SrcOp, RI->getOperand(0), 1739618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT, MaxRecurse-1)) 17409d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 17419d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 17429d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 17439d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 17449d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (isa<ZExtInst>(LHS)) { 17459d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Turn icmp (zext X), (zext Y) into a compare of X and Y if they have the 17469d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // same type. 17479d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (ZExtInst *RI = dyn_cast<ZExtInst>(RHS)) { 17489d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (MaxRecurse && SrcTy == RI->getOperand(0)->getType()) 17499d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Compare X and Y. Note that signed predicates become unsigned. 17509d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(ICmpInst::getUnsignedPredicate(Pred), 1751618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier SrcOp, RI->getOperand(0), TD, TLI, DT, 17529d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands MaxRecurse-1)) 17539d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 17549d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 17559d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Turn icmp (zext X), Cst into a compare of X and Cst if Cst is extended 17569d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // too. If not, then try to deduce the result of the comparison. 17579d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands else if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) { 17589d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Compute the constant that would happen if we truncated to SrcTy then 17599d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // reextended to DstTy. 17609d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant *Trunc = ConstantExpr::getTrunc(CI, SrcTy); 17619d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant *RExt = ConstantExpr::getCast(CastInst::ZExt, Trunc, DstTy); 17629d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 17639d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // If the re-extended constant didn't change then this is effectively 17649d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // also a case of comparing two zero-extended values. 17659d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (RExt == CI && MaxRecurse) 17669d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(ICmpInst::getUnsignedPredicate(Pred), 1767618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier SrcOp, Trunc, TD, TLI, DT, MaxRecurse-1)) 17689d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 17699d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 17709d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Otherwise the upper bits of LHS are zero while RHS has a non-zero bit 17719d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // there. Use this to work out the result of the comparison. 17729d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (RExt != CI) { 17739d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands switch (Pred) { 17749d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands default: 17759d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands assert(false && "Unknown ICmp predicate!"); 17769d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // LHS <u RHS. 17779d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_EQ: 17789d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_UGT: 17799d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_UGE: 17809d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return ConstantInt::getFalse(CI->getContext()); 17819d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 17829d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_NE: 17839d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_ULT: 17849d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_ULE: 17859d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return ConstantInt::getTrue(CI->getContext()); 17869d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 17879d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // LHS is non-negative. If RHS is negative then LHS >s LHS. If RHS 17889d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // is non-negative then LHS <s RHS. 17899d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SGT: 17909d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SGE: 17919d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return CI->getValue().isNegative() ? 17929d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getTrue(CI->getContext()) : 17939d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getFalse(CI->getContext()); 17949d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 17959d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SLT: 17969d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SLE: 17979d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return CI->getValue().isNegative() ? 17989d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getFalse(CI->getContext()) : 17999d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getTrue(CI->getContext()); 18009d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 18019d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 18029d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 18039d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 18049d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 18059d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (isa<SExtInst>(LHS)) { 18069d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Turn icmp (sext X), (sext Y) into a compare of X and Y if they have the 18079d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // same type. 18089d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (SExtInst *RI = dyn_cast<SExtInst>(RHS)) { 18099d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (MaxRecurse && SrcTy == RI->getOperand(0)->getType()) 18109d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Compare X and Y. Note that the predicate does not change. 18119d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(Pred, SrcOp, RI->getOperand(0), 1812618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT, MaxRecurse-1)) 18139d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 18149d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 18159d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Turn icmp (sext X), Cst into a compare of X and Cst if Cst is extended 18169d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // too. If not, then try to deduce the result of the comparison. 18179d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands else if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) { 18189d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Compute the constant that would happen if we truncated to SrcTy then 18199d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // reextended to DstTy. 18209d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant *Trunc = ConstantExpr::getTrunc(CI, SrcTy); 18219d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant *RExt = ConstantExpr::getCast(CastInst::SExt, Trunc, DstTy); 18229d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 18239d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // If the re-extended constant didn't change then this is effectively 18249d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // also a case of comparing two sign-extended values. 18259d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (RExt == CI && MaxRecurse) 1826618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyICmpInst(Pred, SrcOp, Trunc, TD, TLI, DT, 18279d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands MaxRecurse-1)) 18289d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 18299d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 18309d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Otherwise the upper bits of LHS are all equal, while RHS has varying 18319d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // bits there. Use this to work out the result of the comparison. 18329d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (RExt != CI) { 18339d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands switch (Pred) { 18349d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands default: 18359d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands assert(false && "Unknown ICmp predicate!"); 18369d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_EQ: 18379d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return ConstantInt::getFalse(CI->getContext()); 18389d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_NE: 18399d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return ConstantInt::getTrue(CI->getContext()); 18409d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 18419d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // If RHS is non-negative then LHS <s RHS. If RHS is negative then 18429d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // LHS >s RHS. 18439d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SGT: 18449d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SGE: 18459d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return CI->getValue().isNegative() ? 18469d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getTrue(CI->getContext()) : 18479d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getFalse(CI->getContext()); 18489d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SLT: 18499d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SLE: 18509d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return CI->getValue().isNegative() ? 18519d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getFalse(CI->getContext()) : 18529d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getTrue(CI->getContext()); 18539d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 18549d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // If LHS is non-negative then LHS <u RHS. If LHS is negative then 18559d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // LHS >u RHS. 18569d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_UGT: 18579d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_UGE: 18589d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Comparison is true iff the LHS <s 0. 18599d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (MaxRecurse) 18609d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(ICmpInst::ICMP_SLT, SrcOp, 18619d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant::getNullValue(SrcTy), 1862618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT, MaxRecurse-1)) 18639d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 18649d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands break; 18659d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_ULT: 18669d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_ULE: 18679d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Comparison is true iff the LHS >=s 0. 18689d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (MaxRecurse) 18699d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(ICmpInst::ICMP_SGE, SrcOp, 18709d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant::getNullValue(SrcTy), 1871618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT, MaxRecurse-1)) 18729d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 18739d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands break; 18749d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 18759d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 18769d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 18779d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 18789d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 18799d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 188052fb846578714d14bbde9b28884a6a8729217677Duncan Sands // Special logic for binary operators. 188152fb846578714d14bbde9b28884a6a8729217677Duncan Sands BinaryOperator *LBO = dyn_cast<BinaryOperator>(LHS); 188252fb846578714d14bbde9b28884a6a8729217677Duncan Sands BinaryOperator *RBO = dyn_cast<BinaryOperator>(RHS); 188352fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (MaxRecurse && (LBO || RBO)) { 188452fb846578714d14bbde9b28884a6a8729217677Duncan Sands // Analyze the case when either LHS or RHS is an add instruction. 188552fb846578714d14bbde9b28884a6a8729217677Duncan Sands Value *A = 0, *B = 0, *C = 0, *D = 0; 188652fb846578714d14bbde9b28884a6a8729217677Duncan Sands // LHS = A + B (or A and B are null); RHS = C + D (or C and D are null). 188752fb846578714d14bbde9b28884a6a8729217677Duncan Sands bool NoLHSWrapProblem = false, NoRHSWrapProblem = false; 188852fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (LBO && LBO->getOpcode() == Instruction::Add) { 188952fb846578714d14bbde9b28884a6a8729217677Duncan Sands A = LBO->getOperand(0); B = LBO->getOperand(1); 189052fb846578714d14bbde9b28884a6a8729217677Duncan Sands NoLHSWrapProblem = ICmpInst::isEquality(Pred) || 189152fb846578714d14bbde9b28884a6a8729217677Duncan Sands (CmpInst::isUnsigned(Pred) && LBO->hasNoUnsignedWrap()) || 189252fb846578714d14bbde9b28884a6a8729217677Duncan Sands (CmpInst::isSigned(Pred) && LBO->hasNoSignedWrap()); 189352fb846578714d14bbde9b28884a6a8729217677Duncan Sands } 189452fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (RBO && RBO->getOpcode() == Instruction::Add) { 189552fb846578714d14bbde9b28884a6a8729217677Duncan Sands C = RBO->getOperand(0); D = RBO->getOperand(1); 189652fb846578714d14bbde9b28884a6a8729217677Duncan Sands NoRHSWrapProblem = ICmpInst::isEquality(Pred) || 189752fb846578714d14bbde9b28884a6a8729217677Duncan Sands (CmpInst::isUnsigned(Pred) && RBO->hasNoUnsignedWrap()) || 189852fb846578714d14bbde9b28884a6a8729217677Duncan Sands (CmpInst::isSigned(Pred) && RBO->hasNoSignedWrap()); 189952fb846578714d14bbde9b28884a6a8729217677Duncan Sands } 190052fb846578714d14bbde9b28884a6a8729217677Duncan Sands 190152fb846578714d14bbde9b28884a6a8729217677Duncan Sands // icmp (X+Y), X -> icmp Y, 0 for equalities or if there is no overflow. 190252fb846578714d14bbde9b28884a6a8729217677Duncan Sands if ((A == RHS || B == RHS) && NoLHSWrapProblem) 190352fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (Value *V = SimplifyICmpInst(Pred, A == RHS ? B : A, 190452fb846578714d14bbde9b28884a6a8729217677Duncan Sands Constant::getNullValue(RHS->getType()), 1905618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT, MaxRecurse-1)) 190652fb846578714d14bbde9b28884a6a8729217677Duncan Sands return V; 190752fb846578714d14bbde9b28884a6a8729217677Duncan Sands 190852fb846578714d14bbde9b28884a6a8729217677Duncan Sands // icmp X, (X+Y) -> icmp 0, Y for equalities or if there is no overflow. 190952fb846578714d14bbde9b28884a6a8729217677Duncan Sands if ((C == LHS || D == LHS) && NoRHSWrapProblem) 191052fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (Value *V = SimplifyICmpInst(Pred, 191152fb846578714d14bbde9b28884a6a8729217677Duncan Sands Constant::getNullValue(LHS->getType()), 1912618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier C == LHS ? D : C, TD, TLI, DT, MaxRecurse-1)) 191352fb846578714d14bbde9b28884a6a8729217677Duncan Sands return V; 191452fb846578714d14bbde9b28884a6a8729217677Duncan Sands 191552fb846578714d14bbde9b28884a6a8729217677Duncan Sands // icmp (X+Y), (X+Z) -> icmp Y,Z for equalities or if there is no overflow. 191652fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (A && C && (A == C || A == D || B == C || B == D) && 191752fb846578714d14bbde9b28884a6a8729217677Duncan Sands NoLHSWrapProblem && NoRHSWrapProblem) { 191852fb846578714d14bbde9b28884a6a8729217677Duncan Sands // Determine Y and Z in the form icmp (X+Y), (X+Z). 191952fb846578714d14bbde9b28884a6a8729217677Duncan Sands Value *Y = (A == C || A == D) ? B : A; 192052fb846578714d14bbde9b28884a6a8729217677Duncan Sands Value *Z = (C == A || C == B) ? D : C; 1921618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyICmpInst(Pred, Y, Z, TD, TLI, DT, MaxRecurse-1)) 192252fb846578714d14bbde9b28884a6a8729217677Duncan Sands return V; 192352fb846578714d14bbde9b28884a6a8729217677Duncan Sands } 192452fb846578714d14bbde9b28884a6a8729217677Duncan Sands } 192552fb846578714d14bbde9b28884a6a8729217677Duncan Sands 192684dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky if (LBO && match(LBO, m_URem(m_Value(), m_Specific(RHS)))) { 1927786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky bool KnownNonNegative, KnownNegative; 192888cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky switch (Pred) { 192988cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky default: 193088cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky break; 1931786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky case ICmpInst::ICMP_SGT: 1932786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky case ICmpInst::ICMP_SGE: 1933786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky ComputeSignBit(LHS, KnownNonNegative, KnownNegative, TD); 1934786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky if (!KnownNonNegative) 1935786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky break; 1936786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky // fall-through 193788cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky case ICmpInst::ICMP_EQ: 193888cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky case ICmpInst::ICMP_UGT: 193988cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky case ICmpInst::ICMP_UGE: 1940f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 1941786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky case ICmpInst::ICMP_SLT: 1942786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky case ICmpInst::ICMP_SLE: 1943786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky ComputeSignBit(LHS, KnownNonNegative, KnownNegative, TD); 1944786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky if (!KnownNonNegative) 1945786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky break; 1946786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky // fall-through 194788cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky case ICmpInst::ICMP_NE: 194888cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky case ICmpInst::ICMP_ULT: 194988cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky case ICmpInst::ICMP_ULE: 1950f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 195188cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky } 195288cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky } 195384dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky if (RBO && match(RBO, m_URem(m_Value(), m_Specific(LHS)))) { 195484dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky bool KnownNonNegative, KnownNegative; 195584dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky switch (Pred) { 195684dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky default: 195784dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky break; 195884dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_SGT: 195984dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_SGE: 196084dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky ComputeSignBit(RHS, KnownNonNegative, KnownNegative, TD); 196184dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky if (!KnownNonNegative) 196284dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky break; 196384dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky // fall-through 1964a0e2f38b25ce7c51c22ed40d8a315fe1dd98926dNick Lewycky case ICmpInst::ICMP_NE: 196584dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_UGT: 196684dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_UGE: 1967f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 196884dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_SLT: 196984dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_SLE: 197084dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky ComputeSignBit(RHS, KnownNonNegative, KnownNegative, TD); 197184dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky if (!KnownNonNegative) 197284dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky break; 197384dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky // fall-through 1974a0e2f38b25ce7c51c22ed40d8a315fe1dd98926dNick Lewycky case ICmpInst::ICMP_EQ: 197584dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_ULT: 197684dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_ULE: 1977f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 197884dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky } 197984dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky } 198088cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky 1981c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands // x udiv y <=u x. 1982c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands if (LBO && match(LBO, m_UDiv(m_Specific(RHS), m_Value()))) { 1983c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands // icmp pred (X /u Y), X 1984c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands if (Pred == ICmpInst::ICMP_UGT) 1985c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands return getFalse(ITy); 1986c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands if (Pred == ICmpInst::ICMP_ULE) 1987c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands return getTrue(ITy); 1988c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands } 1989c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands 199058bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (MaxRecurse && LBO && RBO && LBO->getOpcode() == RBO->getOpcode() && 199158bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky LBO->getOperand(1) == RBO->getOperand(1)) { 199258bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky switch (LBO->getOpcode()) { 199358bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky default: break; 199458bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::UDiv: 199558bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::LShr: 199658bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (ICmpInst::isSigned(Pred)) 199758bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 199858bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky // fall-through 199958bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::SDiv: 200058bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::AShr: 2001b6e7cd655c6ee119dbeacc321ee92387f983edb0Eli Friedman if (!LBO->isExact() || !RBO->isExact()) 200258bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 200358bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (Value *V = SimplifyICmpInst(Pred, LBO->getOperand(0), 2004618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier RBO->getOperand(0), TD, TLI, DT, MaxRecurse-1)) 200558bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky return V; 200658bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 200758bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::Shl: { 2008c9d904ee2ca36ab6238ed93c7ad2ea67b5fd0a23Duncan Sands bool NUW = LBO->hasNoUnsignedWrap() && RBO->hasNoUnsignedWrap(); 200958bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky bool NSW = LBO->hasNoSignedWrap() && RBO->hasNoSignedWrap(); 201058bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (!NUW && !NSW) 201158bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 201258bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (!NSW && ICmpInst::isSigned(Pred)) 201358bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 201458bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (Value *V = SimplifyICmpInst(Pred, LBO->getOperand(0), 2015618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier RBO->getOperand(0), TD, TLI, DT, MaxRecurse-1)) 201658bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky return V; 201758bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 201858bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky } 201958bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky } 202058bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky } 202158bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky 2022ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Simplify comparisons involving max/min. 2023ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands Value *A, *B; 2024ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands CmpInst::Predicate P = CmpInst::BAD_ICMP_PREDICATE; 2025ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands CmpInst::Predicate EqP; // Chosen so that "A == max/min(A,B)" iff "A EqP B". 2026ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands 20278140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Signed variants on "max(a,b)>=a -> true". 2028ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (match(LHS, m_SMax(m_Value(A), m_Value(B))) && (A == RHS || B == RHS)) { 2029ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != RHS) std::swap(A, B); // smax(A, B) pred A. 2030ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands EqP = CmpInst::ICMP_SGE; // "A == smax(A, B)" iff "A sge B". 2031ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as smax(A, B) pred A. 2032ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = Pred; 2033ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } else if (match(RHS, m_SMax(m_Value(A), m_Value(B))) && 2034ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands (A == LHS || B == LHS)) { 2035ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != LHS) std::swap(A, B); // A pred smax(A, B). 2036ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands EqP = CmpInst::ICMP_SGE; // "A == smax(A, B)" iff "A sge B". 2037ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as smax(A, B) swapped-pred A. 2038ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = CmpInst::getSwappedPredicate(Pred); 2039ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } else if (match(LHS, m_SMin(m_Value(A), m_Value(B))) && 2040ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands (A == RHS || B == RHS)) { 2041ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != RHS) std::swap(A, B); // smin(A, B) pred A. 2042ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands EqP = CmpInst::ICMP_SLE; // "A == smin(A, B)" iff "A sle B". 2043ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as smax(-A, -B) swapped-pred -A. 2044ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Note that we do not need to actually form -A or -B thanks to EqP. 2045ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = CmpInst::getSwappedPredicate(Pred); 2046ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } else if (match(RHS, m_SMin(m_Value(A), m_Value(B))) && 2047ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands (A == LHS || B == LHS)) { 2048ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != LHS) std::swap(A, B); // A pred smin(A, B). 2049ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands EqP = CmpInst::ICMP_SLE; // "A == smin(A, B)" iff "A sle B". 2050ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as smax(-A, -B) pred -A. 2051ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Note that we do not need to actually form -A or -B thanks to EqP. 2052ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = Pred; 2053ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } 2054ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (P != CmpInst::BAD_ICMP_PREDICATE) { 2055ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Cases correspond to "max(A, B) p A". 2056ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands switch (P) { 2057ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands default: 2058ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands break; 2059ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_EQ: 2060ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_SLE: 2061e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Equivalent to "A EqP B". This may be the same as the condition tested 2062e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // in the max/min; if so, we can just return that. 2063e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(LHS, EqP, A, B)) 2064e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2065e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(RHS, EqP, A, B)) 2066e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2067e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Otherwise, see if "A EqP B" simplifies. 2068ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (MaxRecurse) 2069618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyICmpInst(EqP, A, B, TD, TLI, DT, MaxRecurse-1)) 2070ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands return V; 2071ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands break; 2072ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_NE: 2073e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands case CmpInst::ICMP_SGT: { 2074e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands CmpInst::Predicate InvEqP = CmpInst::getInversePredicate(EqP); 2075e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Equivalent to "A InvEqP B". This may be the same as the condition 2076e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // tested in the max/min; if so, we can just return that. 2077e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(LHS, InvEqP, A, B)) 2078e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2079e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(RHS, InvEqP, A, B)) 2080e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2081e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Otherwise, see if "A InvEqP B" simplifies. 2082ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (MaxRecurse) 2083618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyICmpInst(InvEqP, A, B, TD, TLI, DT, MaxRecurse-1)) 2084ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands return V; 2085ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands break; 2086e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands } 2087ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_SGE: 2088ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Always true. 2089f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 2090ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_SLT: 2091ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Always false. 2092f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 2093ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } 2094ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } 2095ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands 20968140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Unsigned variants on "max(a,b)>=a -> true". 2097ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = CmpInst::BAD_ICMP_PREDICATE; 2098ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (match(LHS, m_UMax(m_Value(A), m_Value(B))) && (A == RHS || B == RHS)) { 2099ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != RHS) std::swap(A, B); // umax(A, B) pred A. 2100ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands EqP = CmpInst::ICMP_UGE; // "A == umax(A, B)" iff "A uge B". 2101ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as umax(A, B) pred A. 2102ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = Pred; 2103ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } else if (match(RHS, m_UMax(m_Value(A), m_Value(B))) && 2104ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands (A == LHS || B == LHS)) { 2105ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != LHS) std::swap(A, B); // A pred umax(A, B). 2106ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands EqP = CmpInst::ICMP_UGE; // "A == umax(A, B)" iff "A uge B". 2107ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as umax(A, B) swapped-pred A. 2108ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = CmpInst::getSwappedPredicate(Pred); 2109ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } else if (match(LHS, m_UMin(m_Value(A), m_Value(B))) && 2110ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands (A == RHS || B == RHS)) { 2111ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != RHS) std::swap(A, B); // umin(A, B) pred A. 2112ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands EqP = CmpInst::ICMP_ULE; // "A == umin(A, B)" iff "A ule B". 2113ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as umax(-A, -B) swapped-pred -A. 2114ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Note that we do not need to actually form -A or -B thanks to EqP. 2115ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = CmpInst::getSwappedPredicate(Pred); 2116ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } else if (match(RHS, m_UMin(m_Value(A), m_Value(B))) && 2117ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands (A == LHS || B == LHS)) { 2118ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != LHS) std::swap(A, B); // A pred umin(A, B). 2119ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands EqP = CmpInst::ICMP_ULE; // "A == umin(A, B)" iff "A ule B". 2120ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as umax(-A, -B) pred -A. 2121ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Note that we do not need to actually form -A or -B thanks to EqP. 2122ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = Pred; 2123ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } 2124ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (P != CmpInst::BAD_ICMP_PREDICATE) { 2125ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Cases correspond to "max(A, B) p A". 2126ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands switch (P) { 2127ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands default: 2128ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands break; 2129ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_EQ: 2130ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_ULE: 2131e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Equivalent to "A EqP B". This may be the same as the condition tested 2132e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // in the max/min; if so, we can just return that. 2133e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(LHS, EqP, A, B)) 2134e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2135e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(RHS, EqP, A, B)) 2136e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2137e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Otherwise, see if "A EqP B" simplifies. 2138ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (MaxRecurse) 2139618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyICmpInst(EqP, A, B, TD, TLI, DT, MaxRecurse-1)) 2140ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands return V; 2141ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands break; 2142ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_NE: 2143e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands case CmpInst::ICMP_UGT: { 2144e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands CmpInst::Predicate InvEqP = CmpInst::getInversePredicate(EqP); 2145e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Equivalent to "A InvEqP B". This may be the same as the condition 2146e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // tested in the max/min; if so, we can just return that. 2147e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(LHS, InvEqP, A, B)) 2148e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2149e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(RHS, InvEqP, A, B)) 2150e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2151e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Otherwise, see if "A InvEqP B" simplifies. 2152ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (MaxRecurse) 2153618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyICmpInst(InvEqP, A, B, TD, TLI, DT, MaxRecurse-1)) 2154ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands return V; 2155ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands break; 2156e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands } 2157ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_UGE: 2158ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Always true. 2159f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 2160ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_ULT: 2161ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Always false. 2162f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 2163ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } 2164ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } 2165ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands 21668140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Variants on "max(x,y) >= min(x,z)". 21678140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands Value *C, *D; 21688140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (match(LHS, m_SMax(m_Value(A), m_Value(B))) && 21698140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands match(RHS, m_SMin(m_Value(C), m_Value(D))) && 21708140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands (A == C || A == D || B == C || B == D)) { 21718140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // max(x, ?) pred min(x, ?). 21728140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_SGE) 21738140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always true. 2174f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 21758140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_SLT) 21768140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always false. 2177f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 21788140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands } else if (match(LHS, m_SMin(m_Value(A), m_Value(B))) && 21798140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands match(RHS, m_SMax(m_Value(C), m_Value(D))) && 21808140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands (A == C || A == D || B == C || B == D)) { 21818140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // min(x, ?) pred max(x, ?). 21828140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_SLE) 21838140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always true. 2184f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 21858140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_SGT) 21868140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always false. 2187f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 21888140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands } else if (match(LHS, m_UMax(m_Value(A), m_Value(B))) && 21898140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands match(RHS, m_UMin(m_Value(C), m_Value(D))) && 21908140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands (A == C || A == D || B == C || B == D)) { 21918140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // max(x, ?) pred min(x, ?). 21928140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_UGE) 21938140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always true. 2194f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 21958140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_ULT) 21968140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always false. 2197f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 21988140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands } else if (match(LHS, m_UMin(m_Value(A), m_Value(B))) && 21998140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands match(RHS, m_UMax(m_Value(C), m_Value(D))) && 22008140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands (A == C || A == D || B == C || B == D)) { 22018140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // min(x, ?) pred max(x, ?). 22028140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_ULE) 22038140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always true. 2204f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 22058140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_UGT) 22068140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always false. 2207f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 22088140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands } 22098140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands 22101ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands // If the comparison is with the result of a select instruction, check whether 22111ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands // comparing with either branch of the select always yields the same value. 22120312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<SelectInst>(LHS) || isa<SelectInst>(RHS)) 2213618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = ThreadCmpOverSelect(Pred, LHS, RHS, TD, TLI, DT, MaxRecurse)) 2214a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return V; 2215a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 2216a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the comparison is with the result of a phi instruction, check whether 2217a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // doing the compare with each incoming phi value yields a common result. 22180312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<PHINode>(LHS) || isa<PHINode>(RHS)) 2219618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = ThreadCmpOverPHI(Pred, LHS, RHS, TD, TLI, DT, MaxRecurse)) 22203bbb0cc42b67b4bf2c488285666999963bab0f7eDuncan Sands return V; 22211ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands 22229dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner return 0; 22239dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner} 22249dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 2225a74a58c83be492b7d5b7383656f049909394cff4Duncan SandsValue *llvm::SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS, 2226618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, 2227618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 2228618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT) { 2229618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ::SimplifyICmpInst(Predicate, LHS, RHS, TD, TLI, DT, RecursionLimit); 2230a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 2231a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 22329dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// SimplifyFCmpInst - Given operands for an FCmpInst, see if we can 22339dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// fold the result. If not, this returns null. 2234a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *SimplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS, 2235618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, 2236618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 2237618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT, 22381845009290e4d804ad377927bd8a08cca3036adcDuncan Sands unsigned MaxRecurse) { 22399dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner CmpInst::Predicate Pred = (CmpInst::Predicate)Predicate; 22409dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner assert(CmpInst::isFPPredicate(Pred) && "Not an FP compare!"); 22419dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 2242d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(LHS)) { 22439dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner if (Constant *CRHS = dyn_cast<Constant>(RHS)) 2244618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ConstantFoldCompareInstOperands(Pred, CLHS, CRHS, TD, TLI); 224512a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2246d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // If we have a constant, make sure it is on the RHS. 2247d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner std::swap(LHS, RHS); 2248d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Pred = CmpInst::getSwappedPredicate(Pred); 2249d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 225012a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2251210c5d4880b525e064088b6fec713260128c16ebChris Lattner // Fold trivial predicates. 2252210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (Pred == FCmpInst::FCMP_FALSE) 2253210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(GetCompareTy(LHS), 0); 2254210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (Pred == FCmpInst::FCMP_TRUE) 2255210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(GetCompareTy(LHS), 1); 2256210c5d4880b525e064088b6fec713260128c16ebChris Lattner 2257210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (isa<UndefValue>(RHS)) // fcmp pred X, undef -> undef 2258210c5d4880b525e064088b6fec713260128c16ebChris Lattner return UndefValue::get(GetCompareTy(LHS)); 2259210c5d4880b525e064088b6fec713260128c16ebChris Lattner 2260210c5d4880b525e064088b6fec713260128c16ebChris Lattner // fcmp x,x -> true/false. Not all compares are foldable. 2261124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (LHS == RHS) { 2262210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (CmpInst::isTrueWhenEqual(Pred)) 2263210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(GetCompareTy(LHS), 1); 2264210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (CmpInst::isFalseWhenEqual(Pred)) 2265210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(GetCompareTy(LHS), 0); 2266210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 226712a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2268210c5d4880b525e064088b6fec713260128c16ebChris Lattner // Handle fcmp with constant RHS 2269210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (Constant *RHSC = dyn_cast<Constant>(RHS)) { 2270210c5d4880b525e064088b6fec713260128c16ebChris Lattner // If the constant is a nan, see if we can fold the comparison based on it. 2271210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (ConstantFP *CFP = dyn_cast<ConstantFP>(RHSC)) { 2272210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (CFP->getValueAPF().isNaN()) { 2273210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (FCmpInst::isOrdered(Pred)) // True "if ordered and foo" 2274210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::getFalse(CFP->getContext()); 2275210c5d4880b525e064088b6fec713260128c16ebChris Lattner assert(FCmpInst::isUnordered(Pred) && 2276210c5d4880b525e064088b6fec713260128c16ebChris Lattner "Comparison must be either ordered or unordered!"); 2277210c5d4880b525e064088b6fec713260128c16ebChris Lattner // True if unordered. 2278210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::getTrue(CFP->getContext()); 2279210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 22806b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // Check whether the constant is an infinity. 22816b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman if (CFP->getValueAPF().isInfinity()) { 22826b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman if (CFP->getValueAPF().isNegative()) { 22836b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman switch (Pred) { 22846b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman case FCmpInst::FCMP_OLT: 22856b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // No value is ordered and less than negative infinity. 22866b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman return ConstantInt::getFalse(CFP->getContext()); 22876b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman case FCmpInst::FCMP_UGE: 22886b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // All values are unordered with or at least negative infinity. 22896b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman return ConstantInt::getTrue(CFP->getContext()); 22906b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman default: 22916b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman break; 22926b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } 22936b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } else { 22946b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman switch (Pred) { 22956b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman case FCmpInst::FCMP_OGT: 22966b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // No value is ordered and greater than infinity. 22976b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman return ConstantInt::getFalse(CFP->getContext()); 22986b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman case FCmpInst::FCMP_ULE: 22996b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // All values are unordered with and at most infinity. 23006b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman return ConstantInt::getTrue(CFP->getContext()); 23016b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman default: 23026b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman break; 23036b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } 23046b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } 23056b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } 2306210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 2307210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 230812a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 230992826def593df7a422c7b07f09342febce81ddd3Duncan Sands // If the comparison is with the result of a select instruction, check whether 231092826def593df7a422c7b07f09342febce81ddd3Duncan Sands // comparing with either branch of the select always yields the same value. 23110312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<SelectInst>(LHS) || isa<SelectInst>(RHS)) 2312618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = ThreadCmpOverSelect(Pred, LHS, RHS, TD, TLI, DT, MaxRecurse)) 2313a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return V; 2314a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 2315a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the comparison is with the result of a phi instruction, check whether 2316a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // doing the compare with each incoming phi value yields a common result. 23170312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<PHINode>(LHS) || isa<PHINode>(RHS)) 2318618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = ThreadCmpOverPHI(Pred, LHS, RHS, TD, TLI, DT, MaxRecurse)) 23193bbb0cc42b67b4bf2c488285666999963bab0f7eDuncan Sands return V; 232092826def593df7a422c7b07f09342febce81ddd3Duncan Sands 23219f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner return 0; 23229f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner} 23239f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 2324a74a58c83be492b7d5b7383656f049909394cff4Duncan SandsValue *llvm::SimplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS, 2325618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, 2326618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 2327618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT) { 2328618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ::SimplifyFCmpInst(Predicate, LHS, RHS, TD, TLI, DT, RecursionLimit); 2329a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 2330a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 2331047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner/// SimplifySelectInst - Given operands for a SelectInst, see if we can fold 2332047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner/// the result. If not, this returns null. 2333124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan SandsValue *llvm::SimplifySelectInst(Value *CondVal, Value *TrueVal, Value *FalseVal, 2334124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands const TargetData *TD, const DominatorTree *) { 2335047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner // select true, X, Y -> X 2336047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner // select false, X, Y -> Y 2337047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner if (ConstantInt *CB = dyn_cast<ConstantInt>(CondVal)) 2338047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return CB->getZExtValue() ? TrueVal : FalseVal; 233912a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2340047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner // select C, X, X -> X 2341124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (TrueVal == FalseVal) 2342047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return TrueVal; 234312a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2344047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner if (isa<UndefValue>(CondVal)) { // select undef, X, Y -> X or Y 2345047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner if (isa<Constant>(TrueVal)) 2346047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return TrueVal; 2347047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return FalseVal; 2348047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner } 234968c0dbc14fb7599987fb3e27be4e12c1ac36535eDan Gohman if (isa<UndefValue>(TrueVal)) // select C, undef, X -> X 235068c0dbc14fb7599987fb3e27be4e12c1ac36535eDan Gohman return FalseVal; 235168c0dbc14fb7599987fb3e27be4e12c1ac36535eDan Gohman if (isa<UndefValue>(FalseVal)) // select C, X, undef -> X 235268c0dbc14fb7599987fb3e27be4e12c1ac36535eDan Gohman return TrueVal; 235312a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2354047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return 0; 2355047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner} 2356047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner 2357c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner/// SimplifyGEPInst - Given operands for an GetElementPtrInst, see if we can 2358c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner/// fold the result. If not, this returns null. 2359618c1dbd293d15ee19f61b1156ab8086ad28311aChad RosierValue *llvm::SimplifyGEPInst(ArrayRef<Value *> Ops, const TargetData *TD, 2360618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *) { 236185bbff6c94695f07cc1a9765b4d384ed18d2fd7cDuncan Sands // The type of the GEP pointer operand. 2362db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner PointerType *PtrTy = cast<PointerType>(Ops[0]->getType()); 236385bbff6c94695f07cc1a9765b4d384ed18d2fd7cDuncan Sands 2364c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner // getelementptr P -> P. 2365b9b54ebfed02f0654897d37e8a4448d3f8087558Jay Foad if (Ops.size() == 1) 2366c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner return Ops[0]; 2367c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner 236885bbff6c94695f07cc1a9765b4d384ed18d2fd7cDuncan Sands if (isa<UndefValue>(Ops[0])) { 236985bbff6c94695f07cc1a9765b4d384ed18d2fd7cDuncan Sands // Compute the (pointer) type returned by the GEP instruction. 2370a9203109f4ac95aa7e9624f2838e3d89623ec902Jay Foad Type *LastType = GetElementPtrInst::getIndexedType(PtrTy, Ops.slice(1)); 2371db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *GEPTy = PointerType::get(LastType, PtrTy->getAddressSpace()); 237285bbff6c94695f07cc1a9765b4d384ed18d2fd7cDuncan Sands return UndefValue::get(GEPTy); 237385bbff6c94695f07cc1a9765b4d384ed18d2fd7cDuncan Sands } 2374c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner 2375b9b54ebfed02f0654897d37e8a4448d3f8087558Jay Foad if (Ops.size() == 2) { 2376e60d79faf7ef7bc4847f9e5d067af00b98dced7bDuncan Sands // getelementptr P, 0 -> P. 2377c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner if (ConstantInt *C = dyn_cast<ConstantInt>(Ops[1])) 2378c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner if (C->isZero()) 2379c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner return Ops[0]; 2380e60d79faf7ef7bc4847f9e5d067af00b98dced7bDuncan Sands // getelementptr P, N -> P if P points to a type of zero size. 2381e60d79faf7ef7bc4847f9e5d067af00b98dced7bDuncan Sands if (TD) { 2382db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty = PtrTy->getElementType(); 2383a63395a30f9227bde826749d3480046301b47332Duncan Sands if (Ty->isSized() && TD->getTypeAllocSize(Ty) == 0) 2384e60d79faf7ef7bc4847f9e5d067af00b98dced7bDuncan Sands return Ops[0]; 2385e60d79faf7ef7bc4847f9e5d067af00b98dced7bDuncan Sands } 2386e60d79faf7ef7bc4847f9e5d067af00b98dced7bDuncan Sands } 238712a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2388c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner // Check to see if this is constant foldable. 2389b9b54ebfed02f0654897d37e8a4448d3f8087558Jay Foad for (unsigned i = 0, e = Ops.size(); i != e; ++i) 2390c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner if (!isa<Constant>(Ops[i])) 2391c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner return 0; 239212a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2393dab3d29605a5c83db41b28176273ef55961120c1Jay Foad return ConstantExpr::getGetElementPtr(cast<Constant>(Ops[0]), Ops.slice(1)); 2394c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner} 2395c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner 2396dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands/// SimplifyInsertValueInst - Given operands for an InsertValueInst, see if we 2397dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands/// can fold the result. If not, this returns null. 2398dabc2806726a286b00313419fac8461ebe0f774cDuncan SandsValue *llvm::SimplifyInsertValueInst(Value *Agg, Value *Val, 2399dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands ArrayRef<unsigned> Idxs, 2400dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands const TargetData *, 2401dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands const DominatorTree *) { 2402dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands if (Constant *CAgg = dyn_cast<Constant>(Agg)) 2403dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands if (Constant *CVal = dyn_cast<Constant>(Val)) 2404dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands return ConstantFoldInsertValueInstruction(CAgg, CVal, Idxs); 2405dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands 2406dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands // insertvalue x, undef, n -> x 2407dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands if (match(Val, m_Undef())) 2408dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands return Agg; 2409dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands 2410dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands // insertvalue x, (extractvalue y, n), n 2411dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands if (ExtractValueInst *EV = dyn_cast<ExtractValueInst>(Val)) 2412ae707bd5594e52a8b385760f99ff58aa8fede948Benjamin Kramer if (EV->getAggregateOperand()->getType() == Agg->getType() && 2413ae707bd5594e52a8b385760f99ff58aa8fede948Benjamin Kramer EV->getIndices() == Idxs) { 2414dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands // insertvalue undef, (extractvalue y, n), n -> y 2415dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands if (match(Agg, m_Undef())) 2416dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands return EV->getAggregateOperand(); 2417dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands 2418dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands // insertvalue y, (extractvalue y, n), n -> y 2419dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands if (Agg == EV->getAggregateOperand()) 2420dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands return Agg; 2421dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands } 2422dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands 2423dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands return 0; 2424dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands} 2425dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands 2426ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands/// SimplifyPHINode - See if we can fold the given phi. If not, returns null. 2427ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sandsstatic Value *SimplifyPHINode(PHINode *PN, const DominatorTree *DT) { 2428ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // If all of the PHI's incoming values are the same then replace the PHI node 2429ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // with the common value. 2430ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands Value *CommonValue = 0; 2431ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands bool HasUndefInput = false; 2432ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) { 2433ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands Value *Incoming = PN->getIncomingValue(i); 2434ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // If the incoming value is the phi node itself, it can safely be skipped. 2435ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands if (Incoming == PN) continue; 2436ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands if (isa<UndefValue>(Incoming)) { 2437ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // Remember that we saw an undef value, but otherwise ignore them. 2438ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands HasUndefInput = true; 2439ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands continue; 2440ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands } 2441ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands if (CommonValue && Incoming != CommonValue) 2442ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands return 0; // Not the same, bail out. 2443ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands CommonValue = Incoming; 2444ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands } 2445ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands 2446ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // If CommonValue is null then all of the incoming values were either undef or 2447ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // equal to the phi node itself. 2448ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands if (!CommonValue) 2449ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands return UndefValue::get(PN->getType()); 2450ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands 2451ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // If we have a PHI node like phi(X, undef, X), where X is defined by some 2452ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // instruction, we cannot return X as the result of the PHI node unless it 2453ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // dominates the PHI block. 2454ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands if (HasUndefInput) 2455ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands return ValueDominatesPHI(CommonValue, PN, DT) ? CommonValue : 0; 2456ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands 2457ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands return CommonValue; 2458ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands} 2459ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands 2460d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner//=== Helper functions for higher up the class hierarchy. 24619dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 2462d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner/// SimplifyBinOp - Given operands for a BinaryOperator, see if we can 2463d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner/// fold the result. If not, this returns null. 2464a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *SimplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS, 2465618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, 2466618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 2467618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT, 24681845009290e4d804ad377927bd8a08cca3036adcDuncan Sands unsigned MaxRecurse) { 2469d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner switch (Opcode) { 247081a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner case Instruction::Add: 2471ffeb98ad3becfbb8e26270ef8751e37e4b6b0cd1Duncan Sands return SimplifyAddInst(LHS, RHS, /*isNSW*/false, /*isNUW*/false, 2472618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT, MaxRecurse); 247381a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner case Instruction::Sub: 2474ffeb98ad3becfbb8e26270ef8751e37e4b6b0cd1Duncan Sands return SimplifySubInst(LHS, RHS, /*isNSW*/false, /*isNUW*/false, 2475618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT, MaxRecurse); 2476618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier case Instruction::Mul: return SimplifyMulInst (LHS, RHS, TD, TLI, DT, 2477618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier MaxRecurse); 2478618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier case Instruction::SDiv: return SimplifySDivInst(LHS, RHS, TD, TLI, DT, 2479618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier MaxRecurse); 2480618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier case Instruction::UDiv: return SimplifyUDivInst(LHS, RHS, TD, TLI, DT, 2481618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier MaxRecurse); 2482618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier case Instruction::FDiv: return SimplifyFDivInst(LHS, RHS, TD, TLI, DT, 2483618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier MaxRecurse); 2484618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier case Instruction::SRem: return SimplifySRemInst(LHS, RHS, TD, TLI, DT, 2485618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier MaxRecurse); 2486618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier case Instruction::URem: return SimplifyURemInst(LHS, RHS, TD, TLI, DT, 2487618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier MaxRecurse); 2488618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier case Instruction::FRem: return SimplifyFRemInst(LHS, RHS, TD, TLI, DT, 2489618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier MaxRecurse); 249081a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner case Instruction::Shl: 2491ffeb98ad3becfbb8e26270ef8751e37e4b6b0cd1Duncan Sands return SimplifyShlInst(LHS, RHS, /*isNSW*/false, /*isNUW*/false, 2492618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT, MaxRecurse); 249381a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner case Instruction::LShr: 2494618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return SimplifyLShrInst(LHS, RHS, /*isExact*/false, TD, TLI, DT, 2495618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier MaxRecurse); 249681a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner case Instruction::AShr: 2497618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return SimplifyAShrInst(LHS, RHS, /*isExact*/false, TD, TLI, DT, 2498618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier MaxRecurse); 2499618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier case Instruction::And: return SimplifyAndInst(LHS, RHS, TD, TLI, DT, 2500618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier MaxRecurse); 2501618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier case Instruction::Or: return SimplifyOrInst (LHS, RHS, TD, TLI, DT, 2502618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier MaxRecurse); 2503618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier case Instruction::Xor: return SimplifyXorInst(LHS, RHS, TD, TLI, DT, 2504618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier MaxRecurse); 2505d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner default: 2506d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(LHS)) 2507d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CRHS = dyn_cast<Constant>(RHS)) { 2508d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Constant *COps[] = {CLHS, CRHS}; 2509618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ConstantFoldInstOperands(Opcode, LHS->getType(), COps, TD, TLI); 2510d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 2511b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 2512566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // If the operation is associative, try some generic simplifications. 2513566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Instruction::isAssociative(Opcode)) 2514618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = SimplifyAssociativeBinOp(Opcode, LHS, RHS, TD, TLI, DT, 2515566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands MaxRecurse)) 2516566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return V; 2517566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 2518b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // If the operation is with the result of a select instruction, check whether 2519b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // operating on either branch of the select always yields the same value. 25200312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<SelectInst>(LHS) || isa<SelectInst>(RHS)) 2521618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = ThreadBinOpOverSelect(Opcode, LHS, RHS, TD, TLI, DT, 25220312a93693abc2eb682b2b101c889959888fd883Duncan Sands MaxRecurse)) 2523a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return V; 2524a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 2525a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the operation is with the result of a phi instruction, check whether 2526a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // operating on all incoming values of the phi always yields the same value. 25270312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<PHINode>(LHS) || isa<PHINode>(RHS)) 2528618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier if (Value *V = ThreadBinOpOverPHI(Opcode, LHS, RHS, TD, TLI, DT, 2529618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier MaxRecurse)) 2530b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return V; 2531b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 2532d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return 0; 2533d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 2534d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner} 25359dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 253612a86f5b3199e72e6d967781acc76340f5920e46Duncan SandsValue *llvm::SimplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS, 2537618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, const TargetLibraryInfo *TLI, 2538618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT) { 2539618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ::SimplifyBinOp(Opcode, LHS, RHS, TD, TLI, DT, RecursionLimit); 2540a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 2541a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 25429dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// SimplifyCmpInst - Given operands for a CmpInst, see if we can 25439dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// fold the result. 2544a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *SimplifyCmpInst(unsigned Predicate, Value *LHS, Value *RHS, 2545618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, 2546618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 2547618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT, 25481845009290e4d804ad377927bd8a08cca3036adcDuncan Sands unsigned MaxRecurse) { 25499dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner if (CmpInst::isIntPredicate((CmpInst::Predicate)Predicate)) 2550618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return SimplifyICmpInst(Predicate, LHS, RHS, TD, TLI, DT, MaxRecurse); 2551618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return SimplifyFCmpInst(Predicate, LHS, RHS, TD, TLI, DT, MaxRecurse); 25529dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner} 25539dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 2554a74a58c83be492b7d5b7383656f049909394cff4Duncan SandsValue *llvm::SimplifyCmpInst(unsigned Predicate, Value *LHS, Value *RHS, 2555618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetData *TD, const TargetLibraryInfo *TLI, 2556618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT) { 2557618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier return ::SimplifyCmpInst(Predicate, LHS, RHS, TD, TLI, DT, RecursionLimit); 2558a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 2559e34537856a544c83513e390ac9552a8bc3823346Chris Lattner 256071d050315704c23b235594d3fad5268c12d825e3Dan Gohmanstatic Value *SimplifyCallInst(CallInst *CI) { 256171d050315704c23b235594d3fad5268c12d825e3Dan Gohman // call undef -> undef 256271d050315704c23b235594d3fad5268c12d825e3Dan Gohman if (isa<UndefValue>(CI->getCalledValue())) 256371d050315704c23b235594d3fad5268c12d825e3Dan Gohman return UndefValue::get(CI->getType()); 256471d050315704c23b235594d3fad5268c12d825e3Dan Gohman 256571d050315704c23b235594d3fad5268c12d825e3Dan Gohman return 0; 256671d050315704c23b235594d3fad5268c12d825e3Dan Gohman} 256771d050315704c23b235594d3fad5268c12d825e3Dan Gohman 2568e34537856a544c83513e390ac9552a8bc3823346Chris Lattner/// SimplifyInstruction - See if we can compute a simplified version of this 2569e34537856a544c83513e390ac9552a8bc3823346Chris Lattner/// instruction. If not, this returns null. 2570eff0581583ef10e2872e9baf537a04b67d992101Duncan SandsValue *llvm::SimplifyInstruction(Instruction *I, const TargetData *TD, 2571618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 2572eff0581583ef10e2872e9baf537a04b67d992101Duncan Sands const DominatorTree *DT) { 2573d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands Value *Result; 2574d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands 2575e34537856a544c83513e390ac9552a8bc3823346Chris Lattner switch (I->getOpcode()) { 2576e34537856a544c83513e390ac9552a8bc3823346Chris Lattner default: 2577618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Result = ConstantFoldInstruction(I, TD, TLI); 2578d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 25798aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner case Instruction::Add: 2580d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands Result = SimplifyAddInst(I->getOperand(0), I->getOperand(1), 2581d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands cast<BinaryOperator>(I)->hasNoSignedWrap(), 2582d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands cast<BinaryOperator>(I)->hasNoUnsignedWrap(), 2583618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT); 2584d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 2585fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands case Instruction::Sub: 2586fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands Result = SimplifySubInst(I->getOperand(0), I->getOperand(1), 2587fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands cast<BinaryOperator>(I)->hasNoSignedWrap(), 2588fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands cast<BinaryOperator>(I)->hasNoUnsignedWrap(), 2589618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT); 2590fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands break; 259182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands case Instruction::Mul: 2592618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Result = SimplifyMulInst(I->getOperand(0), I->getOperand(1), TD, TLI, DT); 259382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands break; 2594593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands case Instruction::SDiv: 2595618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Result = SimplifySDivInst(I->getOperand(0), I->getOperand(1), TD, TLI, DT); 2596593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands break; 2597593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands case Instruction::UDiv: 2598618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Result = SimplifyUDivInst(I->getOperand(0), I->getOperand(1), TD, TLI, DT); 2599593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands break; 26001fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel case Instruction::FDiv: 2601618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Result = SimplifyFDivInst(I->getOperand(0), I->getOperand(1), TD, TLI, DT); 26021fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel break; 2603f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands case Instruction::SRem: 2604618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Result = SimplifySRemInst(I->getOperand(0), I->getOperand(1), TD, TLI, DT); 2605f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands break; 2606f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands case Instruction::URem: 2607618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Result = SimplifyURemInst(I->getOperand(0), I->getOperand(1), TD, TLI, DT); 2608f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands break; 2609f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands case Instruction::FRem: 2610618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Result = SimplifyFRemInst(I->getOperand(0), I->getOperand(1), TD, TLI, DT); 2611f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands break; 2612c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands case Instruction::Shl: 261381a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Result = SimplifyShlInst(I->getOperand(0), I->getOperand(1), 261481a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner cast<BinaryOperator>(I)->hasNoSignedWrap(), 261581a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner cast<BinaryOperator>(I)->hasNoUnsignedWrap(), 2616618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT); 2617c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands break; 2618c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands case Instruction::LShr: 261981a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Result = SimplifyLShrInst(I->getOperand(0), I->getOperand(1), 262081a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner cast<BinaryOperator>(I)->isExact(), 2621618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT); 2622c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands break; 2623c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands case Instruction::AShr: 262481a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Result = SimplifyAShrInst(I->getOperand(0), I->getOperand(1), 262581a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner cast<BinaryOperator>(I)->isExact(), 2626618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier TD, TLI, DT); 2627c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands break; 2628e34537856a544c83513e390ac9552a8bc3823346Chris Lattner case Instruction::And: 2629618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Result = SimplifyAndInst(I->getOperand(0), I->getOperand(1), TD, TLI, DT); 2630d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 2631e34537856a544c83513e390ac9552a8bc3823346Chris Lattner case Instruction::Or: 2632618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Result = SimplifyOrInst(I->getOperand(0), I->getOperand(1), TD, TLI, DT); 2633d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 26342b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands case Instruction::Xor: 2635618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier Result = SimplifyXorInst(I->getOperand(0), I->getOperand(1), TD, TLI, DT); 26362b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands break; 2637e34537856a544c83513e390ac9552a8bc3823346Chris Lattner case Instruction::ICmp: 2638d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands Result = SimplifyICmpInst(cast<ICmpInst>(I)->getPredicate(), 2639618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier I->getOperand(0), I->getOperand(1), TD, TLI, DT); 2640d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 2641e34537856a544c83513e390ac9552a8bc3823346Chris Lattner case Instruction::FCmp: 2642d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands Result = SimplifyFCmpInst(cast<FCmpInst>(I)->getPredicate(), 2643618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier I->getOperand(0), I->getOperand(1), TD, TLI, DT); 2644d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 2645047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner case Instruction::Select: 2646d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands Result = SimplifySelectInst(I->getOperand(0), I->getOperand(1), 2647d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands I->getOperand(2), TD, DT); 2648d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 2649c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner case Instruction::GetElementPtr: { 2650c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner SmallVector<Value*, 8> Ops(I->op_begin(), I->op_end()); 2651b9b54ebfed02f0654897d37e8a4448d3f8087558Jay Foad Result = SimplifyGEPInst(Ops, TD, DT); 2652d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 2653c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner } 2654dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands case Instruction::InsertValue: { 2655dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands InsertValueInst *IV = cast<InsertValueInst>(I); 2656dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands Result = SimplifyInsertValueInst(IV->getAggregateOperand(), 2657dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands IV->getInsertedValueOperand(), 2658dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands IV->getIndices(), TD, DT); 2659dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands break; 2660dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands } 2661cd6636c737a82949ad13db2d0d918af6424fb78bDuncan Sands case Instruction::PHI: 2662d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands Result = SimplifyPHINode(cast<PHINode>(I), DT); 2663d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 266471d050315704c23b235594d3fad5268c12d825e3Dan Gohman case Instruction::Call: 266571d050315704c23b235594d3fad5268c12d825e3Dan Gohman Result = SimplifyCallInst(cast<CallInst>(I)); 266671d050315704c23b235594d3fad5268c12d825e3Dan Gohman break; 2667e34537856a544c83513e390ac9552a8bc3823346Chris Lattner } 2668d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands 2669d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands /// If called on unreachable code, the above logic may report that the 2670d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands /// instruction simplified to itself. Make life easier for users by 2671f8b1a5ea9602bb65a5cf59d3d34f2851a08cdc3eDuncan Sands /// detecting that case here, returning a safe value instead. 2672f8b1a5ea9602bb65a5cf59d3d34f2851a08cdc3eDuncan Sands return Result == I ? UndefValue::get(I->getType()) : Result; 2673e34537856a544c83513e390ac9552a8bc3823346Chris Lattner} 2674e34537856a544c83513e390ac9552a8bc3823346Chris Lattner 267540d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// ReplaceAndSimplifyAllUses - Perform From->replaceAllUsesWith(To) and then 267640d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// delete the From instruction. In addition to a basic RAUW, this does a 267740d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// recursive simplification of the newly formed instructions. This catches 267840d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// things where one simplification exposes other opportunities. This only 267940d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// simplifies and deletes scalar operations, it does not change the CFG. 268040d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// 268140d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattnervoid llvm::ReplaceAndSimplifyAllUses(Instruction *From, Value *To, 2682eff0581583ef10e2872e9baf537a04b67d992101Duncan Sands const TargetData *TD, 2683618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 2684eff0581583ef10e2872e9baf537a04b67d992101Duncan Sands const DominatorTree *DT) { 268540d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner assert(From != To && "ReplaceAndSimplifyAllUses(X,X) is not valid!"); 268612a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2687d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // FromHandle/ToHandle - This keeps a WeakVH on the from/to values so that 2688d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // we can know if it gets deleted out from under us or replaced in a 2689d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // recursive simplification. 269040d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner WeakVH FromHandle(From); 2691d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner WeakVH ToHandle(To); 269212a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 269340d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner while (!From->use_empty()) { 269440d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner // Update the instruction to use the new value. 2695d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner Use &TheUse = From->use_begin().getUse(); 2696d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner Instruction *User = cast<Instruction>(TheUse.getUser()); 2697d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner TheUse = To; 2698d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner 2699d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // Check to see if the instruction can be folded due to the operand 2700d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // replacement. For example changing (or X, Y) into (or X, -1) can replace 2701d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // the 'or' with -1. 2702d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner Value *SimplifiedVal; 2703d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner { 2704d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // Sanity check to make sure 'User' doesn't dangle across 2705d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // SimplifyInstruction. 2706d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner AssertingVH<> UserHandle(User); 270712a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2708618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier SimplifiedVal = SimplifyInstruction(User, TD, TLI, DT); 2709d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner if (SimplifiedVal == 0) continue; 271040d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner } 271112a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2712d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // Recursively simplify this user to the new value. 2713618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier ReplaceAndSimplifyAllUses(User, SimplifiedVal, TD, TLI, DT); 2714d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner From = dyn_cast_or_null<Instruction>((Value*)FromHandle); 2715d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner To = ToHandle; 271612a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2717d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner assert(ToHandle && "To value deleted by recursive simplification?"); 271812a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2719d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // If the recursive simplification ended up revisiting and deleting 2720d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // 'From' then we're done. 2721d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner if (From == 0) 2722d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner return; 272340d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner } 272412a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2725d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // If 'From' has value handles referring to it, do a real RAUW to update them. 2726d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner From->replaceAllUsesWith(To); 272712a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 272840d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner From->eraseFromParent(); 272940d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner} 2730