InstructionSimplify.cpp revision 7781ae5be570940178295f6f808215089a3fe411
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 *, 4182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands const DominatorTree *, unsigned); 42a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *SimplifyBinOp(unsigned, Value *, Value *, const TargetData *, 431845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const DominatorTree *, unsigned); 44a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *SimplifyCmpInst(unsigned, Value *, Value *, const TargetData *, 451845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const DominatorTree *, unsigned); 4682fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sandsstatic Value *SimplifyOrInst(Value *, Value *, const TargetData *, 4782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands const DominatorTree *, unsigned); 4882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sandsstatic Value *SimplifyXorInst(Value *, Value *, const TargetData *, 4982fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands const DominatorTree *, unsigned); 501845009290e4d804ad377927bd8a08cca3036adcDuncan Sands 51f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands/// getFalse - For a boolean type, or a vector of boolean type, return false, or 52f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands/// a vector with every element false, as appropriate for the type. 53f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sandsstatic Constant *getFalse(Type *Ty) { 54f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands assert((Ty->isIntegerTy(1) || 55f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands (Ty->isVectorTy() && 56f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands cast<VectorType>(Ty)->getElementType()->isIntegerTy(1))) && 57f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands "Expected i1 type or a vector of i1!"); 58f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return Constant::getNullValue(Ty); 59f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands} 60f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands 61f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands/// getTrue - For a boolean type, or a vector of boolean type, return true, or 62f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands/// a vector with every element true, as appropriate for the type. 63f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sandsstatic Constant *getTrue(Type *Ty) { 64f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands assert((Ty->isIntegerTy(1) || 65f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands (Ty->isVectorTy() && 66f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands cast<VectorType>(Ty)->getElementType()->isIntegerTy(1))) && 67f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands "Expected i1 type or a vector of i1!"); 68f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return Constant::getAllOnesValue(Ty); 69f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands} 70f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands 716dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands/// isSameCompare - Is V equivalent to the comparison "LHS Pred RHS"? 726dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sandsstatic bool isSameCompare(Value *V, CmpInst::Predicate Pred, Value *LHS, 736dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands Value *RHS) { 746dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands CmpInst *Cmp = dyn_cast<CmpInst>(V); 756dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (!Cmp) 766dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return false; 776dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands CmpInst::Predicate CPred = Cmp->getPredicate(); 786dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands Value *CLHS = Cmp->getOperand(0), *CRHS = Cmp->getOperand(1); 796dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (CPred == Pred && CLHS == LHS && CRHS == RHS) 806dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return true; 816dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return CPred == CmpInst::getSwappedPredicate(Pred) && CLHS == RHS && 826dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands CRHS == LHS; 836dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands} 846dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands 851845009290e4d804ad377927bd8a08cca3036adcDuncan Sands/// ValueDominatesPHI - Does the given value dominate the specified phi node? 861845009290e4d804ad377927bd8a08cca3036adcDuncan Sandsstatic bool ValueDominatesPHI(Value *V, PHINode *P, const DominatorTree *DT) { 871845009290e4d804ad377927bd8a08cca3036adcDuncan Sands Instruction *I = dyn_cast<Instruction>(V); 881845009290e4d804ad377927bd8a08cca3036adcDuncan Sands if (!I) 891845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // Arguments and constants dominate all instructions. 901845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return true; 911845009290e4d804ad377927bd8a08cca3036adcDuncan Sands 921845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // If we have a DominatorTree then do a precise test. 931845009290e4d804ad377927bd8a08cca3036adcDuncan Sands if (DT) 941845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return DT->dominates(I, P); 951845009290e4d804ad377927bd8a08cca3036adcDuncan Sands 961845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // Otherwise, if the instruction is in the entry block, and is not an invoke, 971845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // then it obviously dominates all phi nodes. 981845009290e4d804ad377927bd8a08cca3036adcDuncan Sands if (I->getParent() == &I->getParent()->getParent()->getEntryBlock() && 991845009290e4d804ad377927bd8a08cca3036adcDuncan Sands !isa<InvokeInst>(I)) 1001845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return true; 1011845009290e4d804ad377927bd8a08cca3036adcDuncan Sands 1021845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return false; 1031845009290e4d804ad377927bd8a08cca3036adcDuncan Sands} 104a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 1053421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// ExpandBinOp - Simplify "A op (B op' C)" by distributing op over op', turning 1063421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// it into "(A op B) op' (A op C)". Here "op" is given by Opcode and "op'" is 1073421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// given by OpcodeToExpand, while "A" corresponds to LHS and "B op' C" to RHS. 1083421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// Also performs the transform "(A op' B) op C" -> "(A op C) op' (B op C)". 1093421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// Returns the simplified value, or null if no simplification was performed. 1103421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sandsstatic Value *ExpandBinOp(unsigned Opcode, Value *LHS, Value *RHS, 111e21083aa3a79506f896d95d7147c3c4627a77ef0Benjamin Kramer unsigned OpcToExpand, const TargetData *TD, 1123421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands const DominatorTree *DT, unsigned MaxRecurse) { 113e21083aa3a79506f896d95d7147c3c4627a77ef0Benjamin Kramer Instruction::BinaryOps OpcodeToExpand = (Instruction::BinaryOps)OpcToExpand; 1143421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 1153421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (!MaxRecurse--) 1163421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return 0; 1173421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1183421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Check whether the expression has the form "(A op' B) op C". 1193421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (BinaryOperator *Op0 = dyn_cast<BinaryOperator>(LHS)) 1203421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Op0->getOpcode() == OpcodeToExpand) { 1213421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // It does! Try turning it into "(A op C) op' (B op C)". 1223421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands Value *A = Op0->getOperand(0), *B = Op0->getOperand(1), *C = RHS; 1233421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Do "A op C" and "B op C" both simplify? 1243421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *L = SimplifyBinOp(Opcode, A, C, TD, DT, MaxRecurse)) 1253421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *R = SimplifyBinOp(Opcode, B, C, TD, DT, MaxRecurse)) { 1263421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // They do! Return "L op' R" if it simplifies or is already available. 1273421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // If "L op' R" equals "A op' B" then "L op' R" is just the LHS. 128124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if ((L == A && R == B) || (Instruction::isCommutative(OpcodeToExpand) 129124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands && L == B && R == A)) { 130a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumExpand; 1313421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return LHS; 132a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 1333421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Otherwise return "L op' R" if it simplifies. 134a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands if (Value *V = SimplifyBinOp(OpcodeToExpand, L, R, TD, DT, 135a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands MaxRecurse)) { 136a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumExpand; 1373421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 138a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 1393421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 1403421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 1413421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1423421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Check whether the expression has the form "A op (B op' C)". 1433421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (BinaryOperator *Op1 = dyn_cast<BinaryOperator>(RHS)) 1443421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Op1->getOpcode() == OpcodeToExpand) { 1453421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // It does! Try turning it into "(A op B) op' (A op C)". 1463421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands Value *A = LHS, *B = Op1->getOperand(0), *C = Op1->getOperand(1); 1473421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Do "A op B" and "A op C" both simplify? 1483421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *L = SimplifyBinOp(Opcode, A, B, TD, DT, MaxRecurse)) 1493421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *R = SimplifyBinOp(Opcode, A, C, TD, DT, MaxRecurse)) { 1503421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // They do! Return "L op' R" if it simplifies or is already available. 1513421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // If "L op' R" equals "B op' C" then "L op' R" is just the RHS. 152124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if ((L == B && R == C) || (Instruction::isCommutative(OpcodeToExpand) 153124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands && L == C && R == B)) { 154a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumExpand; 1553421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return RHS; 156a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 1573421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Otherwise return "L op' R" if it simplifies. 158a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands if (Value *V = SimplifyBinOp(OpcodeToExpand, L, R, TD, DT, 159a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands MaxRecurse)) { 160a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumExpand; 1613421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 162a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 1633421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 1643421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 1653421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1663421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return 0; 1673421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands} 1683421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1693421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// FactorizeBinOp - Simplify "LHS Opcode RHS" by factorizing out a common term 1703421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// using the operation OpCodeToExtract. For example, when Opcode is Add and 1713421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// OpCodeToExtract is Mul then this tries to turn "(A*B)+(A*C)" into "A*(B+C)". 1723421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// Returns the simplified value, or null if no simplification was performed. 1733421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sandsstatic Value *FactorizeBinOp(unsigned Opcode, Value *LHS, Value *RHS, 174e21083aa3a79506f896d95d7147c3c4627a77ef0Benjamin Kramer unsigned OpcToExtract, const TargetData *TD, 1753421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands const DominatorTree *DT, unsigned MaxRecurse) { 176e21083aa3a79506f896d95d7147c3c4627a77ef0Benjamin Kramer Instruction::BinaryOps OpcodeToExtract = (Instruction::BinaryOps)OpcToExtract; 1773421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 1783421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (!MaxRecurse--) 1793421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return 0; 1803421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1813421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands BinaryOperator *Op0 = dyn_cast<BinaryOperator>(LHS); 1823421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands BinaryOperator *Op1 = dyn_cast<BinaryOperator>(RHS); 1833421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1843421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (!Op0 || Op0->getOpcode() != OpcodeToExtract || 1853421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands !Op1 || Op1->getOpcode() != OpcodeToExtract) 1863421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return 0; 1873421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1883421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // The expression has the form "(A op' B) op (C op' D)". 18982fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands Value *A = Op0->getOperand(0), *B = Op0->getOperand(1); 19082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands Value *C = Op1->getOperand(0), *D = Op1->getOperand(1); 1913421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1923421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Use left distributivity, i.e. "X op' (Y op Z) = (X op' Y) op (X op' Z)". 1933421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Does the instruction have the form "(A op' B) op (A op' D)" or, in the 1943421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // commutative case, "(A op' B) op (C op' A)"? 195124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (A == C || (Instruction::isCommutative(OpcodeToExtract) && A == D)) { 196124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands Value *DD = A == C ? D : C; 1973421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Form "A op' (B op DD)" if it simplifies completely. 1983421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Does "B op DD" simplify? 1993421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = SimplifyBinOp(Opcode, B, DD, TD, DT, MaxRecurse)) { 2003421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // It does! Return "A op' V" if it simplifies or is already available. 2011cd05bb605e3c3eee9197d3f10b628c60d0cc07aDuncan Sands // If V equals B then "A op' V" is just the LHS. If V equals DD then 2021cd05bb605e3c3eee9197d3f10b628c60d0cc07aDuncan Sands // "A op' V" is just the RHS. 203124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (V == B || V == DD) { 204a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumFactor; 205124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands return V == B ? LHS : RHS; 206a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 2073421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Otherwise return "A op' V" if it simplifies. 208a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands if (Value *W = SimplifyBinOp(OpcodeToExtract, A, V, TD, DT, MaxRecurse)) { 209a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumFactor; 2103421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return W; 211a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 2123421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 2133421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 2143421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 2153421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Use right distributivity, i.e. "(X op Y) op' Z = (X op' Z) op (Y op' Z)". 2163421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Does the instruction have the form "(A op' B) op (C op' B)" or, in the 2173421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // commutative case, "(A op' B) op (B op' D)"? 218124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (B == D || (Instruction::isCommutative(OpcodeToExtract) && B == C)) { 219124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands Value *CC = B == D ? C : D; 2203421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Form "(A op CC) op' B" if it simplifies completely.. 2213421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Does "A op CC" simplify? 2223421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = SimplifyBinOp(Opcode, A, CC, TD, DT, MaxRecurse)) { 2233421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // It does! Return "V op' B" if it simplifies or is already available. 2241cd05bb605e3c3eee9197d3f10b628c60d0cc07aDuncan Sands // If V equals A then "V op' B" is just the LHS. If V equals CC then 2251cd05bb605e3c3eee9197d3f10b628c60d0cc07aDuncan Sands // "V op' B" is just the RHS. 226124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (V == A || V == CC) { 227a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumFactor; 228124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands return V == A ? LHS : RHS; 229a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 2303421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Otherwise return "V op' B" if it simplifies. 231a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands if (Value *W = SimplifyBinOp(OpcodeToExtract, V, B, TD, DT, MaxRecurse)) { 232a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumFactor; 2333421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return W; 234a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 2353421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 2363421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 2373421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 2383421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return 0; 2393421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands} 2403421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 2413421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// SimplifyAssociativeBinOp - Generic simplifications for associative binary 2423421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// operations. Returns the simpler value, or null if none was found. 243e21083aa3a79506f896d95d7147c3c4627a77ef0Benjamin Kramerstatic Value *SimplifyAssociativeBinOp(unsigned Opc, Value *LHS, Value *RHS, 244566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands const TargetData *TD, 245566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands const DominatorTree *DT, 246566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands unsigned MaxRecurse) { 247e21083aa3a79506f896d95d7147c3c4627a77ef0Benjamin Kramer Instruction::BinaryOps Opcode = (Instruction::BinaryOps)Opc; 248566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands assert(Instruction::isAssociative(Opcode) && "Not an associative operation!"); 249566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 250566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 251566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (!MaxRecurse--) 252566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return 0; 253566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 254566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands BinaryOperator *Op0 = dyn_cast<BinaryOperator>(LHS); 255566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands BinaryOperator *Op1 = dyn_cast<BinaryOperator>(RHS); 256566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 257566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Transform: "(A op B) op C" ==> "A op (B op C)" if it simplifies completely. 258566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Op0 && Op0->getOpcode() == Opcode) { 259566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *A = Op0->getOperand(0); 260566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *B = Op0->getOperand(1); 261566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *C = RHS; 262566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 263566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Does "B op C" simplify? 264566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Value *V = SimplifyBinOp(Opcode, B, C, TD, DT, MaxRecurse)) { 265566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // It does! Return "A op V" if it simplifies or is already available. 266566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // If V equals B then "A op V" is just the LHS. 267124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (V == B) return LHS; 268566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Otherwise return "A op V" if it simplifies. 269a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands if (Value *W = SimplifyBinOp(Opcode, A, V, TD, DT, MaxRecurse)) { 270a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumReassoc; 271566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return W; 272a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 273566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 274566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 275566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 276566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Transform: "A op (B op C)" ==> "(A op B) op C" if it simplifies completely. 277566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Op1 && Op1->getOpcode() == Opcode) { 278566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *A = LHS; 279566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *B = Op1->getOperand(0); 280566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *C = Op1->getOperand(1); 281566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 282566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Does "A op B" simplify? 283566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Value *V = SimplifyBinOp(Opcode, A, B, TD, DT, MaxRecurse)) { 284566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // It does! Return "V op C" if it simplifies or is already available. 285566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // If V equals B then "V op C" is just the RHS. 286124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (V == B) return RHS; 287566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Otherwise return "V op C" if it simplifies. 288a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands if (Value *W = SimplifyBinOp(Opcode, V, C, TD, DT, MaxRecurse)) { 289a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumReassoc; 290566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return W; 291a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 292566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 293566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 294566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 295566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // The remaining transforms require commutativity as well as associativity. 296566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (!Instruction::isCommutative(Opcode)) 297566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return 0; 298566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 299566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Transform: "(A op B) op C" ==> "(C op A) op B" if it simplifies completely. 300566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Op0 && Op0->getOpcode() == Opcode) { 301566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *A = Op0->getOperand(0); 302566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *B = Op0->getOperand(1); 303566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *C = RHS; 304566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 305566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Does "C op A" simplify? 306566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Value *V = SimplifyBinOp(Opcode, C, A, TD, DT, MaxRecurse)) { 307566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // It does! Return "V op B" if it simplifies or is already available. 308566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // If V equals A then "V op B" is just the LHS. 309124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (V == A) return LHS; 310566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Otherwise return "V op B" if it simplifies. 311a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands if (Value *W = SimplifyBinOp(Opcode, V, B, TD, DT, MaxRecurse)) { 312a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumReassoc; 313566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return W; 314a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 315566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 316566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 317566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 318566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Transform: "A op (B op C)" ==> "B op (C op A)" if it simplifies completely. 319566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Op1 && Op1->getOpcode() == Opcode) { 320566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *A = LHS; 321566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *B = Op1->getOperand(0); 322566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *C = Op1->getOperand(1); 323566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 324566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Does "C op A" simplify? 325566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Value *V = SimplifyBinOp(Opcode, C, A, TD, DT, MaxRecurse)) { 326566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // It does! Return "B op V" if it simplifies or is already available. 327566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // If V equals C then "B op V" is just the RHS. 328124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (V == C) return RHS; 329566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Otherwise return "B op V" if it simplifies. 330a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands if (Value *W = SimplifyBinOp(Opcode, B, V, TD, DT, MaxRecurse)) { 331a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumReassoc; 332566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return W; 333a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 334566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 335566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 336566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 337566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return 0; 338566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands} 339566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 340b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// ThreadBinOpOverSelect - In the case of a binary operation with a select 341b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// instruction as an operand, try to simplify the binop by seeing whether 342b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// evaluating it on both branches of the select results in the same value. 343b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// Returns the common value if so, otherwise returns null. 344b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sandsstatic Value *ThreadBinOpOverSelect(unsigned Opcode, Value *LHS, Value *RHS, 3451845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const TargetData *TD, 3461845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const DominatorTree *DT, 3471845009290e4d804ad377927bd8a08cca3036adcDuncan Sands unsigned MaxRecurse) { 3480312a93693abc2eb682b2b101c889959888fd883Duncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 3490312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (!MaxRecurse--) 3500312a93693abc2eb682b2b101c889959888fd883Duncan Sands return 0; 3510312a93693abc2eb682b2b101c889959888fd883Duncan Sands 352b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands SelectInst *SI; 353b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (isa<SelectInst>(LHS)) { 354b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands SI = cast<SelectInst>(LHS); 355b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } else { 356b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands assert(isa<SelectInst>(RHS) && "No select instruction operand!"); 357b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands SI = cast<SelectInst>(RHS); 358b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } 359b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 360b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // Evaluate the BinOp on the true and false branches of the select. 361b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Value *TV; 362b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Value *FV; 363b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (SI == LHS) { 3641845009290e4d804ad377927bd8a08cca3036adcDuncan Sands TV = SimplifyBinOp(Opcode, SI->getTrueValue(), RHS, TD, DT, MaxRecurse); 3651845009290e4d804ad377927bd8a08cca3036adcDuncan Sands FV = SimplifyBinOp(Opcode, SI->getFalseValue(), RHS, TD, DT, MaxRecurse); 366b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } else { 3671845009290e4d804ad377927bd8a08cca3036adcDuncan Sands TV = SimplifyBinOp(Opcode, LHS, SI->getTrueValue(), TD, DT, MaxRecurse); 3681845009290e4d804ad377927bd8a08cca3036adcDuncan Sands FV = SimplifyBinOp(Opcode, LHS, SI->getFalseValue(), TD, DT, MaxRecurse); 369b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } 370b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 3717cf85e74e3885005ca8e5fdb155fa5351e255b85Duncan Sands // If they simplified to the same value, then return the common value. 372124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands // If they both failed to simplify then return null. 373124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (TV == FV) 374b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return TV; 375b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 376b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // If one branch simplified to undef, return the other one. 377b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (TV && isa<UndefValue>(TV)) 378b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return FV; 379b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (FV && isa<UndefValue>(FV)) 380b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return TV; 381b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 382b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // If applying the operation did not change the true and false select values, 383b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // then the result of the binop is the select itself. 384124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (TV == SI->getTrueValue() && FV == SI->getFalseValue()) 385b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return SI; 386b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 387b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // If one branch simplified and the other did not, and the simplified 388b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // value is equal to the unsimplified one, return the simplified value. 389b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // For example, select (cond, X, X & Z) & Z -> X & Z. 390b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if ((FV && !TV) || (TV && !FV)) { 391b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // Check that the simplified value has the form "X op Y" where "op" is the 392b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // same as the original operation. 393b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Instruction *Simplified = dyn_cast<Instruction>(FV ? FV : TV); 394b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (Simplified && Simplified->getOpcode() == Opcode) { 395b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // The value that didn't simplify is "UnsimplifiedLHS op UnsimplifiedRHS". 396b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // We already know that "op" is the same as for the simplified value. See 397b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // if the operands match too. If so, return the simplified value. 398b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Value *UnsimplifiedBranch = FV ? SI->getTrueValue() : SI->getFalseValue(); 399b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Value *UnsimplifiedLHS = SI == LHS ? UnsimplifiedBranch : LHS; 400b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Value *UnsimplifiedRHS = SI == LHS ? RHS : UnsimplifiedBranch; 401124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (Simplified->getOperand(0) == UnsimplifiedLHS && 402124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands Simplified->getOperand(1) == UnsimplifiedRHS) 403b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return Simplified; 404b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (Simplified->isCommutative() && 405124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands Simplified->getOperand(1) == UnsimplifiedLHS && 406124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands Simplified->getOperand(0) == UnsimplifiedRHS) 407b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return Simplified; 408b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } 409b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } 410b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 411b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return 0; 412b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands} 413b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 414b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// ThreadCmpOverSelect - In the case of a comparison with a select instruction, 415b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// try to simplify the comparison by seeing whether both branches of the select 416b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// result in the same value. Returns the common value if so, otherwise returns 417b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// null. 418b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sandsstatic Value *ThreadCmpOverSelect(CmpInst::Predicate Pred, Value *LHS, 419a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands Value *RHS, const TargetData *TD, 4201845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const DominatorTree *DT, 421a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands unsigned MaxRecurse) { 4220312a93693abc2eb682b2b101c889959888fd883Duncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 4230312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (!MaxRecurse--) 4240312a93693abc2eb682b2b101c889959888fd883Duncan Sands return 0; 4250312a93693abc2eb682b2b101c889959888fd883Duncan Sands 426b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // Make sure the select is on the LHS. 427b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (!isa<SelectInst>(LHS)) { 428b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands std::swap(LHS, RHS); 429b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Pred = CmpInst::getSwappedPredicate(Pred); 430b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } 431b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands assert(isa<SelectInst>(LHS) && "Not comparing with a select instruction!"); 432b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands SelectInst *SI = cast<SelectInst>(LHS); 4336dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands Value *Cond = SI->getCondition(); 4346dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands Value *TV = SI->getTrueValue(); 4356dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands Value *FV = SI->getFalseValue(); 436b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 43750ca4d37f7f3b460c6441eb5ad14625a7d86b5d9Duncan Sands // Now that we have "cmp select(Cond, TV, FV), RHS", analyse it. 438b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // Does "cmp TV, RHS" simplify? 4396dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands Value *TCmp = SimplifyCmpInst(Pred, TV, RHS, TD, DT, MaxRecurse); 4406dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (TCmp == Cond) { 4416dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // It not only simplified, it simplified to the select condition. Replace 4426dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // it with 'true'. 4436dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands TCmp = getTrue(Cond->getType()); 4446dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands } else if (!TCmp) { 4456dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // It didn't simplify. However if "cmp TV, RHS" is equal to the select 4466dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // condition then we can replace it with 'true'. Otherwise give up. 4476dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (!isSameCompare(Cond, Pred, TV, RHS)) 4486dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return 0; 4496dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands TCmp = getTrue(Cond->getType()); 45050ca4d37f7f3b460c6441eb5ad14625a7d86b5d9Duncan Sands } 45150ca4d37f7f3b460c6441eb5ad14625a7d86b5d9Duncan Sands 4526dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // Does "cmp FV, RHS" simplify? 4536dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands Value *FCmp = SimplifyCmpInst(Pred, FV, RHS, TD, DT, MaxRecurse); 4546dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (FCmp == Cond) { 4556dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // It not only simplified, it simplified to the select condition. Replace 4566dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // it with 'false'. 4576dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands FCmp = getFalse(Cond->getType()); 4586dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands } else if (!FCmp) { 4596dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // It didn't simplify. However if "cmp FV, RHS" is equal to the select 4606dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // condition then we can replace it with 'false'. Otherwise give up. 4616dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (!isSameCompare(Cond, Pred, FV, RHS)) 4626dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return 0; 4636dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands FCmp = getFalse(Cond->getType()); 4646dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands } 4656dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands 4666dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // If both sides simplified to the same value, then use it as the result of 4676dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // the original comparison. 4686dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (TCmp == FCmp) 4696dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return TCmp; 4706dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // If the false value simplified to false, then the result of the compare 4716dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // is equal to "Cond && TCmp". This also catches the case when the false 4726dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // value simplified to false and the true value to true, returning "Cond". 4736dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (match(FCmp, m_Zero())) 4746dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (Value *V = SimplifyAndInst(Cond, TCmp, TD, DT, MaxRecurse)) 4756dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return V; 4766dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // If the true value simplified to true, then the result of the compare 4776dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // is equal to "Cond || FCmp". 4786dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (match(TCmp, m_One())) 4796dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (Value *V = SimplifyOrInst(Cond, FCmp, TD, DT, MaxRecurse)) 4806dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return V; 4816dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // Finally, if the false value simplified to true and the true value to 4826dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // false, then the result of the compare is equal to "!Cond". 4836dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (match(FCmp, m_One()) && match(TCmp, m_Zero())) 4846dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (Value *V = 4856dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands SimplifyXorInst(Cond, Constant::getAllOnesValue(Cond->getType()), 4866dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands TD, DT, MaxRecurse)) 4876dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return V; 4886dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands 489b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return 0; 490b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands} 491b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 492a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// ThreadBinOpOverPHI - In the case of a binary operation with an operand that 493a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// is a PHI instruction, try to simplify the binop by seeing whether evaluating 494a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// it on the incoming phi values yields the same result for every value. If so 495a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// returns the common value, otherwise returns null. 496a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *ThreadBinOpOverPHI(unsigned Opcode, Value *LHS, Value *RHS, 4971845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const TargetData *TD, const DominatorTree *DT, 4981845009290e4d804ad377927bd8a08cca3036adcDuncan Sands unsigned MaxRecurse) { 4990312a93693abc2eb682b2b101c889959888fd883Duncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 5000312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (!MaxRecurse--) 5010312a93693abc2eb682b2b101c889959888fd883Duncan Sands return 0; 5020312a93693abc2eb682b2b101c889959888fd883Duncan Sands 503a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands PHINode *PI; 504a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands if (isa<PHINode>(LHS)) { 505a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands PI = cast<PHINode>(LHS); 5061845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // Bail out if RHS and the phi may be mutually interdependent due to a loop. 5071845009290e4d804ad377927bd8a08cca3036adcDuncan Sands if (!ValueDominatesPHI(RHS, PI, DT)) 5081845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return 0; 509a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands } else { 510a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands assert(isa<PHINode>(RHS) && "No PHI instruction operand!"); 511a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands PI = cast<PHINode>(RHS); 5121845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // Bail out if LHS and the phi may be mutually interdependent due to a loop. 5131845009290e4d804ad377927bd8a08cca3036adcDuncan Sands if (!ValueDominatesPHI(LHS, PI, DT)) 5141845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return 0; 515a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands } 516a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 517a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // Evaluate the BinOp on the incoming phi values. 518a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands Value *CommonValue = 0; 519a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands for (unsigned i = 0, e = PI->getNumIncomingValues(); i != e; ++i) { 520552008946530e01efdad15044e1f621883d14a3aDuncan Sands Value *Incoming = PI->getIncomingValue(i); 521ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // If the incoming value is the phi node itself, it can safely be skipped. 522552008946530e01efdad15044e1f621883d14a3aDuncan Sands if (Incoming == PI) continue; 523a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands Value *V = PI == LHS ? 5241845009290e4d804ad377927bd8a08cca3036adcDuncan Sands SimplifyBinOp(Opcode, Incoming, RHS, TD, DT, MaxRecurse) : 5251845009290e4d804ad377927bd8a08cca3036adcDuncan Sands SimplifyBinOp(Opcode, LHS, Incoming, TD, DT, MaxRecurse); 526a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the operation failed to simplify, or simplified to a different value 527a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // to previously, then give up. 528a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands if (!V || (CommonValue && V != CommonValue)) 529a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return 0; 530a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands CommonValue = V; 531a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands } 532a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 533a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return CommonValue; 534a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 535a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 536a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// ThreadCmpOverPHI - In the case of a comparison with a PHI instruction, try 537a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// try to simplify the comparison by seeing whether comparing with all of the 538a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// incoming phi values yields the same result every time. If so returns the 539a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// common result, otherwise returns null. 540a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *ThreadCmpOverPHI(CmpInst::Predicate Pred, Value *LHS, Value *RHS, 5411845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const TargetData *TD, const DominatorTree *DT, 5421845009290e4d804ad377927bd8a08cca3036adcDuncan Sands unsigned MaxRecurse) { 5430312a93693abc2eb682b2b101c889959888fd883Duncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 5440312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (!MaxRecurse--) 5450312a93693abc2eb682b2b101c889959888fd883Duncan Sands return 0; 5460312a93693abc2eb682b2b101c889959888fd883Duncan Sands 547a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // Make sure the phi is on the LHS. 548a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands if (!isa<PHINode>(LHS)) { 549a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands std::swap(LHS, RHS); 550a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands Pred = CmpInst::getSwappedPredicate(Pred); 551a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands } 552a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands assert(isa<PHINode>(LHS) && "Not comparing with a phi instruction!"); 553a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands PHINode *PI = cast<PHINode>(LHS); 554a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 5551845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // Bail out if RHS and the phi may be mutually interdependent due to a loop. 5561845009290e4d804ad377927bd8a08cca3036adcDuncan Sands if (!ValueDominatesPHI(RHS, PI, DT)) 5571845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return 0; 5581845009290e4d804ad377927bd8a08cca3036adcDuncan Sands 559a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // Evaluate the BinOp on the incoming phi values. 560a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands Value *CommonValue = 0; 561a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands for (unsigned i = 0, e = PI->getNumIncomingValues(); i != e; ++i) { 562552008946530e01efdad15044e1f621883d14a3aDuncan Sands Value *Incoming = PI->getIncomingValue(i); 563ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // If the incoming value is the phi node itself, it can safely be skipped. 564552008946530e01efdad15044e1f621883d14a3aDuncan Sands if (Incoming == PI) continue; 5651845009290e4d804ad377927bd8a08cca3036adcDuncan Sands Value *V = SimplifyCmpInst(Pred, Incoming, RHS, TD, DT, MaxRecurse); 566a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the operation failed to simplify, or simplified to a different value 567a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // to previously, then give up. 568a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands if (!V || (CommonValue && V != CommonValue)) 569a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return 0; 570a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands CommonValue = V; 571a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands } 572a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 573a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return CommonValue; 574a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 575a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 5768aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner/// SimplifyAddInst - Given operands for an Add, see if we can 577d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner/// fold the result. If not, this returns null. 578ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sandsstatic Value *SimplifyAddInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, 579ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands const TargetData *TD, const DominatorTree *DT, 580ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands unsigned MaxRecurse) { 581d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 582d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 583d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Constant *Ops[] = { CLHS, CRHS }; 5848aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner return ConstantFoldInstOperands(Instruction::Add, CLHS->getType(), 5851d2f569c3428d70d0cf690c9adb459ad4a3ecff2Jay Foad Ops, TD); 5868aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner } 58712a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 5888aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner // Canonicalize the constant to the RHS. 5898aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner std::swap(Op0, Op1); 5908aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner } 59112a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 592fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X + undef -> undef 593f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 594fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return Op1; 59512a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 596fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X + 0 -> X 597fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands if (match(Op1, m_Zero())) 598fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return Op0; 599fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 600fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X + (Y - X) -> Y 601fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // (Y - X) + X -> Y 602ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands // Eg: X + -X -> 0 603124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands Value *Y = 0; 604124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (match(Op1, m_Sub(m_Value(Y), m_Specific(Op0))) || 605124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands match(Op0, m_Sub(m_Value(Y), m_Specific(Op1)))) 606fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return Y; 607fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 608fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X + ~X -> -1 since ~X = -X-1 609124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (match(Op0, m_Not(m_Specific(Op1))) || 610124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands match(Op1, m_Not(m_Specific(Op0)))) 611fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return Constant::getAllOnesValue(Op0->getType()); 61287689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands 61382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands /// i1 add -> xor. 61475d289ed6201e82718343d7a36d2a2fa082f6217Duncan Sands if (MaxRecurse && Op0->getType()->isIntegerTy(1)) 61507f30fbd734069b80b90c6aeea0ae645ce3880c0Duncan Sands if (Value *V = SimplifyXorInst(Op0, Op1, TD, DT, MaxRecurse-1)) 61607f30fbd734069b80b90c6aeea0ae645ce3880c0Duncan Sands return V; 61782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 618566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Try some generic simplifications for associative operations. 619566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Value *V = SimplifyAssociativeBinOp(Instruction::Add, Op0, Op1, TD, DT, 620566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands MaxRecurse)) 621566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return V; 622566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 6233421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Mul distributes over Add. Try some generic simplifications based on this. 6243421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = FactorizeBinOp(Instruction::Add, Op0, Op1, Instruction::Mul, 6253421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands TD, DT, MaxRecurse)) 6263421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 6273421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 62887689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // Threading Add over selects and phi nodes is pointless, so don't bother. 62987689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // Threading over the select in "A + select(cond, B, C)" means evaluating 63087689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // "A+B" and "A+C" and seeing if they are equal; but they are equal if and 63187689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // only if B and C are equal. If B and C are equal then (since we assume 63287689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // that operands have already been simplified) "select(cond, B, C)" should 63387689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // have been simplified to the common value of B and C already. Analysing 63487689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // "A+B" and "A+C" thus gains nothing, but costs compile time. Similarly 63587689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // for threading over phi nodes. 63687689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands 6378aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner return 0; 6388aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner} 6398aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner 640ee9a2e322af96accc9e55ed6373c0057453714b1Duncan SandsValue *llvm::SimplifyAddInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, 641ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands const TargetData *TD, const DominatorTree *DT) { 642ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands return ::SimplifyAddInst(Op0, Op1, isNSW, isNUW, TD, DT, RecursionLimit); 643ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands} 644ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands 645fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands/// SimplifySubInst - Given operands for a Sub, see if we can 646fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands/// fold the result. If not, this returns null. 647ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sandsstatic Value *SimplifySubInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, 6483421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands const TargetData *TD, const DominatorTree *DT, 649ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands unsigned MaxRecurse) { 650fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands if (Constant *CLHS = dyn_cast<Constant>(Op0)) 651fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 652fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands Constant *Ops[] = { CLHS, CRHS }; 653fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return ConstantFoldInstOperands(Instruction::Sub, CLHS->getType(), 6541d2f569c3428d70d0cf690c9adb459ad4a3ecff2Jay Foad Ops, TD); 655fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands } 656fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 657fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X - undef -> undef 658fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // undef - X -> undef 659f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op0, m_Undef()) || match(Op1, m_Undef())) 660fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return UndefValue::get(Op0->getType()); 661fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 662fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X - 0 -> X 663fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands if (match(Op1, m_Zero())) 664fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return Op0; 665fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 666fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X - X -> 0 667124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (Op0 == Op1) 668fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return Constant::getNullValue(Op0->getType()); 669fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 670fe02c69f84ad52d42be934e4fe702f03e4991a6aDuncan Sands // (X*2) - X -> X 671fe02c69f84ad52d42be934e4fe702f03e4991a6aDuncan Sands // (X<<1) - X -> X 672b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands Value *X = 0; 673fe02c69f84ad52d42be934e4fe702f03e4991a6aDuncan Sands if (match(Op0, m_Mul(m_Specific(Op1), m_ConstantInt<2>())) || 674fe02c69f84ad52d42be934e4fe702f03e4991a6aDuncan Sands match(Op0, m_Shl(m_Specific(Op1), m_One()))) 675fe02c69f84ad52d42be934e4fe702f03e4991a6aDuncan Sands return Op1; 676fe02c69f84ad52d42be934e4fe702f03e4991a6aDuncan Sands 677b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // (X + Y) - Z -> X + (Y - Z) or Y + (X - Z) if everything simplifies. 678b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // For example, (X + Y) - Y -> X; (Y + X) - Y -> X 679b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands Value *Y = 0, *Z = Op1; 680b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands if (MaxRecurse && match(Op0, m_Add(m_Value(X), m_Value(Y)))) { // (X + Y) - Z 681b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // See if "V === Y - Z" simplifies. 682b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands if (Value *V = SimplifyBinOp(Instruction::Sub, Y, Z, TD, DT, MaxRecurse-1)) 683b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does! Now see if "X + V" simplifies. 684b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands if (Value *W = SimplifyBinOp(Instruction::Add, X, V, TD, DT, 685b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands MaxRecurse-1)) { 686b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does, we successfully reassociated! 687b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands ++NumReassoc; 688b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands return W; 689b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands } 690b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // See if "V === X - Z" simplifies. 691b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands if (Value *V = SimplifyBinOp(Instruction::Sub, X, Z, TD, DT, MaxRecurse-1)) 692b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does! Now see if "Y + V" simplifies. 693b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands if (Value *W = SimplifyBinOp(Instruction::Add, Y, V, TD, DT, 694b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands MaxRecurse-1)) { 695b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does, we successfully reassociated! 696b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands ++NumReassoc; 697b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands return W; 698b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands } 699b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands } 70082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 701b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // X - (Y + Z) -> (X - Y) - Z or (X - Z) - Y if everything simplifies. 702b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // For example, X - (X + 1) -> -1 703b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands X = Op0; 704b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands if (MaxRecurse && match(Op1, m_Add(m_Value(Y), m_Value(Z)))) { // X - (Y + Z) 705b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // See if "V === X - Y" simplifies. 706b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands if (Value *V = SimplifyBinOp(Instruction::Sub, X, Y, TD, DT, MaxRecurse-1)) 707b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does! Now see if "V - Z" simplifies. 708b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands if (Value *W = SimplifyBinOp(Instruction::Sub, V, Z, TD, DT, 709b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands MaxRecurse-1)) { 710b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does, we successfully reassociated! 711b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands ++NumReassoc; 712b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands return W; 713b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands } 714b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // See if "V === X - Z" simplifies. 715b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands if (Value *V = SimplifyBinOp(Instruction::Sub, X, Z, TD, DT, MaxRecurse-1)) 716b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does! Now see if "V - Y" simplifies. 717b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands if (Value *W = SimplifyBinOp(Instruction::Sub, V, Y, TD, DT, 718b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands MaxRecurse-1)) { 719b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does, we successfully reassociated! 720b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands ++NumReassoc; 721b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands return W; 722b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands } 723b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands } 724b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands 725b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // Z - (X - Y) -> (Z - X) + Y if everything simplifies. 726b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // For example, X - (X - Y) -> Y. 727b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands Z = Op0; 728c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands if (MaxRecurse && match(Op1, m_Sub(m_Value(X), m_Value(Y)))) // Z - (X - Y) 729c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands // See if "V === Z - X" simplifies. 730c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands if (Value *V = SimplifyBinOp(Instruction::Sub, Z, X, TD, DT, MaxRecurse-1)) 731b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does! Now see if "V + Y" simplifies. 732c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands if (Value *W = SimplifyBinOp(Instruction::Add, V, Y, TD, DT, 733c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands MaxRecurse-1)) { 734c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands // It does, we successfully reassociated! 735c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands ++NumReassoc; 736c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands return W; 737c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands } 738c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands 7393421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Mul distributes over Sub. Try some generic simplifications based on this. 7403421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = FactorizeBinOp(Instruction::Sub, Op0, Op1, Instruction::Mul, 7413421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands TD, DT, MaxRecurse)) 7423421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 7433421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 744b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // i1 sub -> xor. 745b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands if (MaxRecurse && Op0->getType()->isIntegerTy(1)) 746b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands if (Value *V = SimplifyXorInst(Op0, Op1, TD, DT, MaxRecurse-1)) 747b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands return V; 748b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands 749fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // Threading Sub over selects and phi nodes is pointless, so don't bother. 750fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // Threading over the select in "A - select(cond, B, C)" means evaluating 751fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // "A-B" and "A-C" and seeing if they are equal; but they are equal if and 752fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // only if B and C are equal. If B and C are equal then (since we assume 753fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // that operands have already been simplified) "select(cond, B, C)" should 754fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // have been simplified to the common value of B and C already. Analysing 755fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // "A-B" and "A-C" thus gains nothing, but costs compile time. Similarly 756fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // for threading over phi nodes. 757fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 758fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return 0; 759fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands} 760fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 761ee9a2e322af96accc9e55ed6373c0057453714b1Duncan SandsValue *llvm::SimplifySubInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, 762ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands const TargetData *TD, const DominatorTree *DT) { 763ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands return ::SimplifySubInst(Op0, Op1, isNSW, isNUW, TD, DT, RecursionLimit); 764ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands} 765ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands 76682fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands/// SimplifyMulInst - Given operands for a Mul, see if we can 76782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands/// fold the result. If not, this returns null. 76882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sandsstatic Value *SimplifyMulInst(Value *Op0, Value *Op1, const TargetData *TD, 76982fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands const DominatorTree *DT, unsigned MaxRecurse) { 77082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 77182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 77282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands Constant *Ops[] = { CLHS, CRHS }; 77382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return ConstantFoldInstOperands(Instruction::Mul, CLHS->getType(), 7741d2f569c3428d70d0cf690c9adb459ad4a3ecff2Jay Foad Ops, TD); 77582fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands } 77682fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 77782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // Canonicalize the constant to the RHS. 77882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands std::swap(Op0, Op1); 77982fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands } 78082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 78182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // X * undef -> 0 782f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 78382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return Constant::getNullValue(Op0->getType()); 78482fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 78582fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // X * 0 -> 0 78682fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (match(Op1, m_Zero())) 78782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return Op1; 78882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 78982fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // X * 1 -> X 79082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (match(Op1, m_One())) 79182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return Op0; 79282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 7931895e98ef38afbe011575cc25f4889d96e37421bDuncan Sands // (X / Y) * Y -> X if the division is exact. 7941895e98ef38afbe011575cc25f4889d96e37421bDuncan Sands Value *X = 0, *Y = 0; 795aeaf3d484b4d4c35e8794378c4b6cfbbde718dd1Chris Lattner if ((match(Op0, m_IDiv(m_Value(X), m_Value(Y))) && Y == Op1) || // (X / Y) * Y 796aeaf3d484b4d4c35e8794378c4b6cfbbde718dd1Chris Lattner (match(Op1, m_IDiv(m_Value(X), m_Value(Y))) && Y == Op0)) { // Y * (X / Y) 79732a43cc0fc3cd42702d7859eaa58dd42f561a54dDuncan Sands PossiblyExactOperator *Div = 79832a43cc0fc3cd42702d7859eaa58dd42f561a54dDuncan Sands cast<PossiblyExactOperator>(Y == Op1 ? Op0 : Op1); 799c6ee9181a51fdfa3c07e1e53695681c55aa98ce4Chris Lattner if (Div->isExact()) 8001895e98ef38afbe011575cc25f4889d96e37421bDuncan Sands return X; 8011895e98ef38afbe011575cc25f4889d96e37421bDuncan Sands } 8021895e98ef38afbe011575cc25f4889d96e37421bDuncan Sands 8035413880654585f01ea9880f24f07f27c8da56ba8Nick Lewycky // i1 mul -> and. 80475d289ed6201e82718343d7a36d2a2fa082f6217Duncan Sands if (MaxRecurse && Op0->getType()->isIntegerTy(1)) 80507f30fbd734069b80b90c6aeea0ae645ce3880c0Duncan Sands if (Value *V = SimplifyAndInst(Op0, Op1, TD, DT, MaxRecurse-1)) 80607f30fbd734069b80b90c6aeea0ae645ce3880c0Duncan Sands return V; 80782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 80882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // Try some generic simplifications for associative operations. 80982fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (Value *V = SimplifyAssociativeBinOp(Instruction::Mul, Op0, Op1, TD, DT, 81082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands MaxRecurse)) 81182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return V; 81282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 81382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // Mul distributes over Add. Try some generic simplifications based on this. 81482fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (Value *V = ExpandBinOp(Instruction::Mul, Op0, Op1, Instruction::Add, 81582fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands TD, DT, MaxRecurse)) 81682fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return V; 81782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 81882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // If the operation is with the result of a select instruction, check whether 81982fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // operating on either branch of the select always yields the same value. 82082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) 82182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (Value *V = ThreadBinOpOverSelect(Instruction::Mul, Op0, Op1, TD, DT, 82282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands MaxRecurse)) 82382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return V; 82482fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 82582fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // If the operation is with the result of a phi instruction, check whether 82682fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // operating on all incoming values of the phi always yields the same value. 82782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (isa<PHINode>(Op0) || isa<PHINode>(Op1)) 82882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (Value *V = ThreadBinOpOverPHI(Instruction::Mul, Op0, Op1, TD, DT, 82982fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands MaxRecurse)) 83082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return V; 83182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 83282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return 0; 83382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands} 83482fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 83582fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan SandsValue *llvm::SimplifyMulInst(Value *Op0, Value *Op1, const TargetData *TD, 83682fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands const DominatorTree *DT) { 83782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return ::SimplifyMulInst(Op0, Op1, TD, DT, RecursionLimit); 83882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands} 83982fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 840593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands/// SimplifyDiv - Given operands for an SDiv or UDiv, see if we can 841593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands/// fold the result. If not, this returns null. 842479b4b9ef06dd84097202ffa6aea07913cdf651cAnders Carlssonstatic Value *SimplifyDiv(Instruction::BinaryOps Opcode, Value *Op0, Value *Op1, 843593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands const TargetData *TD, const DominatorTree *DT, 844593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands unsigned MaxRecurse) { 845593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Constant *C0 = dyn_cast<Constant>(Op0)) { 846593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Constant *C1 = dyn_cast<Constant>(Op1)) { 847593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands Constant *Ops[] = { C0, C1 }; 8481d2f569c3428d70d0cf690c9adb459ad4a3ecff2Jay Foad return ConstantFoldInstOperands(Opcode, C0->getType(), Ops, TD); 849593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands } 850593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands } 851593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 852a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands bool isSigned = Opcode == Instruction::SDiv; 853a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands 854593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // X / undef -> undef 855f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 856593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return Op1; 857593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 858593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // undef / X -> 0 859f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op0, m_Undef())) 860593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return Constant::getNullValue(Op0->getType()); 861593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 862593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // 0 / X -> 0, we don't need to preserve faults! 863593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (match(Op0, m_Zero())) 864593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return Op0; 865593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 866593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // X / 1 -> X 867593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (match(Op1, m_One())) 868593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return Op0; 869593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 870593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Op0->getType()->isIntegerTy(1)) 871593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // It can't be division by zero, hence it must be division by one. 872593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return Op0; 873593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 874593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // X / X -> 1 875593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Op0 == Op1) 876593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return ConstantInt::get(Op0->getType(), 1); 877593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 878593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // (X * Y) / Y -> X if the multiplication does not overflow. 879593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands Value *X = 0, *Y = 0; 880593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (match(Op0, m_Mul(m_Value(X), m_Value(Y))) && (X == Op1 || Y == Op1)) { 881593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Y != Op1) std::swap(X, Y); // Ensure expression is (X * Y) / Y, Y = Op1 88232a43cc0fc3cd42702d7859eaa58dd42f561a54dDuncan Sands OverflowingBinaryOperator *Mul = cast<OverflowingBinaryOperator>(Op0); 8834b720718fbda1194f925e0a9d931bc220e8b0e3aDuncan Sands // If the Mul knows it does not overflow, then we are good to go. 8844b720718fbda1194f925e0a9d931bc220e8b0e3aDuncan Sands if ((isSigned && Mul->hasNoSignedWrap()) || 8854b720718fbda1194f925e0a9d931bc220e8b0e3aDuncan Sands (!isSigned && Mul->hasNoUnsignedWrap())) 8864b720718fbda1194f925e0a9d931bc220e8b0e3aDuncan Sands return X; 887593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // If X has the form X = A / Y then X * Y cannot overflow. 888593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (BinaryOperator *Div = dyn_cast<BinaryOperator>(X)) 889593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Div->getOpcode() == Opcode && Div->getOperand(1) == Y) 890593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return X; 891593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands } 892593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 893a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands // (X rem Y) / Y -> 0 894a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands if ((isSigned && match(Op0, m_SRem(m_Value(), m_Specific(Op1)))) || 895a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands (!isSigned && match(Op0, m_URem(m_Value(), m_Specific(Op1))))) 896a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands return Constant::getNullValue(Op0->getType()); 897a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands 898a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands // If the operation is with the result of a select instruction, check whether 899a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands // operating on either branch of the select always yields the same value. 900a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) 901a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands if (Value *V = ThreadBinOpOverSelect(Opcode, Op0, Op1, TD, DT, MaxRecurse)) 902a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands return V; 903a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands 904a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands // If the operation is with the result of a phi instruction, check whether 905a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands // operating on all incoming values of the phi always yields the same value. 906a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands if (isa<PHINode>(Op0) || isa<PHINode>(Op1)) 907a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands if (Value *V = ThreadBinOpOverPHI(Opcode, Op0, Op1, TD, DT, MaxRecurse)) 908a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands return V; 909a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands 910593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return 0; 911593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands} 912593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 913593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands/// SimplifySDivInst - Given operands for an SDiv, see if we can 914593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands/// fold the result. If not, this returns null. 915593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sandsstatic Value *SimplifySDivInst(Value *Op0, Value *Op1, const TargetData *TD, 916593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands const DominatorTree *DT, unsigned MaxRecurse) { 917593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Value *V = SimplifyDiv(Instruction::SDiv, Op0, Op1, TD, DT, MaxRecurse)) 918593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return V; 919593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 920593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return 0; 921593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands} 922593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 923593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan SandsValue *llvm::SimplifySDivInst(Value *Op0, Value *Op1, const TargetData *TD, 9241fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel const DominatorTree *DT) { 925593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return ::SimplifySDivInst(Op0, Op1, TD, DT, RecursionLimit); 926593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands} 927593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 928593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands/// SimplifyUDivInst - Given operands for a UDiv, see if we can 929593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands/// fold the result. If not, this returns null. 930593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sandsstatic Value *SimplifyUDivInst(Value *Op0, Value *Op1, const TargetData *TD, 931593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands const DominatorTree *DT, unsigned MaxRecurse) { 932593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Value *V = SimplifyDiv(Instruction::UDiv, Op0, Op1, TD, DT, MaxRecurse)) 933593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return V; 934593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 935593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return 0; 936593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands} 937593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 938593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan SandsValue *llvm::SimplifyUDivInst(Value *Op0, Value *Op1, const TargetData *TD, 9391fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel const DominatorTree *DT) { 940593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return ::SimplifyUDivInst(Op0, Op1, TD, DT, RecursionLimit); 941593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands} 942593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 943f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sandsstatic Value *SimplifyFDivInst(Value *Op0, Value *Op1, const TargetData *, 944f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands const DominatorTree *, unsigned) { 9451fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel // undef / X -> undef (the undef could be a snan). 946f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op0, m_Undef())) 9471fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel return Op0; 9481fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel 9491fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel // X / undef -> undef 950f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 9511fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel return Op1; 9521fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel 9531fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel return 0; 9541fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel} 9551fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel 9561fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van BommelValue *llvm::SimplifyFDivInst(Value *Op0, Value *Op1, const TargetData *TD, 9571fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel const DominatorTree *DT) { 9581fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel return ::SimplifyFDivInst(Op0, Op1, TD, DT, RecursionLimit); 9591fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel} 9601fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel 961f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands/// SimplifyRem - Given operands for an SRem or URem, see if we can 962f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands/// fold the result. If not, this returns null. 963f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sandsstatic Value *SimplifyRem(Instruction::BinaryOps Opcode, Value *Op0, Value *Op1, 964f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands const TargetData *TD, const DominatorTree *DT, 965f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands unsigned MaxRecurse) { 966f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (Constant *C0 = dyn_cast<Constant>(Op0)) { 967f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (Constant *C1 = dyn_cast<Constant>(Op1)) { 968f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands Constant *Ops[] = { C0, C1 }; 9691d2f569c3428d70d0cf690c9adb459ad4a3ecff2Jay Foad return ConstantFoldInstOperands(Opcode, C0->getType(), Ops, TD); 970f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands } 971f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands } 972f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 973f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // X % undef -> undef 974f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op1, m_Undef())) 975f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Op1; 976f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 977f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // undef % X -> 0 978f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op0, m_Undef())) 979f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Constant::getNullValue(Op0->getType()); 980f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 981f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // 0 % X -> 0, we don't need to preserve faults! 982f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op0, m_Zero())) 983f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Op0; 984f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 985f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // X % 0 -> undef, we don't need to preserve faults! 986f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op1, m_Zero())) 987f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return UndefValue::get(Op0->getType()); 988f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 989f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // X % 1 -> 0 990f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op1, m_One())) 991f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Constant::getNullValue(Op0->getType()); 992f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 993f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (Op0->getType()->isIntegerTy(1)) 994f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // It can't be remainder by zero, hence it must be remainder by one. 995f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Constant::getNullValue(Op0->getType()); 996f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 997f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // X % X -> 0 998f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (Op0 == Op1) 999f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Constant::getNullValue(Op0->getType()); 1000f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1001f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // If the operation is with the result of a select instruction, check whether 1002f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // operating on either branch of the select always yields the same value. 1003f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) 1004f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (Value *V = ThreadBinOpOverSelect(Opcode, Op0, Op1, TD, DT, MaxRecurse)) 1005f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return V; 1006f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1007f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // If the operation is with the result of a phi instruction, check whether 1008f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // operating on all incoming values of the phi always yields the same value. 1009f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (isa<PHINode>(Op0) || isa<PHINode>(Op1)) 1010f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (Value *V = ThreadBinOpOverPHI(Opcode, Op0, Op1, TD, DT, MaxRecurse)) 1011f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return V; 1012f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1013f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return 0; 1014f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1015f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1016f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands/// SimplifySRemInst - Given operands for an SRem, see if we can 1017f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands/// fold the result. If not, this returns null. 1018f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sandsstatic Value *SimplifySRemInst(Value *Op0, Value *Op1, const TargetData *TD, 1019f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands const DominatorTree *DT, unsigned MaxRecurse) { 1020f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (Value *V = SimplifyRem(Instruction::SRem, Op0, Op1, TD, DT, MaxRecurse)) 1021f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return V; 1022f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1023f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return 0; 1024f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1025f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1026f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan SandsValue *llvm::SimplifySRemInst(Value *Op0, Value *Op1, const TargetData *TD, 1027f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands const DominatorTree *DT) { 1028f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return ::SimplifySRemInst(Op0, Op1, TD, DT, RecursionLimit); 1029f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1030f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1031f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands/// SimplifyURemInst - Given operands for a URem, see if we can 1032f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands/// fold the result. If not, this returns null. 1033f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sandsstatic Value *SimplifyURemInst(Value *Op0, Value *Op1, const TargetData *TD, 1034f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands const DominatorTree *DT, unsigned MaxRecurse) { 1035f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (Value *V = SimplifyRem(Instruction::URem, Op0, Op1, TD, DT, MaxRecurse)) 1036f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return V; 1037f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1038f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return 0; 1039f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1040f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1041f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan SandsValue *llvm::SimplifyURemInst(Value *Op0, Value *Op1, const TargetData *TD, 1042f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands const DominatorTree *DT) { 1043f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return ::SimplifyURemInst(Op0, Op1, TD, DT, RecursionLimit); 1044f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1045f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1046f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sandsstatic Value *SimplifyFRemInst(Value *Op0, Value *Op1, const TargetData *, 1047f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands const DominatorTree *, unsigned) { 1048f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // undef % X -> undef (the undef could be a snan). 1049f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op0, m_Undef())) 1050f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Op0; 1051f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1052f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // X % undef -> undef 1053f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op1, m_Undef())) 1054f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Op1; 1055f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1056f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return 0; 1057f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1058f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1059f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan SandsValue *llvm::SimplifyFRemInst(Value *Op0, Value *Op1, const TargetData *TD, 1060f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands const DominatorTree *DT) { 1061f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return ::SimplifyFRemInst(Op0, Op1, TD, DT, RecursionLimit); 1062f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1063f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1064cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands/// SimplifyShift - Given operands for an Shl, LShr or AShr, see if we can 1065c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands/// fold the result. If not, this returns null. 1066cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sandsstatic Value *SimplifyShift(unsigned Opcode, Value *Op0, Value *Op1, 1067cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands const TargetData *TD, const DominatorTree *DT, 1068cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands unsigned MaxRecurse) { 1069c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands if (Constant *C0 = dyn_cast<Constant>(Op0)) { 1070c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands if (Constant *C1 = dyn_cast<Constant>(Op1)) { 1071c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands Constant *Ops[] = { C0, C1 }; 10721d2f569c3428d70d0cf690c9adb459ad4a3ecff2Jay Foad return ConstantFoldInstOperands(Opcode, C0->getType(), Ops, TD); 1073c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands } 1074c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands } 1075c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1076cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // 0 shift by X -> 0 1077c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands if (match(Op0, m_Zero())) 1078c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return Op0; 1079c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1080cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // X shift by 0 -> X 1081c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands if (match(Op1, m_Zero())) 1082c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return Op0; 1083c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1084cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // X shift by undef -> undef because it may shift by the bitwidth. 1085f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 1086c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return Op1; 1087c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1088c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands // Shifting by the bitwidth or more is undefined. 1089c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands if (ConstantInt *CI = dyn_cast<ConstantInt>(Op1)) 1090c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands if (CI->getValue().getLimitedValue() >= 1091c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands Op0->getType()->getScalarSizeInBits()) 1092c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return UndefValue::get(Op0->getType()); 1093c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1094cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // If the operation is with the result of a select instruction, check whether 1095cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // operating on either branch of the select always yields the same value. 1096cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) 1097cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands if (Value *V = ThreadBinOpOverSelect(Opcode, Op0, Op1, TD, DT, MaxRecurse)) 1098cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return V; 1099cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands 1100cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // If the operation is with the result of a phi instruction, check whether 1101cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // operating on all incoming values of the phi always yields the same value. 1102cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands if (isa<PHINode>(Op0) || isa<PHINode>(Op1)) 1103cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands if (Value *V = ThreadBinOpOverPHI(Opcode, Op0, Op1, TD, DT, MaxRecurse)) 1104cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return V; 1105cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands 1106cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return 0; 1107cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands} 1108cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands 1109cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands/// SimplifyShlInst - Given operands for an Shl, see if we can 1110cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands/// fold the result. If not, this returns null. 111181a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattnerstatic Value *SimplifyShlInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, 111281a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner const TargetData *TD, const DominatorTree *DT, 111381a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner unsigned MaxRecurse) { 1114cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands if (Value *V = SimplifyShift(Instruction::Shl, Op0, Op1, TD, DT, MaxRecurse)) 1115cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return V; 1116cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands 1117cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // undef << X -> 0 1118f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op0, m_Undef())) 1119cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return Constant::getNullValue(Op0->getType()); 1120cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands 112181a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner // (X >> A) << A -> X 112281a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Value *X; 112381a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner if (match(Op0, m_Shr(m_Value(X), m_Specific(Op1))) && 112481a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner cast<PossiblyExactOperator>(Op0)->isExact()) 112581a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner return X; 1126c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return 0; 1127c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands} 1128c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 112981a0dc911586c77421c2255aa417dc9b350b9e20Chris LattnerValue *llvm::SimplifyShlInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, 113081a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner const TargetData *TD, const DominatorTree *DT) { 113181a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner return ::SimplifyShlInst(Op0, Op1, isNSW, isNUW, TD, DT, RecursionLimit); 1132c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands} 1133c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1134c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands/// SimplifyLShrInst - Given operands for an LShr, see if we can 1135c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands/// fold the result. If not, this returns null. 113681a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattnerstatic Value *SimplifyLShrInst(Value *Op0, Value *Op1, bool isExact, 113781a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner const TargetData *TD, const DominatorTree *DT, 113881a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner unsigned MaxRecurse) { 1139cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands if (Value *V = SimplifyShift(Instruction::LShr, Op0, Op1, TD, DT, MaxRecurse)) 1140cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return V; 1141c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1142c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands // undef >>l X -> 0 1143f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op0, m_Undef())) 1144c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return Constant::getNullValue(Op0->getType()); 1145c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 114681a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner // (X << A) >> A -> X 114781a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Value *X; 114881a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner if (match(Op0, m_Shl(m_Value(X), m_Specific(Op1))) && 114981a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner cast<OverflowingBinaryOperator>(Op0)->hasNoUnsignedWrap()) 115081a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner return X; 115152fb846578714d14bbde9b28884a6a8729217677Duncan Sands 1152c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return 0; 1153c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands} 1154c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 115581a0dc911586c77421c2255aa417dc9b350b9e20Chris LattnerValue *llvm::SimplifyLShrInst(Value *Op0, Value *Op1, bool isExact, 115681a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner const TargetData *TD, const DominatorTree *DT) { 115781a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner return ::SimplifyLShrInst(Op0, Op1, isExact, TD, DT, RecursionLimit); 1158c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands} 1159c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1160c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands/// SimplifyAShrInst - Given operands for an AShr, see if we can 1161c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands/// fold the result. If not, this returns null. 116281a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattnerstatic Value *SimplifyAShrInst(Value *Op0, Value *Op1, bool isExact, 116381a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner const TargetData *TD, const DominatorTree *DT, 116481a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner unsigned MaxRecurse) { 1165cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands if (Value *V = SimplifyShift(Instruction::AShr, Op0, Op1, TD, DT, MaxRecurse)) 1166cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return V; 1167c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1168c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands // all ones >>a X -> all ones 1169c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands if (match(Op0, m_AllOnes())) 1170c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return Op0; 1171c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1172c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands // undef >>a X -> all ones 1173f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op0, m_Undef())) 1174c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return Constant::getAllOnesValue(Op0->getType()); 1175c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 117681a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner // (X << A) >> A -> X 117781a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Value *X; 117881a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner if (match(Op0, m_Shl(m_Value(X), m_Specific(Op1))) && 117981a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner cast<OverflowingBinaryOperator>(Op0)->hasNoSignedWrap()) 118081a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner return X; 118152fb846578714d14bbde9b28884a6a8729217677Duncan Sands 1182c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return 0; 1183c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands} 1184c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 118581a0dc911586c77421c2255aa417dc9b350b9e20Chris LattnerValue *llvm::SimplifyAShrInst(Value *Op0, Value *Op1, bool isExact, 118681a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner const TargetData *TD, const DominatorTree *DT) { 118781a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner return ::SimplifyAShrInst(Op0, Op1, isExact, TD, DT, RecursionLimit); 1188c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands} 1189c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 11908aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner/// SimplifyAndInst - Given operands for an And, see if we can 11918aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner/// fold the result. If not, this returns null. 1192a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *SimplifyAndInst(Value *Op0, Value *Op1, const TargetData *TD, 11931845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const DominatorTree *DT, unsigned MaxRecurse) { 11948aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 11958aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 11968aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner Constant *Ops[] = { CLHS, CRHS }; 1197d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return ConstantFoldInstOperands(Instruction::And, CLHS->getType(), 11981d2f569c3428d70d0cf690c9adb459ad4a3ecff2Jay Foad Ops, TD); 1199d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 120012a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1201d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // Canonicalize the constant to the RHS. 1202d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner std::swap(Op0, Op1); 1203d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 120412a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1205d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X & undef -> 0 1206f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 1207d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Constant::getNullValue(Op0->getType()); 120812a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1209d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X & X = X 1210124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (Op0 == Op1) 1211d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 121212a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 12132b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // X & 0 = 0 12142b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (match(Op1, m_Zero())) 1215d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op1; 121612a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 12172b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // X & -1 = X 12182b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (match(Op1, m_AllOnes())) 12192b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return Op0; 122012a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1221d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // A & ~A = ~A & A = 0 122281a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner if (match(Op0, m_Not(m_Specific(Op1))) || 122381a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner match(Op1, m_Not(m_Specific(Op0)))) 1224d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Constant::getNullValue(Op0->getType()); 122512a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1226d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // (A | ?) & A = A 122781a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Value *A = 0, *B = 0; 1228d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (match(Op0, m_Or(m_Value(A), m_Value(B))) && 1229124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands (A == Op1 || B == Op1)) 1230d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op1; 123112a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1232d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // A & (A | ?) = A 1233d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (match(Op1, m_Or(m_Value(A), m_Value(B))) && 1234124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands (A == Op0 || B == Op0)) 1235d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 123612a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1237dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands // A & (-A) = A if A is a power of two or zero. 1238dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands if (match(Op0, m_Neg(m_Specific(Op1))) || 1239dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands match(Op1, m_Neg(m_Specific(Op0)))) { 1240dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands if (isPowerOfTwo(Op0, TD, /*OrZero*/true)) 1241dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands return Op0; 1242dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands if (isPowerOfTwo(Op1, TD, /*OrZero*/true)) 1243dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands return Op1; 1244dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands } 1245dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands 1246566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Try some generic simplifications for associative operations. 1247566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Value *V = SimplifyAssociativeBinOp(Instruction::And, Op0, Op1, TD, DT, 1248566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands MaxRecurse)) 1249566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return V; 12506844c8ea5a67e551be7106d6b7b9e1a64eecbe51Benjamin Kramer 12513421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // And distributes over Or. Try some generic simplifications based on this. 12523421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = ExpandBinOp(Instruction::And, Op0, Op1, Instruction::Or, 12533421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands TD, DT, MaxRecurse)) 12543421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 12553421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 12563421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // And distributes over Xor. Try some generic simplifications based on this. 12573421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = ExpandBinOp(Instruction::And, Op0, Op1, Instruction::Xor, 12583421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands TD, DT, MaxRecurse)) 12593421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 12603421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 12613421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Or distributes over And. Try some generic simplifications based on this. 12623421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = FactorizeBinOp(Instruction::And, Op0, Op1, Instruction::Or, 12633421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands TD, DT, MaxRecurse)) 12643421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 12653421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1266b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // If the operation is with the result of a select instruction, check whether 1267b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // operating on either branch of the select always yields the same value. 12680312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) 12691845009290e4d804ad377927bd8a08cca3036adcDuncan Sands if (Value *V = ThreadBinOpOverSelect(Instruction::And, Op0, Op1, TD, DT, 12700312a93693abc2eb682b2b101c889959888fd883Duncan Sands MaxRecurse)) 1271a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return V; 1272a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 1273a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the operation is with the result of a phi instruction, check whether 1274a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // operating on all incoming values of the phi always yields the same value. 12750312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<PHINode>(Op0) || isa<PHINode>(Op1)) 12761845009290e4d804ad377927bd8a08cca3036adcDuncan Sands if (Value *V = ThreadBinOpOverPHI(Instruction::And, Op0, Op1, TD, DT, 12770312a93693abc2eb682b2b101c889959888fd883Duncan Sands MaxRecurse)) 1278b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return V; 1279b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 1280d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return 0; 1281d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner} 12829f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 12831845009290e4d804ad377927bd8a08cca3036adcDuncan SandsValue *llvm::SimplifyAndInst(Value *Op0, Value *Op1, const TargetData *TD, 12841845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const DominatorTree *DT) { 12851845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return ::SimplifyAndInst(Op0, Op1, TD, DT, RecursionLimit); 1286a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 1287a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 1288d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner/// SimplifyOrInst - Given operands for an Or, see if we can 12899f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner/// fold the result. If not, this returns null. 1290a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *SimplifyOrInst(Value *Op0, Value *Op1, const TargetData *TD, 12911845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const DominatorTree *DT, unsigned MaxRecurse) { 1292d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 1293d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 1294d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Constant *Ops[] = { CLHS, CRHS }; 1295d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return ConstantFoldInstOperands(Instruction::Or, CLHS->getType(), 12961d2f569c3428d70d0cf690c9adb459ad4a3ecff2Jay Foad Ops, TD); 1297d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 129812a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1299d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // Canonicalize the constant to the RHS. 1300d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner std::swap(Op0, Op1); 1301d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 130212a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1303d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X | undef -> -1 1304f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 1305d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Constant::getAllOnesValue(Op0->getType()); 130612a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1307d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X | X = X 1308124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (Op0 == Op1) 1309d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 1310d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 13112b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // X | 0 = X 13122b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (match(Op1, m_Zero())) 1313d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 131412a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 13152b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // X | -1 = -1 13162b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (match(Op1, m_AllOnes())) 13172b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return Op1; 131812a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1319d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // A | ~A = ~A | A = -1 132081a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner if (match(Op0, m_Not(m_Specific(Op1))) || 132181a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner match(Op1, m_Not(m_Specific(Op0)))) 1322d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Constant::getAllOnesValue(Op0->getType()); 132312a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1324d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // (A & ?) | A = A 132581a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Value *A = 0, *B = 0; 1326d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (match(Op0, m_And(m_Value(A), m_Value(B))) && 1327124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands (A == Op1 || B == Op1)) 1328d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op1; 132912a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1330d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // A | (A & ?) = A 1331d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (match(Op1, m_And(m_Value(A), m_Value(B))) && 1332124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands (A == Op0 || B == Op0)) 1333d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 133412a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 133538f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer // ~(A & ?) | A = -1 133638f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer if (match(Op0, m_Not(m_And(m_Value(A), m_Value(B)))) && 133738f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer (A == Op1 || B == Op1)) 133838f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer return Constant::getAllOnesValue(Op1->getType()); 133938f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer 134038f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer // A | ~(A & ?) = -1 134138f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer if (match(Op1, m_Not(m_And(m_Value(A), m_Value(B)))) && 134238f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer (A == Op0 || B == Op0)) 134338f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer return Constant::getAllOnesValue(Op0->getType()); 134438f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer 1345566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Try some generic simplifications for associative operations. 1346566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Value *V = SimplifyAssociativeBinOp(Instruction::Or, Op0, Op1, TD, DT, 1347566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands MaxRecurse)) 1348566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return V; 13496844c8ea5a67e551be7106d6b7b9e1a64eecbe51Benjamin Kramer 13503421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Or distributes over And. Try some generic simplifications based on this. 13513421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = ExpandBinOp(Instruction::Or, Op0, Op1, Instruction::And, 13523421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands TD, DT, MaxRecurse)) 13533421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 13543421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 13553421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // And distributes over Or. Try some generic simplifications based on this. 13563421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = FactorizeBinOp(Instruction::Or, Op0, Op1, Instruction::And, 13573421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands TD, DT, MaxRecurse)) 13583421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 13593421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1360b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // If the operation is with the result of a select instruction, check whether 1361b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // operating on either branch of the select always yields the same value. 13620312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) 13631845009290e4d804ad377927bd8a08cca3036adcDuncan Sands if (Value *V = ThreadBinOpOverSelect(Instruction::Or, Op0, Op1, TD, DT, 13640312a93693abc2eb682b2b101c889959888fd883Duncan Sands MaxRecurse)) 1365a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return V; 1366a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 1367a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the operation is with the result of a phi instruction, check whether 1368a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // operating on all incoming values of the phi always yields the same value. 13690312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<PHINode>(Op0) || isa<PHINode>(Op1)) 13701845009290e4d804ad377927bd8a08cca3036adcDuncan Sands if (Value *V = ThreadBinOpOverPHI(Instruction::Or, Op0, Op1, TD, DT, 13710312a93693abc2eb682b2b101c889959888fd883Duncan Sands MaxRecurse)) 1372b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return V; 1373b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 13749f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner return 0; 13759f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner} 13769f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 13771845009290e4d804ad377927bd8a08cca3036adcDuncan SandsValue *llvm::SimplifyOrInst(Value *Op0, Value *Op1, const TargetData *TD, 13781845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const DominatorTree *DT) { 13791845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return ::SimplifyOrInst(Op0, Op1, TD, DT, RecursionLimit); 1380a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 1381d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 13822b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands/// SimplifyXorInst - Given operands for a Xor, see if we can 13832b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands/// fold the result. If not, this returns null. 13842b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sandsstatic Value *SimplifyXorInst(Value *Op0, Value *Op1, const TargetData *TD, 13852b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands const DominatorTree *DT, unsigned MaxRecurse) { 13862b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 13872b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 13882b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands Constant *Ops[] = { CLHS, CRHS }; 13892b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return ConstantFoldInstOperands(Instruction::Xor, CLHS->getType(), 13901d2f569c3428d70d0cf690c9adb459ad4a3ecff2Jay Foad Ops, TD); 13912b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands } 13922b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 13932b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // Canonicalize the constant to the RHS. 13942b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands std::swap(Op0, Op1); 13952b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands } 13962b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 13972b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // A ^ undef -> undef 1398f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 1399f8b1a5ea9602bb65a5cf59d3d34f2851a08cdc3eDuncan Sands return Op1; 14002b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 14012b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // A ^ 0 = A 14022b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (match(Op1, m_Zero())) 14032b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return Op0; 14042b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 1405f23d4adbfaf870d5fa67c6bff0da7891d3a98f9dEli Friedman // A ^ A = 0 1406f23d4adbfaf870d5fa67c6bff0da7891d3a98f9dEli Friedman if (Op0 == Op1) 1407f23d4adbfaf870d5fa67c6bff0da7891d3a98f9dEli Friedman return Constant::getNullValue(Op0->getType()); 1408f23d4adbfaf870d5fa67c6bff0da7891d3a98f9dEli Friedman 14092b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // A ^ ~A = ~A ^ A = -1 141081a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner if (match(Op0, m_Not(m_Specific(Op1))) || 141181a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner match(Op1, m_Not(m_Specific(Op0)))) 14122b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return Constant::getAllOnesValue(Op0->getType()); 14132b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 1414566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Try some generic simplifications for associative operations. 1415566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Value *V = SimplifyAssociativeBinOp(Instruction::Xor, Op0, Op1, TD, DT, 1416566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands MaxRecurse)) 1417566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return V; 14182b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 14193421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // And distributes over Xor. Try some generic simplifications based on this. 14203421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = FactorizeBinOp(Instruction::Xor, Op0, Op1, Instruction::And, 14213421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands TD, DT, MaxRecurse)) 14223421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 14233421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 142487689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // Threading Xor over selects and phi nodes is pointless, so don't bother. 142587689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // Threading over the select in "A ^ select(cond, B, C)" means evaluating 142687689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // "A^B" and "A^C" and seeing if they are equal; but they are equal if and 142787689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // only if B and C are equal. If B and C are equal then (since we assume 142887689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // that operands have already been simplified) "select(cond, B, C)" should 142987689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // have been simplified to the common value of B and C already. Analysing 143087689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // "A^B" and "A^C" thus gains nothing, but costs compile time. Similarly 143187689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // for threading over phi nodes. 14322b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 14332b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return 0; 14342b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands} 14352b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 14362b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan SandsValue *llvm::SimplifyXorInst(Value *Op0, Value *Op1, const TargetData *TD, 14372b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands const DominatorTree *DT) { 14382b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return ::SimplifyXorInst(Op0, Op1, TD, DT, RecursionLimit); 14392b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands} 14402b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 1441db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattnerstatic Type *GetCompareTy(Value *Op) { 1442210c5d4880b525e064088b6fec713260128c16ebChris Lattner return CmpInst::makeCmpResultType(Op->getType()); 1443210c5d4880b525e064088b6fec713260128c16ebChris Lattner} 1444210c5d4880b525e064088b6fec713260128c16ebChris Lattner 1445e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands/// ExtractEquivalentCondition - Rummage around inside V looking for something 1446e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands/// equivalent to the comparison "LHS Pred RHS". Return such a value if found, 1447e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands/// otherwise return null. Helper function for analyzing max/min idioms. 1448e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sandsstatic Value *ExtractEquivalentCondition(Value *V, CmpInst::Predicate Pred, 1449e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands Value *LHS, Value *RHS) { 1450e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands SelectInst *SI = dyn_cast<SelectInst>(V); 1451e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (!SI) 1452e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return 0; 1453e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands CmpInst *Cmp = dyn_cast<CmpInst>(SI->getCondition()); 1454e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (!Cmp) 1455e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return 0; 1456e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands Value *CmpLHS = Cmp->getOperand(0), *CmpRHS = Cmp->getOperand(1); 1457e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Pred == Cmp->getPredicate() && LHS == CmpLHS && RHS == CmpRHS) 1458e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return Cmp; 1459e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Pred == CmpInst::getSwappedPredicate(Cmp->getPredicate()) && 1460e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands LHS == CmpRHS && RHS == CmpLHS) 1461e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return Cmp; 1462e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return 0; 1463e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands} 1464e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands 14659dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// SimplifyICmpInst - Given operands for an ICmpInst, see if we can 14669dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// fold the result. If not, this returns null. 1467a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS, 14681845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const TargetData *TD, const DominatorTree *DT, 14691845009290e4d804ad377927bd8a08cca3036adcDuncan Sands unsigned MaxRecurse) { 14709f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner CmpInst::Predicate Pred = (CmpInst::Predicate)Predicate; 14719dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner assert(CmpInst::isIntPredicate(Pred) && "Not an integer compare!"); 147212a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1473d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(LHS)) { 14748f73deaa8732a556046bf4ac6207be55972e3b74Chris Lattner if (Constant *CRHS = dyn_cast<Constant>(RHS)) 14758f73deaa8732a556046bf4ac6207be55972e3b74Chris Lattner return ConstantFoldCompareInstOperands(Pred, CLHS, CRHS, TD); 1476d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 1477d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // If we have a constant, make sure it is on the RHS. 1478d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner std::swap(LHS, RHS); 1479d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Pred = CmpInst::getSwappedPredicate(Pred); 1480d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 148112a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1482db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *ITy = GetCompareTy(LHS); // The return type. 1483db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *OpTy = LHS->getType(); // The operand type. 148412a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1485210c5d4880b525e064088b6fec713260128c16ebChris Lattner // icmp X, X -> true/false 1486c8e14b3d37b80abb6adb4b831af0452d9ecbf2b2Chris Lattner // X icmp undef -> true/false. For example, icmp ugt %X, undef -> false 1487c8e14b3d37b80abb6adb4b831af0452d9ecbf2b2Chris Lattner // because X could be 0. 1488124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (LHS == RHS || isa<UndefValue>(RHS)) 1489210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(ITy, CmpInst::isTrueWhenEqual(Pred)); 149012a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 14916dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // Special case logic when the operands have i1 type. 14926dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (OpTy->isIntegerTy(1) || (OpTy->isVectorTy() && 14936dc91253ab1872e118b08511a09d5c934988354eDuncan Sands cast<VectorType>(OpTy)->getElementType()->isIntegerTy(1))) { 14946dc91253ab1872e118b08511a09d5c934988354eDuncan Sands switch (Pred) { 14956dc91253ab1872e118b08511a09d5c934988354eDuncan Sands default: break; 14966dc91253ab1872e118b08511a09d5c934988354eDuncan Sands case ICmpInst::ICMP_EQ: 14976dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // X == 1 -> X 14986dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (match(RHS, m_One())) 14996dc91253ab1872e118b08511a09d5c934988354eDuncan Sands return LHS; 15006dc91253ab1872e118b08511a09d5c934988354eDuncan Sands break; 15016dc91253ab1872e118b08511a09d5c934988354eDuncan Sands case ICmpInst::ICMP_NE: 15026dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // X != 0 -> X 15036dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (match(RHS, m_Zero())) 15046dc91253ab1872e118b08511a09d5c934988354eDuncan Sands return LHS; 15056dc91253ab1872e118b08511a09d5c934988354eDuncan Sands break; 15066dc91253ab1872e118b08511a09d5c934988354eDuncan Sands case ICmpInst::ICMP_UGT: 15076dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // X >u 0 -> X 15086dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (match(RHS, m_Zero())) 15096dc91253ab1872e118b08511a09d5c934988354eDuncan Sands return LHS; 15106dc91253ab1872e118b08511a09d5c934988354eDuncan Sands break; 15116dc91253ab1872e118b08511a09d5c934988354eDuncan Sands case ICmpInst::ICMP_UGE: 15126dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // X >=u 1 -> X 15136dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (match(RHS, m_One())) 15146dc91253ab1872e118b08511a09d5c934988354eDuncan Sands return LHS; 15156dc91253ab1872e118b08511a09d5c934988354eDuncan Sands break; 15166dc91253ab1872e118b08511a09d5c934988354eDuncan Sands case ICmpInst::ICMP_SLT: 15176dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // X <s 0 -> X 15186dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (match(RHS, m_Zero())) 15196dc91253ab1872e118b08511a09d5c934988354eDuncan Sands return LHS; 15206dc91253ab1872e118b08511a09d5c934988354eDuncan Sands break; 15216dc91253ab1872e118b08511a09d5c934988354eDuncan Sands case ICmpInst::ICMP_SLE: 15226dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // X <=s -1 -> X 15236dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (match(RHS, m_One())) 15246dc91253ab1872e118b08511a09d5c934988354eDuncan Sands return LHS; 15256dc91253ab1872e118b08511a09d5c934988354eDuncan Sands break; 15266dc91253ab1872e118b08511a09d5c934988354eDuncan Sands } 15276dc91253ab1872e118b08511a09d5c934988354eDuncan Sands } 152812a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1529d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands // icmp <alloca*>, <global/alloca*/null> - Different stack variables have 1530d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands // different addresses, and what's more the address of a stack variable is 1531d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands // never null or equal to the address of a global. Note that generalizing 1532d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands // to the case where LHS is a global variable address or null is pointless, 1533d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands // since if both LHS and RHS are constants then we already constant folded 1534d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands // the compare, and if only one of them is then we moved it to RHS already. 1535d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (isa<AllocaInst>(LHS) && (isa<GlobalValue>(RHS) || isa<AllocaInst>(RHS) || 1536d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands isa<ConstantPointerNull>(RHS))) 153758bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky // We already know that LHS != RHS. 1538d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands return ConstantInt::get(ITy, CmpInst::isFalseWhenEqual(Pred)); 1539d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands 1540d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands // If we are comparing with zero then try hard since this is a common case. 1541d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (match(RHS, m_Zero())) { 1542d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands bool LHSKnownNonNegative, LHSKnownNegative; 1543d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands switch (Pred) { 1544d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands default: 1545d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands assert(false && "Unknown ICmp predicate!"); 1546d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_ULT: 1547f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 1548d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_UGE: 1549f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 1550d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_EQ: 1551d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_ULE: 1552d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (isKnownNonZero(LHS, TD)) 1553f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 1554d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands break; 1555d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_NE: 1556d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_UGT: 1557d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (isKnownNonZero(LHS, TD)) 1558f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 1559d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands break; 1560d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_SLT: 1561d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, TD); 1562d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNegative) 1563f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 1564d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNonNegative) 1565f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 1566d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands break; 1567d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_SLE: 1568d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, TD); 1569d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNegative) 1570f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 1571d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNonNegative && isKnownNonZero(LHS, TD)) 1572f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 1573d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands break; 1574d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_SGE: 1575d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, TD); 1576d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNegative) 1577f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 1578d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNonNegative) 1579f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 1580d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands break; 1581d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_SGT: 1582d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, TD); 1583d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNegative) 1584f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 1585d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNonNegative && isKnownNonZero(LHS, TD)) 1586f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 1587d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands break; 1588d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands } 1589d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands } 1590d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands 1591d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands // See if we are doing a comparison with a constant integer. 1592210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) { 15933a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // Rule out tautological comparisons (eg., ult 0 or uge 0). 15943a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky ConstantRange RHS_CR = ICmpInst::makeConstantRange(Pred, CI->getValue()); 15953a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (RHS_CR.isEmptySet()) 15963a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky return ConstantInt::getFalse(CI->getContext()); 15973a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (RHS_CR.isFullSet()) 15983a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky return ConstantInt::getTrue(CI->getContext()); 15993a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky 16003a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // Many binary operators with constant RHS have easy to compute constant 16013a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // range. Use them to check whether the comparison is a tautology. 16023a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky uint32_t Width = CI->getBitWidth(); 16033a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt Lower = APInt(Width, 0); 16043a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt Upper = APInt(Width, 0); 16053a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky ConstantInt *CI2; 16063a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (match(LHS, m_URem(m_Value(), m_ConstantInt(CI2)))) { 16073a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'urem x, CI2' produces [0, CI2). 16083a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = CI2->getValue(); 16093a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_SRem(m_Value(), m_ConstantInt(CI2)))) { 16103a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'srem x, CI2' produces (-|CI2|, |CI2|). 16113a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = CI2->getValue().abs(); 16123a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Lower = (-Upper) + 1; 1613c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands } else if (match(LHS, m_UDiv(m_ConstantInt(CI2), m_Value()))) { 1614c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands // 'udiv CI2, x' produces [0, CI2]. 16157781ae5be570940178295f6f808215089a3fe411Eli Friedman Upper = CI2->getValue() + 1; 16163a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_UDiv(m_Value(), m_ConstantInt(CI2)))) { 16173a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'udiv x, CI2' produces [0, UINT_MAX / CI2]. 16183a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt NegOne = APInt::getAllOnesValue(Width); 16193a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (!CI2->isZero()) 16203a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = NegOne.udiv(CI2->getValue()) + 1; 16213a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_SDiv(m_Value(), m_ConstantInt(CI2)))) { 16223a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'sdiv x, CI2' produces [INT_MIN / CI2, INT_MAX / CI2]. 16233a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt IntMin = APInt::getSignedMinValue(Width); 16243a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt IntMax = APInt::getSignedMaxValue(Width); 16253a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt Val = CI2->getValue().abs(); 16263a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (!Val.isMinValue()) { 16273a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Lower = IntMin.sdiv(Val); 16283a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = IntMax.sdiv(Val) + 1; 16293a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } 16303a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_LShr(m_Value(), m_ConstantInt(CI2)))) { 16313a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'lshr x, CI2' produces [0, UINT_MAX >> CI2]. 16323a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt NegOne = APInt::getAllOnesValue(Width); 16333a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (CI2->getValue().ult(Width)) 16343a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = NegOne.lshr(CI2->getValue()) + 1; 16353a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_AShr(m_Value(), m_ConstantInt(CI2)))) { 16363a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'ashr x, CI2' produces [INT_MIN >> CI2, INT_MAX >> CI2]. 16373a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt IntMin = APInt::getSignedMinValue(Width); 16383a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt IntMax = APInt::getSignedMaxValue(Width); 16393a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (CI2->getValue().ult(Width)) { 16403a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Lower = IntMin.ashr(CI2->getValue()); 16413a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = IntMax.ashr(CI2->getValue()) + 1; 16423a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } 16433a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_Or(m_Value(), m_ConstantInt(CI2)))) { 16443a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'or x, CI2' produces [CI2, UINT_MAX]. 16453a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Lower = CI2->getValue(); 16463a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_And(m_Value(), m_ConstantInt(CI2)))) { 16473a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'and x, CI2' produces [0, CI2]. 16483a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = CI2->getValue() + 1; 16493a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } 16503a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (Lower != Upper) { 16513a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky ConstantRange LHS_CR = ConstantRange(Lower, Upper); 16523a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (RHS_CR.contains(LHS_CR)) 16533a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky return ConstantInt::getTrue(RHS->getContext()); 16543a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (RHS_CR.inverse().contains(LHS_CR)) 16553a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky return ConstantInt::getFalse(RHS->getContext()); 1656210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 1657210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 16581ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands 16599d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Compare of cast, for example (zext X) != 0 -> X != 0 16609d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (isa<CastInst>(LHS) && (isa<Constant>(RHS) || isa<CastInst>(RHS))) { 16619d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Instruction *LI = cast<CastInst>(LHS); 16629d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Value *SrcOp = LI->getOperand(0); 1663db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *SrcTy = SrcOp->getType(); 1664db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *DstTy = LI->getType(); 16659d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 16669d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Turn icmp (ptrtoint x), (ptrtoint/constant) into a compare of the input 16679d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // if the integer type is the same size as the pointer type. 16689d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (MaxRecurse && TD && isa<PtrToIntInst>(LI) && 16699d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands TD->getPointerSizeInBits() == DstTy->getPrimitiveSizeInBits()) { 16709d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Constant *RHSC = dyn_cast<Constant>(RHS)) { 16719d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Transfer the cast to the constant. 16729d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(Pred, SrcOp, 16739d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantExpr::getIntToPtr(RHSC, SrcTy), 16749d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands TD, DT, MaxRecurse-1)) 16759d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 16769d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } else if (PtrToIntInst *RI = dyn_cast<PtrToIntInst>(RHS)) { 16779d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (RI->getOperand(0)->getType() == SrcTy) 16789d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Compare without the cast. 16799d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(Pred, SrcOp, RI->getOperand(0), 16809d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands TD, DT, MaxRecurse-1)) 16819d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 16829d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 16839d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 16849d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 16859d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (isa<ZExtInst>(LHS)) { 16869d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Turn icmp (zext X), (zext Y) into a compare of X and Y if they have the 16879d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // same type. 16889d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (ZExtInst *RI = dyn_cast<ZExtInst>(RHS)) { 16899d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (MaxRecurse && SrcTy == RI->getOperand(0)->getType()) 16909d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Compare X and Y. Note that signed predicates become unsigned. 16919d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(ICmpInst::getUnsignedPredicate(Pred), 16929d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands SrcOp, RI->getOperand(0), TD, DT, 16939d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands MaxRecurse-1)) 16949d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 16959d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 16969d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Turn icmp (zext X), Cst into a compare of X and Cst if Cst is extended 16979d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // too. If not, then try to deduce the result of the comparison. 16989d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands else if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) { 16999d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Compute the constant that would happen if we truncated to SrcTy then 17009d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // reextended to DstTy. 17019d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant *Trunc = ConstantExpr::getTrunc(CI, SrcTy); 17029d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant *RExt = ConstantExpr::getCast(CastInst::ZExt, Trunc, DstTy); 17039d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 17049d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // If the re-extended constant didn't change then this is effectively 17059d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // also a case of comparing two zero-extended values. 17069d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (RExt == CI && MaxRecurse) 17079d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(ICmpInst::getUnsignedPredicate(Pred), 17089d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands SrcOp, Trunc, TD, DT, MaxRecurse-1)) 17099d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 17109d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 17119d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Otherwise the upper bits of LHS are zero while RHS has a non-zero bit 17129d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // there. Use this to work out the result of the comparison. 17139d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (RExt != CI) { 17149d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands switch (Pred) { 17159d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands default: 17169d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands assert(false && "Unknown ICmp predicate!"); 17179d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // LHS <u RHS. 17189d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_EQ: 17199d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_UGT: 17209d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_UGE: 17219d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return ConstantInt::getFalse(CI->getContext()); 17229d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 17239d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_NE: 17249d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_ULT: 17259d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_ULE: 17269d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return ConstantInt::getTrue(CI->getContext()); 17279d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 17289d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // LHS is non-negative. If RHS is negative then LHS >s LHS. If RHS 17299d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // is non-negative then LHS <s RHS. 17309d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SGT: 17319d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SGE: 17329d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return CI->getValue().isNegative() ? 17339d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getTrue(CI->getContext()) : 17349d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getFalse(CI->getContext()); 17359d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 17369d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SLT: 17379d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SLE: 17389d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return CI->getValue().isNegative() ? 17399d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getFalse(CI->getContext()) : 17409d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getTrue(CI->getContext()); 17419d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 17429d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 17439d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 17449d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 17459d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 17469d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (isa<SExtInst>(LHS)) { 17479d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Turn icmp (sext X), (sext Y) into a compare of X and Y if they have the 17489d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // same type. 17499d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (SExtInst *RI = dyn_cast<SExtInst>(RHS)) { 17509d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (MaxRecurse && SrcTy == RI->getOperand(0)->getType()) 17519d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Compare X and Y. Note that the predicate does not change. 17529d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(Pred, SrcOp, RI->getOperand(0), 17539d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands TD, DT, MaxRecurse-1)) 17549d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 17559d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 17569d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Turn icmp (sext X), Cst into a compare of X and Cst if Cst is extended 17579d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // too. If not, then try to deduce the result of the comparison. 17589d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands else if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) { 17599d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Compute the constant that would happen if we truncated to SrcTy then 17609d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // reextended to DstTy. 17619d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant *Trunc = ConstantExpr::getTrunc(CI, SrcTy); 17629d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant *RExt = ConstantExpr::getCast(CastInst::SExt, Trunc, DstTy); 17639d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 17649d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // If the re-extended constant didn't change then this is effectively 17659d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // also a case of comparing two sign-extended values. 17669d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (RExt == CI && MaxRecurse) 17679d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(Pred, SrcOp, Trunc, TD, DT, 17689d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands MaxRecurse-1)) 17699d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 17709d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 17719d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Otherwise the upper bits of LHS are all equal, while RHS has varying 17729d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // bits there. Use this to work out the result of the comparison. 17739d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (RExt != CI) { 17749d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands switch (Pred) { 17759d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands default: 17769d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands assert(false && "Unknown ICmp predicate!"); 17779d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_EQ: 17789d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return ConstantInt::getFalse(CI->getContext()); 17799d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_NE: 17809d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return ConstantInt::getTrue(CI->getContext()); 17819d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 17829d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // If RHS is non-negative then LHS <s RHS. If RHS is negative then 17839d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // LHS >s RHS. 17849d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SGT: 17859d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SGE: 17869d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return CI->getValue().isNegative() ? 17879d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getTrue(CI->getContext()) : 17889d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getFalse(CI->getContext()); 17899d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SLT: 17909d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SLE: 17919d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return CI->getValue().isNegative() ? 17929d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getFalse(CI->getContext()) : 17939d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getTrue(CI->getContext()); 17949d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 17959d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // If LHS is non-negative then LHS <u RHS. If LHS is negative then 17969d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // LHS >u RHS. 17979d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_UGT: 17989d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_UGE: 17999d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Comparison is true iff the LHS <s 0. 18009d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (MaxRecurse) 18019d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(ICmpInst::ICMP_SLT, SrcOp, 18029d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant::getNullValue(SrcTy), 18039d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands TD, DT, MaxRecurse-1)) 18049d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 18059d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands break; 18069d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_ULT: 18079d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_ULE: 18089d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Comparison is true iff the LHS >=s 0. 18099d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (MaxRecurse) 18109d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(ICmpInst::ICMP_SGE, SrcOp, 18119d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant::getNullValue(SrcTy), 18129d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands TD, DT, MaxRecurse-1)) 18139d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 18149d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands break; 18159d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 18169d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 18179d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 18189d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 18199d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 18209d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 182152fb846578714d14bbde9b28884a6a8729217677Duncan Sands // Special logic for binary operators. 182252fb846578714d14bbde9b28884a6a8729217677Duncan Sands BinaryOperator *LBO = dyn_cast<BinaryOperator>(LHS); 182352fb846578714d14bbde9b28884a6a8729217677Duncan Sands BinaryOperator *RBO = dyn_cast<BinaryOperator>(RHS); 182452fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (MaxRecurse && (LBO || RBO)) { 182552fb846578714d14bbde9b28884a6a8729217677Duncan Sands // Analyze the case when either LHS or RHS is an add instruction. 182652fb846578714d14bbde9b28884a6a8729217677Duncan Sands Value *A = 0, *B = 0, *C = 0, *D = 0; 182752fb846578714d14bbde9b28884a6a8729217677Duncan Sands // LHS = A + B (or A and B are null); RHS = C + D (or C and D are null). 182852fb846578714d14bbde9b28884a6a8729217677Duncan Sands bool NoLHSWrapProblem = false, NoRHSWrapProblem = false; 182952fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (LBO && LBO->getOpcode() == Instruction::Add) { 183052fb846578714d14bbde9b28884a6a8729217677Duncan Sands A = LBO->getOperand(0); B = LBO->getOperand(1); 183152fb846578714d14bbde9b28884a6a8729217677Duncan Sands NoLHSWrapProblem = ICmpInst::isEquality(Pred) || 183252fb846578714d14bbde9b28884a6a8729217677Duncan Sands (CmpInst::isUnsigned(Pred) && LBO->hasNoUnsignedWrap()) || 183352fb846578714d14bbde9b28884a6a8729217677Duncan Sands (CmpInst::isSigned(Pred) && LBO->hasNoSignedWrap()); 183452fb846578714d14bbde9b28884a6a8729217677Duncan Sands } 183552fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (RBO && RBO->getOpcode() == Instruction::Add) { 183652fb846578714d14bbde9b28884a6a8729217677Duncan Sands C = RBO->getOperand(0); D = RBO->getOperand(1); 183752fb846578714d14bbde9b28884a6a8729217677Duncan Sands NoRHSWrapProblem = ICmpInst::isEquality(Pred) || 183852fb846578714d14bbde9b28884a6a8729217677Duncan Sands (CmpInst::isUnsigned(Pred) && RBO->hasNoUnsignedWrap()) || 183952fb846578714d14bbde9b28884a6a8729217677Duncan Sands (CmpInst::isSigned(Pred) && RBO->hasNoSignedWrap()); 184052fb846578714d14bbde9b28884a6a8729217677Duncan Sands } 184152fb846578714d14bbde9b28884a6a8729217677Duncan Sands 184252fb846578714d14bbde9b28884a6a8729217677Duncan Sands // icmp (X+Y), X -> icmp Y, 0 for equalities or if there is no overflow. 184352fb846578714d14bbde9b28884a6a8729217677Duncan Sands if ((A == RHS || B == RHS) && NoLHSWrapProblem) 184452fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (Value *V = SimplifyICmpInst(Pred, A == RHS ? B : A, 184552fb846578714d14bbde9b28884a6a8729217677Duncan Sands Constant::getNullValue(RHS->getType()), 184652fb846578714d14bbde9b28884a6a8729217677Duncan Sands TD, DT, MaxRecurse-1)) 184752fb846578714d14bbde9b28884a6a8729217677Duncan Sands return V; 184852fb846578714d14bbde9b28884a6a8729217677Duncan Sands 184952fb846578714d14bbde9b28884a6a8729217677Duncan Sands // icmp X, (X+Y) -> icmp 0, Y for equalities or if there is no overflow. 185052fb846578714d14bbde9b28884a6a8729217677Duncan Sands if ((C == LHS || D == LHS) && NoRHSWrapProblem) 185152fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (Value *V = SimplifyICmpInst(Pred, 185252fb846578714d14bbde9b28884a6a8729217677Duncan Sands Constant::getNullValue(LHS->getType()), 185352fb846578714d14bbde9b28884a6a8729217677Duncan Sands C == LHS ? D : C, TD, DT, MaxRecurse-1)) 185452fb846578714d14bbde9b28884a6a8729217677Duncan Sands return V; 185552fb846578714d14bbde9b28884a6a8729217677Duncan Sands 185652fb846578714d14bbde9b28884a6a8729217677Duncan Sands // icmp (X+Y), (X+Z) -> icmp Y,Z for equalities or if there is no overflow. 185752fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (A && C && (A == C || A == D || B == C || B == D) && 185852fb846578714d14bbde9b28884a6a8729217677Duncan Sands NoLHSWrapProblem && NoRHSWrapProblem) { 185952fb846578714d14bbde9b28884a6a8729217677Duncan Sands // Determine Y and Z in the form icmp (X+Y), (X+Z). 186052fb846578714d14bbde9b28884a6a8729217677Duncan Sands Value *Y = (A == C || A == D) ? B : A; 186152fb846578714d14bbde9b28884a6a8729217677Duncan Sands Value *Z = (C == A || C == B) ? D : C; 186252fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (Value *V = SimplifyICmpInst(Pred, Y, Z, TD, DT, MaxRecurse-1)) 186352fb846578714d14bbde9b28884a6a8729217677Duncan Sands return V; 186452fb846578714d14bbde9b28884a6a8729217677Duncan Sands } 186552fb846578714d14bbde9b28884a6a8729217677Duncan Sands } 186652fb846578714d14bbde9b28884a6a8729217677Duncan Sands 186784dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky if (LBO && match(LBO, m_URem(m_Value(), m_Specific(RHS)))) { 1868786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky bool KnownNonNegative, KnownNegative; 186988cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky switch (Pred) { 187088cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky default: 187188cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky break; 1872786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky case ICmpInst::ICMP_SGT: 1873786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky case ICmpInst::ICMP_SGE: 1874786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky ComputeSignBit(LHS, KnownNonNegative, KnownNegative, TD); 1875786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky if (!KnownNonNegative) 1876786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky break; 1877786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky // fall-through 187888cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky case ICmpInst::ICMP_EQ: 187988cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky case ICmpInst::ICMP_UGT: 188088cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky case ICmpInst::ICMP_UGE: 1881f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 1882786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky case ICmpInst::ICMP_SLT: 1883786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky case ICmpInst::ICMP_SLE: 1884786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky ComputeSignBit(LHS, KnownNonNegative, KnownNegative, TD); 1885786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky if (!KnownNonNegative) 1886786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky break; 1887786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky // fall-through 188888cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky case ICmpInst::ICMP_NE: 188988cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky case ICmpInst::ICMP_ULT: 189088cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky case ICmpInst::ICMP_ULE: 1891f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 189288cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky } 189388cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky } 189484dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky if (RBO && match(RBO, m_URem(m_Value(), m_Specific(LHS)))) { 189584dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky bool KnownNonNegative, KnownNegative; 189684dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky switch (Pred) { 189784dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky default: 189884dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky break; 189984dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_SGT: 190084dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_SGE: 190184dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky ComputeSignBit(RHS, KnownNonNegative, KnownNegative, TD); 190284dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky if (!KnownNonNegative) 190384dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky break; 190484dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky // fall-through 1905a0e2f38b25ce7c51c22ed40d8a315fe1dd98926dNick Lewycky case ICmpInst::ICMP_NE: 190684dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_UGT: 190784dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_UGE: 1908f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 190984dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_SLT: 191084dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_SLE: 191184dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky ComputeSignBit(RHS, KnownNonNegative, KnownNegative, TD); 191284dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky if (!KnownNonNegative) 191384dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky break; 191484dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky // fall-through 1915a0e2f38b25ce7c51c22ed40d8a315fe1dd98926dNick Lewycky case ICmpInst::ICMP_EQ: 191684dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_ULT: 191784dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_ULE: 1918f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 191984dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky } 192084dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky } 192188cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky 1922c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands // x udiv y <=u x. 1923c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands if (LBO && match(LBO, m_UDiv(m_Specific(RHS), m_Value()))) { 1924c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands // icmp pred (X /u Y), X 1925c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands if (Pred == ICmpInst::ICMP_UGT) 1926c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands return getFalse(ITy); 1927c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands if (Pred == ICmpInst::ICMP_ULE) 1928c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands return getTrue(ITy); 1929c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands } 1930c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands 193158bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (MaxRecurse && LBO && RBO && LBO->getOpcode() == RBO->getOpcode() && 193258bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky LBO->getOperand(1) == RBO->getOperand(1)) { 193358bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky switch (LBO->getOpcode()) { 193458bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky default: break; 193558bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::UDiv: 193658bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::LShr: 193758bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (ICmpInst::isSigned(Pred)) 193858bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 193958bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky // fall-through 194058bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::SDiv: 194158bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::AShr: 1942b6e7cd655c6ee119dbeacc321ee92387f983edb0Eli Friedman if (!LBO->isExact() || !RBO->isExact()) 194358bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 194458bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (Value *V = SimplifyICmpInst(Pred, LBO->getOperand(0), 194558bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky RBO->getOperand(0), TD, DT, MaxRecurse-1)) 194658bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky return V; 194758bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 194858bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::Shl: { 1949c9d904ee2ca36ab6238ed93c7ad2ea67b5fd0a23Duncan Sands bool NUW = LBO->hasNoUnsignedWrap() && RBO->hasNoUnsignedWrap(); 195058bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky bool NSW = LBO->hasNoSignedWrap() && RBO->hasNoSignedWrap(); 195158bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (!NUW && !NSW) 195258bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 195358bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (!NSW && ICmpInst::isSigned(Pred)) 195458bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 195558bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (Value *V = SimplifyICmpInst(Pred, LBO->getOperand(0), 195658bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky RBO->getOperand(0), TD, DT, MaxRecurse-1)) 195758bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky return V; 195858bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 195958bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky } 196058bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky } 196158bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky } 196258bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky 1963ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Simplify comparisons involving max/min. 1964ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands Value *A, *B; 1965ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands CmpInst::Predicate P = CmpInst::BAD_ICMP_PREDICATE; 1966ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands CmpInst::Predicate EqP; // Chosen so that "A == max/min(A,B)" iff "A EqP B". 1967ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands 19688140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Signed variants on "max(a,b)>=a -> true". 1969ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (match(LHS, m_SMax(m_Value(A), m_Value(B))) && (A == RHS || B == RHS)) { 1970ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != RHS) std::swap(A, B); // smax(A, B) pred A. 1971ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands EqP = CmpInst::ICMP_SGE; // "A == smax(A, B)" iff "A sge B". 1972ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as smax(A, B) pred A. 1973ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = Pred; 1974ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } else if (match(RHS, m_SMax(m_Value(A), m_Value(B))) && 1975ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands (A == LHS || B == LHS)) { 1976ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != LHS) std::swap(A, B); // A pred smax(A, B). 1977ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands EqP = CmpInst::ICMP_SGE; // "A == smax(A, B)" iff "A sge B". 1978ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as smax(A, B) swapped-pred A. 1979ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = CmpInst::getSwappedPredicate(Pred); 1980ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } else if (match(LHS, m_SMin(m_Value(A), m_Value(B))) && 1981ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands (A == RHS || B == RHS)) { 1982ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != RHS) std::swap(A, B); // smin(A, B) pred A. 1983ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands EqP = CmpInst::ICMP_SLE; // "A == smin(A, B)" iff "A sle B". 1984ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as smax(-A, -B) swapped-pred -A. 1985ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Note that we do not need to actually form -A or -B thanks to EqP. 1986ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = CmpInst::getSwappedPredicate(Pred); 1987ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } else if (match(RHS, m_SMin(m_Value(A), m_Value(B))) && 1988ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands (A == LHS || B == LHS)) { 1989ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != LHS) std::swap(A, B); // A pred smin(A, B). 1990ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands EqP = CmpInst::ICMP_SLE; // "A == smin(A, B)" iff "A sle B". 1991ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as smax(-A, -B) pred -A. 1992ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Note that we do not need to actually form -A or -B thanks to EqP. 1993ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = Pred; 1994ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } 1995ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (P != CmpInst::BAD_ICMP_PREDICATE) { 1996ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Cases correspond to "max(A, B) p A". 1997ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands switch (P) { 1998ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands default: 1999ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands break; 2000ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_EQ: 2001ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_SLE: 2002e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Equivalent to "A EqP B". This may be the same as the condition tested 2003e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // in the max/min; if so, we can just return that. 2004e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(LHS, EqP, A, B)) 2005e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2006e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(RHS, EqP, A, B)) 2007e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2008e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Otherwise, see if "A EqP B" simplifies. 2009ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (MaxRecurse) 2010ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (Value *V = SimplifyICmpInst(EqP, A, B, TD, DT, MaxRecurse-1)) 2011ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands return V; 2012ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands break; 2013ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_NE: 2014e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands case CmpInst::ICMP_SGT: { 2015e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands CmpInst::Predicate InvEqP = CmpInst::getInversePredicate(EqP); 2016e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Equivalent to "A InvEqP B". This may be the same as the condition 2017e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // tested in the max/min; if so, we can just return that. 2018e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(LHS, InvEqP, A, B)) 2019e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2020e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(RHS, InvEqP, A, B)) 2021e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2022e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Otherwise, see if "A InvEqP B" simplifies. 2023ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (MaxRecurse) 2024e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = SimplifyICmpInst(InvEqP, A, B, TD, DT, MaxRecurse-1)) 2025ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands return V; 2026ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands break; 2027e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands } 2028ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_SGE: 2029ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Always true. 2030f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 2031ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_SLT: 2032ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Always false. 2033f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 2034ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } 2035ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } 2036ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands 20378140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Unsigned variants on "max(a,b)>=a -> true". 2038ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = CmpInst::BAD_ICMP_PREDICATE; 2039ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (match(LHS, m_UMax(m_Value(A), m_Value(B))) && (A == RHS || B == RHS)) { 2040ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != RHS) std::swap(A, B); // umax(A, B) pred A. 2041ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands EqP = CmpInst::ICMP_UGE; // "A == umax(A, B)" iff "A uge B". 2042ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as umax(A, B) pred A. 2043ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = Pred; 2044ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } else if (match(RHS, m_UMax(m_Value(A), m_Value(B))) && 2045ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands (A == LHS || B == LHS)) { 2046ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != LHS) std::swap(A, B); // A pred umax(A, B). 2047ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands EqP = CmpInst::ICMP_UGE; // "A == umax(A, B)" iff "A uge B". 2048ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as umax(A, B) swapped-pred A. 2049ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = CmpInst::getSwappedPredicate(Pred); 2050ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } else if (match(LHS, m_UMin(m_Value(A), m_Value(B))) && 2051ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands (A == RHS || B == RHS)) { 2052ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != RHS) std::swap(A, B); // umin(A, B) pred A. 2053ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands EqP = CmpInst::ICMP_ULE; // "A == umin(A, B)" iff "A ule B". 2054ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as umax(-A, -B) swapped-pred -A. 2055ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Note that we do not need to actually form -A or -B thanks to EqP. 2056ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = CmpInst::getSwappedPredicate(Pred); 2057ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } else if (match(RHS, m_UMin(m_Value(A), m_Value(B))) && 2058ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands (A == LHS || B == LHS)) { 2059ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != LHS) std::swap(A, B); // A pred umin(A, B). 2060ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands EqP = CmpInst::ICMP_ULE; // "A == umin(A, B)" iff "A ule B". 2061ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as umax(-A, -B) pred -A. 2062ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Note that we do not need to actually form -A or -B thanks to EqP. 2063ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = Pred; 2064ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } 2065ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (P != CmpInst::BAD_ICMP_PREDICATE) { 2066ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Cases correspond to "max(A, B) p A". 2067ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands switch (P) { 2068ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands default: 2069ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands break; 2070ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_EQ: 2071ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_ULE: 2072e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Equivalent to "A EqP B". This may be the same as the condition tested 2073e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // in the max/min; if so, we can just return that. 2074e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(LHS, EqP, A, B)) 2075e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2076e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(RHS, EqP, A, B)) 2077e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2078e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Otherwise, see if "A EqP B" simplifies. 2079ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (MaxRecurse) 2080ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (Value *V = SimplifyICmpInst(EqP, A, B, TD, DT, MaxRecurse-1)) 2081ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands return V; 2082ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands break; 2083ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_NE: 2084e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands case CmpInst::ICMP_UGT: { 2085e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands CmpInst::Predicate InvEqP = CmpInst::getInversePredicate(EqP); 2086e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Equivalent to "A InvEqP B". This may be the same as the condition 2087e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // tested in the max/min; if so, we can just return that. 2088e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(LHS, InvEqP, A, B)) 2089e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2090e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(RHS, InvEqP, A, B)) 2091e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2092e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Otherwise, see if "A InvEqP B" simplifies. 2093ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (MaxRecurse) 2094e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = SimplifyICmpInst(InvEqP, A, B, TD, DT, MaxRecurse-1)) 2095ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands return V; 2096ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands break; 2097e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands } 2098ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_UGE: 2099ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Always true. 2100f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 2101ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_ULT: 2102ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Always false. 2103f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 2104ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } 2105ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } 2106ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands 21078140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Variants on "max(x,y) >= min(x,z)". 21088140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands Value *C, *D; 21098140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (match(LHS, m_SMax(m_Value(A), m_Value(B))) && 21108140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands match(RHS, m_SMin(m_Value(C), m_Value(D))) && 21118140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands (A == C || A == D || B == C || B == D)) { 21128140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // max(x, ?) pred min(x, ?). 21138140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_SGE) 21148140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always true. 2115f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 21168140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_SLT) 21178140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always false. 2118f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 21198140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands } else if (match(LHS, m_SMin(m_Value(A), m_Value(B))) && 21208140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands match(RHS, m_SMax(m_Value(C), m_Value(D))) && 21218140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands (A == C || A == D || B == C || B == D)) { 21228140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // min(x, ?) pred max(x, ?). 21238140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_SLE) 21248140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always true. 2125f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 21268140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_SGT) 21278140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always false. 2128f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 21298140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands } else if (match(LHS, m_UMax(m_Value(A), m_Value(B))) && 21308140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands match(RHS, m_UMin(m_Value(C), m_Value(D))) && 21318140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands (A == C || A == D || B == C || B == D)) { 21328140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // max(x, ?) pred min(x, ?). 21338140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_UGE) 21348140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always true. 2135f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 21368140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_ULT) 21378140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always false. 2138f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 21398140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands } else if (match(LHS, m_UMin(m_Value(A), m_Value(B))) && 21408140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands match(RHS, m_UMax(m_Value(C), m_Value(D))) && 21418140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands (A == C || A == D || B == C || B == D)) { 21428140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // min(x, ?) pred max(x, ?). 21438140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_ULE) 21448140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always true. 2145f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 21468140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_UGT) 21478140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always false. 2148f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 21498140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands } 21508140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands 21511ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands // If the comparison is with the result of a select instruction, check whether 21521ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands // comparing with either branch of the select always yields the same value. 21530312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<SelectInst>(LHS) || isa<SelectInst>(RHS)) 21540312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (Value *V = ThreadCmpOverSelect(Pred, LHS, RHS, TD, DT, MaxRecurse)) 2155a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return V; 2156a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 2157a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the comparison is with the result of a phi instruction, check whether 2158a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // doing the compare with each incoming phi value yields a common result. 21590312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<PHINode>(LHS) || isa<PHINode>(RHS)) 21600312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (Value *V = ThreadCmpOverPHI(Pred, LHS, RHS, TD, DT, MaxRecurse)) 21613bbb0cc42b67b4bf2c488285666999963bab0f7eDuncan Sands return V; 21621ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands 21639dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner return 0; 21649dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner} 21659dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 2166a74a58c83be492b7d5b7383656f049909394cff4Duncan SandsValue *llvm::SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS, 21671845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const TargetData *TD, const DominatorTree *DT) { 21681845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return ::SimplifyICmpInst(Predicate, LHS, RHS, TD, DT, RecursionLimit); 2169a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 2170a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 21719dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// SimplifyFCmpInst - Given operands for an FCmpInst, see if we can 21729dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// fold the result. If not, this returns null. 2173a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *SimplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS, 21741845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const TargetData *TD, const DominatorTree *DT, 21751845009290e4d804ad377927bd8a08cca3036adcDuncan Sands unsigned MaxRecurse) { 21769dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner CmpInst::Predicate Pred = (CmpInst::Predicate)Predicate; 21779dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner assert(CmpInst::isFPPredicate(Pred) && "Not an FP compare!"); 21789dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 2179d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(LHS)) { 21809dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner if (Constant *CRHS = dyn_cast<Constant>(RHS)) 21819dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner return ConstantFoldCompareInstOperands(Pred, CLHS, CRHS, TD); 218212a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2183d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // If we have a constant, make sure it is on the RHS. 2184d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner std::swap(LHS, RHS); 2185d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Pred = CmpInst::getSwappedPredicate(Pred); 2186d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 218712a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2188210c5d4880b525e064088b6fec713260128c16ebChris Lattner // Fold trivial predicates. 2189210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (Pred == FCmpInst::FCMP_FALSE) 2190210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(GetCompareTy(LHS), 0); 2191210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (Pred == FCmpInst::FCMP_TRUE) 2192210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(GetCompareTy(LHS), 1); 2193210c5d4880b525e064088b6fec713260128c16ebChris Lattner 2194210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (isa<UndefValue>(RHS)) // fcmp pred X, undef -> undef 2195210c5d4880b525e064088b6fec713260128c16ebChris Lattner return UndefValue::get(GetCompareTy(LHS)); 2196210c5d4880b525e064088b6fec713260128c16ebChris Lattner 2197210c5d4880b525e064088b6fec713260128c16ebChris Lattner // fcmp x,x -> true/false. Not all compares are foldable. 2198124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (LHS == RHS) { 2199210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (CmpInst::isTrueWhenEqual(Pred)) 2200210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(GetCompareTy(LHS), 1); 2201210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (CmpInst::isFalseWhenEqual(Pred)) 2202210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(GetCompareTy(LHS), 0); 2203210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 220412a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2205210c5d4880b525e064088b6fec713260128c16ebChris Lattner // Handle fcmp with constant RHS 2206210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (Constant *RHSC = dyn_cast<Constant>(RHS)) { 2207210c5d4880b525e064088b6fec713260128c16ebChris Lattner // If the constant is a nan, see if we can fold the comparison based on it. 2208210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (ConstantFP *CFP = dyn_cast<ConstantFP>(RHSC)) { 2209210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (CFP->getValueAPF().isNaN()) { 2210210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (FCmpInst::isOrdered(Pred)) // True "if ordered and foo" 2211210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::getFalse(CFP->getContext()); 2212210c5d4880b525e064088b6fec713260128c16ebChris Lattner assert(FCmpInst::isUnordered(Pred) && 2213210c5d4880b525e064088b6fec713260128c16ebChris Lattner "Comparison must be either ordered or unordered!"); 2214210c5d4880b525e064088b6fec713260128c16ebChris Lattner // True if unordered. 2215210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::getTrue(CFP->getContext()); 2216210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 22176b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // Check whether the constant is an infinity. 22186b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman if (CFP->getValueAPF().isInfinity()) { 22196b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman if (CFP->getValueAPF().isNegative()) { 22206b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman switch (Pred) { 22216b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman case FCmpInst::FCMP_OLT: 22226b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // No value is ordered and less than negative infinity. 22236b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman return ConstantInt::getFalse(CFP->getContext()); 22246b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman case FCmpInst::FCMP_UGE: 22256b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // All values are unordered with or at least negative infinity. 22266b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman return ConstantInt::getTrue(CFP->getContext()); 22276b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman default: 22286b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman break; 22296b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } 22306b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } else { 22316b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman switch (Pred) { 22326b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman case FCmpInst::FCMP_OGT: 22336b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // No value is ordered and greater than infinity. 22346b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman return ConstantInt::getFalse(CFP->getContext()); 22356b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman case FCmpInst::FCMP_ULE: 22366b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // All values are unordered with and at most infinity. 22376b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman return ConstantInt::getTrue(CFP->getContext()); 22386b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman default: 22396b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman break; 22406b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } 22416b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } 22426b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } 2243210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 2244210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 224512a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 224692826def593df7a422c7b07f09342febce81ddd3Duncan Sands // If the comparison is with the result of a select instruction, check whether 224792826def593df7a422c7b07f09342febce81ddd3Duncan Sands // comparing with either branch of the select always yields the same value. 22480312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<SelectInst>(LHS) || isa<SelectInst>(RHS)) 22490312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (Value *V = ThreadCmpOverSelect(Pred, LHS, RHS, TD, DT, MaxRecurse)) 2250a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return V; 2251a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 2252a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the comparison is with the result of a phi instruction, check whether 2253a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // doing the compare with each incoming phi value yields a common result. 22540312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<PHINode>(LHS) || isa<PHINode>(RHS)) 22550312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (Value *V = ThreadCmpOverPHI(Pred, LHS, RHS, TD, DT, MaxRecurse)) 22563bbb0cc42b67b4bf2c488285666999963bab0f7eDuncan Sands return V; 225792826def593df7a422c7b07f09342febce81ddd3Duncan Sands 22589f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner return 0; 22599f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner} 22609f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 2261a74a58c83be492b7d5b7383656f049909394cff4Duncan SandsValue *llvm::SimplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS, 22621845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const TargetData *TD, const DominatorTree *DT) { 22631845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return ::SimplifyFCmpInst(Predicate, LHS, RHS, TD, DT, RecursionLimit); 2264a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 2265a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 2266047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner/// SimplifySelectInst - Given operands for a SelectInst, see if we can fold 2267047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner/// the result. If not, this returns null. 2268124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan SandsValue *llvm::SimplifySelectInst(Value *CondVal, Value *TrueVal, Value *FalseVal, 2269124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands const TargetData *TD, const DominatorTree *) { 2270047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner // select true, X, Y -> X 2271047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner // select false, X, Y -> Y 2272047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner if (ConstantInt *CB = dyn_cast<ConstantInt>(CondVal)) 2273047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return CB->getZExtValue() ? TrueVal : FalseVal; 227412a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2275047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner // select C, X, X -> X 2276124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (TrueVal == FalseVal) 2277047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return TrueVal; 227812a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2279047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner if (isa<UndefValue>(CondVal)) { // select undef, X, Y -> X or Y 2280047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner if (isa<Constant>(TrueVal)) 2281047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return TrueVal; 2282047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return FalseVal; 2283047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner } 228468c0dbc14fb7599987fb3e27be4e12c1ac36535eDan Gohman if (isa<UndefValue>(TrueVal)) // select C, undef, X -> X 228568c0dbc14fb7599987fb3e27be4e12c1ac36535eDan Gohman return FalseVal; 228668c0dbc14fb7599987fb3e27be4e12c1ac36535eDan Gohman if (isa<UndefValue>(FalseVal)) // select C, X, undef -> X 228768c0dbc14fb7599987fb3e27be4e12c1ac36535eDan Gohman return TrueVal; 228812a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2289047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return 0; 2290047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner} 2291047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner 2292c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner/// SimplifyGEPInst - Given operands for an GetElementPtrInst, see if we can 2293c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner/// fold the result. If not, this returns null. 2294b9b54ebfed02f0654897d37e8a4448d3f8087558Jay FoadValue *llvm::SimplifyGEPInst(ArrayRef<Value *> Ops, 22951845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const TargetData *TD, const DominatorTree *) { 229685bbff6c94695f07cc1a9765b4d384ed18d2fd7cDuncan Sands // The type of the GEP pointer operand. 2297db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner PointerType *PtrTy = cast<PointerType>(Ops[0]->getType()); 229885bbff6c94695f07cc1a9765b4d384ed18d2fd7cDuncan Sands 2299c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner // getelementptr P -> P. 2300b9b54ebfed02f0654897d37e8a4448d3f8087558Jay Foad if (Ops.size() == 1) 2301c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner return Ops[0]; 2302c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner 230385bbff6c94695f07cc1a9765b4d384ed18d2fd7cDuncan Sands if (isa<UndefValue>(Ops[0])) { 230485bbff6c94695f07cc1a9765b4d384ed18d2fd7cDuncan Sands // Compute the (pointer) type returned by the GEP instruction. 2305a9203109f4ac95aa7e9624f2838e3d89623ec902Jay Foad Type *LastType = GetElementPtrInst::getIndexedType(PtrTy, Ops.slice(1)); 2306db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *GEPTy = PointerType::get(LastType, PtrTy->getAddressSpace()); 230785bbff6c94695f07cc1a9765b4d384ed18d2fd7cDuncan Sands return UndefValue::get(GEPTy); 230885bbff6c94695f07cc1a9765b4d384ed18d2fd7cDuncan Sands } 2309c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner 2310b9b54ebfed02f0654897d37e8a4448d3f8087558Jay Foad if (Ops.size() == 2) { 2311e60d79faf7ef7bc4847f9e5d067af00b98dced7bDuncan Sands // getelementptr P, 0 -> P. 2312c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner if (ConstantInt *C = dyn_cast<ConstantInt>(Ops[1])) 2313c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner if (C->isZero()) 2314c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner return Ops[0]; 2315e60d79faf7ef7bc4847f9e5d067af00b98dced7bDuncan Sands // getelementptr P, N -> P if P points to a type of zero size. 2316e60d79faf7ef7bc4847f9e5d067af00b98dced7bDuncan Sands if (TD) { 2317db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty = PtrTy->getElementType(); 2318a63395a30f9227bde826749d3480046301b47332Duncan Sands if (Ty->isSized() && TD->getTypeAllocSize(Ty) == 0) 2319e60d79faf7ef7bc4847f9e5d067af00b98dced7bDuncan Sands return Ops[0]; 2320e60d79faf7ef7bc4847f9e5d067af00b98dced7bDuncan Sands } 2321e60d79faf7ef7bc4847f9e5d067af00b98dced7bDuncan Sands } 232212a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2323c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner // Check to see if this is constant foldable. 2324b9b54ebfed02f0654897d37e8a4448d3f8087558Jay Foad for (unsigned i = 0, e = Ops.size(); i != e; ++i) 2325c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner if (!isa<Constant>(Ops[i])) 2326c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner return 0; 232712a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2328dab3d29605a5c83db41b28176273ef55961120c1Jay Foad return ConstantExpr::getGetElementPtr(cast<Constant>(Ops[0]), Ops.slice(1)); 2329c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner} 2330c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner 2331dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands/// SimplifyInsertValueInst - Given operands for an InsertValueInst, see if we 2332dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands/// can fold the result. If not, this returns null. 2333dabc2806726a286b00313419fac8461ebe0f774cDuncan SandsValue *llvm::SimplifyInsertValueInst(Value *Agg, Value *Val, 2334dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands ArrayRef<unsigned> Idxs, 2335dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands const TargetData *, 2336dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands const DominatorTree *) { 2337dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands if (Constant *CAgg = dyn_cast<Constant>(Agg)) 2338dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands if (Constant *CVal = dyn_cast<Constant>(Val)) 2339dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands return ConstantFoldInsertValueInstruction(CAgg, CVal, Idxs); 2340dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands 2341dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands // insertvalue x, undef, n -> x 2342dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands if (match(Val, m_Undef())) 2343dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands return Agg; 2344dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands 2345dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands // insertvalue x, (extractvalue y, n), n 2346dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands if (ExtractValueInst *EV = dyn_cast<ExtractValueInst>(Val)) 2347ae707bd5594e52a8b385760f99ff58aa8fede948Benjamin Kramer if (EV->getAggregateOperand()->getType() == Agg->getType() && 2348ae707bd5594e52a8b385760f99ff58aa8fede948Benjamin Kramer EV->getIndices() == Idxs) { 2349dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands // insertvalue undef, (extractvalue y, n), n -> y 2350dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands if (match(Agg, m_Undef())) 2351dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands return EV->getAggregateOperand(); 2352dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands 2353dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands // insertvalue y, (extractvalue y, n), n -> y 2354dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands if (Agg == EV->getAggregateOperand()) 2355dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands return Agg; 2356dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands } 2357dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands 2358dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands return 0; 2359dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands} 2360dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands 2361ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands/// SimplifyPHINode - See if we can fold the given phi. If not, returns null. 2362ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sandsstatic Value *SimplifyPHINode(PHINode *PN, const DominatorTree *DT) { 2363ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // If all of the PHI's incoming values are the same then replace the PHI node 2364ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // with the common value. 2365ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands Value *CommonValue = 0; 2366ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands bool HasUndefInput = false; 2367ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) { 2368ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands Value *Incoming = PN->getIncomingValue(i); 2369ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // If the incoming value is the phi node itself, it can safely be skipped. 2370ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands if (Incoming == PN) continue; 2371ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands if (isa<UndefValue>(Incoming)) { 2372ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // Remember that we saw an undef value, but otherwise ignore them. 2373ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands HasUndefInput = true; 2374ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands continue; 2375ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands } 2376ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands if (CommonValue && Incoming != CommonValue) 2377ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands return 0; // Not the same, bail out. 2378ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands CommonValue = Incoming; 2379ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands } 2380ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands 2381ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // If CommonValue is null then all of the incoming values were either undef or 2382ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // equal to the phi node itself. 2383ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands if (!CommonValue) 2384ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands return UndefValue::get(PN->getType()); 2385ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands 2386ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // If we have a PHI node like phi(X, undef, X), where X is defined by some 2387ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // instruction, we cannot return X as the result of the PHI node unless it 2388ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // dominates the PHI block. 2389ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands if (HasUndefInput) 2390ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands return ValueDominatesPHI(CommonValue, PN, DT) ? CommonValue : 0; 2391ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands 2392ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands return CommonValue; 2393ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands} 2394ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands 2395c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner 2396d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner//=== Helper functions for higher up the class hierarchy. 23979dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 2398d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner/// SimplifyBinOp - Given operands for a BinaryOperator, see if we can 2399d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner/// fold the result. If not, this returns null. 2400a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *SimplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS, 24011845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const TargetData *TD, const DominatorTree *DT, 24021845009290e4d804ad377927bd8a08cca3036adcDuncan Sands unsigned MaxRecurse) { 2403d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner switch (Opcode) { 240481a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner case Instruction::Add: 2405ffeb98ad3becfbb8e26270ef8751e37e4b6b0cd1Duncan Sands return SimplifyAddInst(LHS, RHS, /*isNSW*/false, /*isNUW*/false, 240681a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner TD, DT, MaxRecurse); 240781a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner case Instruction::Sub: 2408ffeb98ad3becfbb8e26270ef8751e37e4b6b0cd1Duncan Sands return SimplifySubInst(LHS, RHS, /*isNSW*/false, /*isNUW*/false, 240981a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner TD, DT, MaxRecurse); 241081a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner case Instruction::Mul: return SimplifyMulInst (LHS, RHS, TD, DT, MaxRecurse); 2411593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands case Instruction::SDiv: return SimplifySDivInst(LHS, RHS, TD, DT, MaxRecurse); 2412593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands case Instruction::UDiv: return SimplifyUDivInst(LHS, RHS, TD, DT, MaxRecurse); 24131fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel case Instruction::FDiv: return SimplifyFDivInst(LHS, RHS, TD, DT, MaxRecurse); 2414f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands case Instruction::SRem: return SimplifySRemInst(LHS, RHS, TD, DT, MaxRecurse); 2415f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands case Instruction::URem: return SimplifyURemInst(LHS, RHS, TD, DT, MaxRecurse); 2416f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands case Instruction::FRem: return SimplifyFRemInst(LHS, RHS, TD, DT, MaxRecurse); 241781a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner case Instruction::Shl: 2418ffeb98ad3becfbb8e26270ef8751e37e4b6b0cd1Duncan Sands return SimplifyShlInst(LHS, RHS, /*isNSW*/false, /*isNUW*/false, 241981a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner TD, DT, MaxRecurse); 242081a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner case Instruction::LShr: 2421ffeb98ad3becfbb8e26270ef8751e37e4b6b0cd1Duncan Sands return SimplifyLShrInst(LHS, RHS, /*isExact*/false, TD, DT, MaxRecurse); 242281a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner case Instruction::AShr: 2423ffeb98ad3becfbb8e26270ef8751e37e4b6b0cd1Duncan Sands return SimplifyAShrInst(LHS, RHS, /*isExact*/false, TD, DT, MaxRecurse); 242482fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands case Instruction::And: return SimplifyAndInst(LHS, RHS, TD, DT, MaxRecurse); 242581a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner case Instruction::Or: return SimplifyOrInst (LHS, RHS, TD, DT, MaxRecurse); 242682fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands case Instruction::Xor: return SimplifyXorInst(LHS, RHS, TD, DT, MaxRecurse); 2427d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner default: 2428d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(LHS)) 2429d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CRHS = dyn_cast<Constant>(RHS)) { 2430d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Constant *COps[] = {CLHS, CRHS}; 24311d2f569c3428d70d0cf690c9adb459ad4a3ecff2Jay Foad return ConstantFoldInstOperands(Opcode, LHS->getType(), COps, TD); 2432d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 2433b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 2434566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // If the operation is associative, try some generic simplifications. 2435566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Instruction::isAssociative(Opcode)) 2436566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Value *V = SimplifyAssociativeBinOp(Opcode, LHS, RHS, TD, DT, 2437566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands MaxRecurse)) 2438566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return V; 2439566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 2440b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // If the operation is with the result of a select instruction, check whether 2441b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // operating on either branch of the select always yields the same value. 24420312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<SelectInst>(LHS) || isa<SelectInst>(RHS)) 24431845009290e4d804ad377927bd8a08cca3036adcDuncan Sands if (Value *V = ThreadBinOpOverSelect(Opcode, LHS, RHS, TD, DT, 24440312a93693abc2eb682b2b101c889959888fd883Duncan Sands MaxRecurse)) 2445a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return V; 2446a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 2447a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the operation is with the result of a phi instruction, check whether 2448a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // operating on all incoming values of the phi always yields the same value. 24490312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<PHINode>(LHS) || isa<PHINode>(RHS)) 24500312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (Value *V = ThreadBinOpOverPHI(Opcode, LHS, RHS, TD, DT, MaxRecurse)) 2451b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return V; 2452b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 2453d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return 0; 2454d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 2455d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner} 24569dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 245712a86f5b3199e72e6d967781acc76340f5920e46Duncan SandsValue *llvm::SimplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS, 24581845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const TargetData *TD, const DominatorTree *DT) { 24591845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return ::SimplifyBinOp(Opcode, LHS, RHS, TD, DT, RecursionLimit); 2460a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 2461a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 24629dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// SimplifyCmpInst - Given operands for a CmpInst, see if we can 24639dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// fold the result. 2464a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *SimplifyCmpInst(unsigned Predicate, Value *LHS, Value *RHS, 24651845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const TargetData *TD, const DominatorTree *DT, 24661845009290e4d804ad377927bd8a08cca3036adcDuncan Sands unsigned MaxRecurse) { 24679dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner if (CmpInst::isIntPredicate((CmpInst::Predicate)Predicate)) 24681845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return SimplifyICmpInst(Predicate, LHS, RHS, TD, DT, MaxRecurse); 24691845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return SimplifyFCmpInst(Predicate, LHS, RHS, TD, DT, MaxRecurse); 24709dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner} 24719dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 2472a74a58c83be492b7d5b7383656f049909394cff4Duncan SandsValue *llvm::SimplifyCmpInst(unsigned Predicate, Value *LHS, Value *RHS, 24731845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const TargetData *TD, const DominatorTree *DT) { 24741845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return ::SimplifyCmpInst(Predicate, LHS, RHS, TD, DT, RecursionLimit); 2475a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 2476e34537856a544c83513e390ac9552a8bc3823346Chris Lattner 247771d050315704c23b235594d3fad5268c12d825e3Dan Gohmanstatic Value *SimplifyCallInst(CallInst *CI) { 247871d050315704c23b235594d3fad5268c12d825e3Dan Gohman // call undef -> undef 247971d050315704c23b235594d3fad5268c12d825e3Dan Gohman if (isa<UndefValue>(CI->getCalledValue())) 248071d050315704c23b235594d3fad5268c12d825e3Dan Gohman return UndefValue::get(CI->getType()); 248171d050315704c23b235594d3fad5268c12d825e3Dan Gohman 248271d050315704c23b235594d3fad5268c12d825e3Dan Gohman return 0; 248371d050315704c23b235594d3fad5268c12d825e3Dan Gohman} 248471d050315704c23b235594d3fad5268c12d825e3Dan Gohman 2485e34537856a544c83513e390ac9552a8bc3823346Chris Lattner/// SimplifyInstruction - See if we can compute a simplified version of this 2486e34537856a544c83513e390ac9552a8bc3823346Chris Lattner/// instruction. If not, this returns null. 2487eff0581583ef10e2872e9baf537a04b67d992101Duncan SandsValue *llvm::SimplifyInstruction(Instruction *I, const TargetData *TD, 2488eff0581583ef10e2872e9baf537a04b67d992101Duncan Sands const DominatorTree *DT) { 2489d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands Value *Result; 2490d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands 2491e34537856a544c83513e390ac9552a8bc3823346Chris Lattner switch (I->getOpcode()) { 2492e34537856a544c83513e390ac9552a8bc3823346Chris Lattner default: 2493d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands Result = ConstantFoldInstruction(I, TD); 2494d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 24958aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner case Instruction::Add: 2496d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands Result = SimplifyAddInst(I->getOperand(0), I->getOperand(1), 2497d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands cast<BinaryOperator>(I)->hasNoSignedWrap(), 2498d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands cast<BinaryOperator>(I)->hasNoUnsignedWrap(), 2499d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands TD, DT); 2500d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 2501fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands case Instruction::Sub: 2502fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands Result = SimplifySubInst(I->getOperand(0), I->getOperand(1), 2503fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands cast<BinaryOperator>(I)->hasNoSignedWrap(), 2504fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands cast<BinaryOperator>(I)->hasNoUnsignedWrap(), 2505fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands TD, DT); 2506fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands break; 250782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands case Instruction::Mul: 250882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands Result = SimplifyMulInst(I->getOperand(0), I->getOperand(1), TD, DT); 250982fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands break; 2510593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands case Instruction::SDiv: 2511593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands Result = SimplifySDivInst(I->getOperand(0), I->getOperand(1), TD, DT); 2512593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands break; 2513593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands case Instruction::UDiv: 2514593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands Result = SimplifyUDivInst(I->getOperand(0), I->getOperand(1), TD, DT); 2515593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands break; 25161fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel case Instruction::FDiv: 25171fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel Result = SimplifyFDivInst(I->getOperand(0), I->getOperand(1), TD, DT); 25181fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel break; 2519f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands case Instruction::SRem: 2520f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands Result = SimplifySRemInst(I->getOperand(0), I->getOperand(1), TD, DT); 2521f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands break; 2522f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands case Instruction::URem: 2523f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands Result = SimplifyURemInst(I->getOperand(0), I->getOperand(1), TD, DT); 2524f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands break; 2525f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands case Instruction::FRem: 2526f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands Result = SimplifyFRemInst(I->getOperand(0), I->getOperand(1), TD, DT); 2527f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands break; 2528c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands case Instruction::Shl: 252981a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Result = SimplifyShlInst(I->getOperand(0), I->getOperand(1), 253081a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner cast<BinaryOperator>(I)->hasNoSignedWrap(), 253181a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner cast<BinaryOperator>(I)->hasNoUnsignedWrap(), 253281a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner TD, DT); 2533c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands break; 2534c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands case Instruction::LShr: 253581a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Result = SimplifyLShrInst(I->getOperand(0), I->getOperand(1), 253681a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner cast<BinaryOperator>(I)->isExact(), 253781a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner TD, DT); 2538c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands break; 2539c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands case Instruction::AShr: 254081a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Result = SimplifyAShrInst(I->getOperand(0), I->getOperand(1), 254181a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner cast<BinaryOperator>(I)->isExact(), 254281a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner TD, DT); 2543c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands break; 2544e34537856a544c83513e390ac9552a8bc3823346Chris Lattner case Instruction::And: 2545d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands Result = SimplifyAndInst(I->getOperand(0), I->getOperand(1), TD, DT); 2546d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 2547e34537856a544c83513e390ac9552a8bc3823346Chris Lattner case Instruction::Or: 2548d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands Result = SimplifyOrInst(I->getOperand(0), I->getOperand(1), TD, DT); 2549d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 25502b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands case Instruction::Xor: 25512b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands Result = SimplifyXorInst(I->getOperand(0), I->getOperand(1), TD, DT); 25522b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands break; 2553e34537856a544c83513e390ac9552a8bc3823346Chris Lattner case Instruction::ICmp: 2554d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands Result = SimplifyICmpInst(cast<ICmpInst>(I)->getPredicate(), 2555d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands I->getOperand(0), I->getOperand(1), TD, DT); 2556d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 2557e34537856a544c83513e390ac9552a8bc3823346Chris Lattner case Instruction::FCmp: 2558d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands Result = SimplifyFCmpInst(cast<FCmpInst>(I)->getPredicate(), 2559d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands I->getOperand(0), I->getOperand(1), TD, DT); 2560d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 2561047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner case Instruction::Select: 2562d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands Result = SimplifySelectInst(I->getOperand(0), I->getOperand(1), 2563d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands I->getOperand(2), TD, DT); 2564d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 2565c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner case Instruction::GetElementPtr: { 2566c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner SmallVector<Value*, 8> Ops(I->op_begin(), I->op_end()); 2567b9b54ebfed02f0654897d37e8a4448d3f8087558Jay Foad Result = SimplifyGEPInst(Ops, TD, DT); 2568d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 2569c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner } 2570dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands case Instruction::InsertValue: { 2571dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands InsertValueInst *IV = cast<InsertValueInst>(I); 2572dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands Result = SimplifyInsertValueInst(IV->getAggregateOperand(), 2573dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands IV->getInsertedValueOperand(), 2574dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands IV->getIndices(), TD, DT); 2575dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands break; 2576dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands } 2577cd6636c737a82949ad13db2d0d918af6424fb78bDuncan Sands case Instruction::PHI: 2578d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands Result = SimplifyPHINode(cast<PHINode>(I), DT); 2579d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 258071d050315704c23b235594d3fad5268c12d825e3Dan Gohman case Instruction::Call: 258171d050315704c23b235594d3fad5268c12d825e3Dan Gohman Result = SimplifyCallInst(cast<CallInst>(I)); 258271d050315704c23b235594d3fad5268c12d825e3Dan Gohman break; 2583e34537856a544c83513e390ac9552a8bc3823346Chris Lattner } 2584d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands 2585d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands /// If called on unreachable code, the above logic may report that the 2586d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands /// instruction simplified to itself. Make life easier for users by 2587f8b1a5ea9602bb65a5cf59d3d34f2851a08cdc3eDuncan Sands /// detecting that case here, returning a safe value instead. 2588f8b1a5ea9602bb65a5cf59d3d34f2851a08cdc3eDuncan Sands return Result == I ? UndefValue::get(I->getType()) : Result; 2589e34537856a544c83513e390ac9552a8bc3823346Chris Lattner} 2590e34537856a544c83513e390ac9552a8bc3823346Chris Lattner 259140d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// ReplaceAndSimplifyAllUses - Perform From->replaceAllUsesWith(To) and then 259240d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// delete the From instruction. In addition to a basic RAUW, this does a 259340d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// recursive simplification of the newly formed instructions. This catches 259440d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// things where one simplification exposes other opportunities. This only 259540d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// simplifies and deletes scalar operations, it does not change the CFG. 259640d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// 259740d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattnervoid llvm::ReplaceAndSimplifyAllUses(Instruction *From, Value *To, 2598eff0581583ef10e2872e9baf537a04b67d992101Duncan Sands const TargetData *TD, 2599eff0581583ef10e2872e9baf537a04b67d992101Duncan Sands const DominatorTree *DT) { 260040d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner assert(From != To && "ReplaceAndSimplifyAllUses(X,X) is not valid!"); 260112a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2602d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // FromHandle/ToHandle - This keeps a WeakVH on the from/to values so that 2603d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // we can know if it gets deleted out from under us or replaced in a 2604d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // recursive simplification. 260540d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner WeakVH FromHandle(From); 2606d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner WeakVH ToHandle(To); 260712a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 260840d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner while (!From->use_empty()) { 260940d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner // Update the instruction to use the new value. 2610d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner Use &TheUse = From->use_begin().getUse(); 2611d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner Instruction *User = cast<Instruction>(TheUse.getUser()); 2612d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner TheUse = To; 2613d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner 2614d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // Check to see if the instruction can be folded due to the operand 2615d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // replacement. For example changing (or X, Y) into (or X, -1) can replace 2616d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // the 'or' with -1. 2617d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner Value *SimplifiedVal; 2618d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner { 2619d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // Sanity check to make sure 'User' doesn't dangle across 2620d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // SimplifyInstruction. 2621d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner AssertingVH<> UserHandle(User); 262212a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2623eff0581583ef10e2872e9baf537a04b67d992101Duncan Sands SimplifiedVal = SimplifyInstruction(User, TD, DT); 2624d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner if (SimplifiedVal == 0) continue; 262540d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner } 262612a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2627d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // Recursively simplify this user to the new value. 2628eff0581583ef10e2872e9baf537a04b67d992101Duncan Sands ReplaceAndSimplifyAllUses(User, SimplifiedVal, TD, DT); 2629d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner From = dyn_cast_or_null<Instruction>((Value*)FromHandle); 2630d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner To = ToHandle; 263112a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2632d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner assert(ToHandle && "To value deleted by recursive simplification?"); 263312a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2634d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // If the recursive simplification ended up revisiting and deleting 2635d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // 'From' then we're done. 2636d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner if (From == 0) 2637d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner return; 263840d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner } 263912a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2640d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // If 'From' has value handles referring to it, do a real RAUW to update them. 2641d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner From->replaceAllUsesWith(To); 264212a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 264340d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner From->eraseFromParent(); 264440d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner} 2645