InstructionSimplify.cpp revision dce4a407a24b04eebc6a376f8e62b41aaa7b071f
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 209f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner#include "llvm/Analysis/InstructionSimplify.h" 21d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/ADT/SetVector.h" 22d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/ADT/Statistic.h" 239f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner#include "llvm/Analysis/ConstantFolding.h" 24fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman#include "llvm/Analysis/MemoryBuiltins.h" 2536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines#include "llvm/Analysis/ValueTracking.h" 2636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines#include "llvm/IR/ConstantRange.h" 270b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/DataLayout.h" 2836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines#include "llvm/IR/Dominators.h" 2936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines#include "llvm/IR/GetElementPtrTypeIterator.h" 300b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/GlobalAlias.h" 310b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Operator.h" 3236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines#include "llvm/IR/PatternMatch.h" 3336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines#include "llvm/IR/ValueHandle.h" 349f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattnerusing namespace llvm; 35d06094f0682f2ede03caff4892b1a57469896d48Chris Lattnerusing namespace llvm::PatternMatch; 369f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 37dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines#define DEBUG_TYPE "instsimplify" 38dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 3981a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattnerenum { RecursionLimit = 3 }; 40a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 41a3c44a5280042dbc0cde995675c225ede4528c6eDuncan SandsSTATISTIC(NumExpand, "Number of expansions"); 42a3c44a5280042dbc0cde995675c225ede4528c6eDuncan SandsSTATISTIC(NumFactor , "Number of factorizations"); 43a3c44a5280042dbc0cde995675c225ede4528c6eDuncan SandsSTATISTIC(NumReassoc, "Number of reassociations"); 44a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands 450aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstruct Query { 4636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const DataLayout *DL; 470aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const TargetLibraryInfo *TLI; 480aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const DominatorTree *DT; 490aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands 5036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Query(const DataLayout *DL, const TargetLibraryInfo *tli, 5136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const DominatorTree *dt) : DL(DL), TLI(tli), DT(dt) {} 520aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands}; 530aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands 540aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyAndInst(Value *, Value *, const Query &, unsigned); 550aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyBinOp(unsigned, Value *, Value *, const Query &, 56618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier unsigned); 570aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyCmpInst(unsigned, Value *, Value *, const Query &, 58618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier unsigned); 590aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyOrInst(Value *, Value *, const Query &, unsigned); 600aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyXorInst(Value *, Value *, const Query &, unsigned); 61bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sandsstatic Value *SimplifyTruncInst(Value *, Type *, const Query &, unsigned); 621845009290e4d804ad377927bd8a08cca3036adcDuncan Sands 63f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands/// getFalse - For a boolean type, or a vector of boolean type, return false, or 64f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands/// a vector with every element false, as appropriate for the type. 65f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sandsstatic Constant *getFalse(Type *Ty) { 6666d004ef708642bbdc38fd761507f2e9ee3970cdNick Lewycky assert(Ty->getScalarType()->isIntegerTy(1) && 67f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands "Expected i1 type or a vector of i1!"); 68f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return Constant::getNullValue(Ty); 69f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands} 70f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands 71f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands/// getTrue - For a boolean type, or a vector of boolean type, return true, or 72f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands/// a vector with every element true, as appropriate for the type. 73f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sandsstatic Constant *getTrue(Type *Ty) { 7466d004ef708642bbdc38fd761507f2e9ee3970cdNick Lewycky assert(Ty->getScalarType()->isIntegerTy(1) && 75f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands "Expected i1 type or a vector of i1!"); 76f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return Constant::getAllOnesValue(Ty); 77f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands} 78f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands 796dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands/// isSameCompare - Is V equivalent to the comparison "LHS Pred RHS"? 806dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sandsstatic bool isSameCompare(Value *V, CmpInst::Predicate Pred, Value *LHS, 816dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands Value *RHS) { 826dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands CmpInst *Cmp = dyn_cast<CmpInst>(V); 836dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (!Cmp) 846dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return false; 856dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands CmpInst::Predicate CPred = Cmp->getPredicate(); 866dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands Value *CLHS = Cmp->getOperand(0), *CRHS = Cmp->getOperand(1); 876dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (CPred == Pred && CLHS == LHS && CRHS == RHS) 886dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return true; 896dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return CPred == CmpInst::getSwappedPredicate(Pred) && CLHS == RHS && 906dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands CRHS == LHS; 916dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands} 926dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands 931845009290e4d804ad377927bd8a08cca3036adcDuncan Sands/// ValueDominatesPHI - Does the given value dominate the specified phi node? 941845009290e4d804ad377927bd8a08cca3036adcDuncan Sandsstatic bool ValueDominatesPHI(Value *V, PHINode *P, const DominatorTree *DT) { 951845009290e4d804ad377927bd8a08cca3036adcDuncan Sands Instruction *I = dyn_cast<Instruction>(V); 961845009290e4d804ad377927bd8a08cca3036adcDuncan Sands if (!I) 971845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // Arguments and constants dominate all instructions. 981845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return true; 991845009290e4d804ad377927bd8a08cca3036adcDuncan Sands 100ff739c1575df58f3926c2f3b6e00a6c45f773523Chandler Carruth // If we are processing instructions (and/or basic blocks) that have not been 101ff739c1575df58f3926c2f3b6e00a6c45f773523Chandler Carruth // fully added to a function, the parent nodes may still be null. Simply 102ff739c1575df58f3926c2f3b6e00a6c45f773523Chandler Carruth // return the conservative answer in these cases. 103ff739c1575df58f3926c2f3b6e00a6c45f773523Chandler Carruth if (!I->getParent() || !P->getParent() || !I->getParent()->getParent()) 104ff739c1575df58f3926c2f3b6e00a6c45f773523Chandler Carruth return false; 105ff739c1575df58f3926c2f3b6e00a6c45f773523Chandler Carruth 1061845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // If we have a DominatorTree then do a precise test. 1075b8f0ddc7e5bc3c7ffe1b2226a8316796f18b90eEli Friedman if (DT) { 1085b8f0ddc7e5bc3c7ffe1b2226a8316796f18b90eEli Friedman if (!DT->isReachableFromEntry(P->getParent())) 1095b8f0ddc7e5bc3c7ffe1b2226a8316796f18b90eEli Friedman return true; 1105b8f0ddc7e5bc3c7ffe1b2226a8316796f18b90eEli Friedman if (!DT->isReachableFromEntry(I->getParent())) 1115b8f0ddc7e5bc3c7ffe1b2226a8316796f18b90eEli Friedman return false; 1125b8f0ddc7e5bc3c7ffe1b2226a8316796f18b90eEli Friedman return DT->dominates(I, P); 1135b8f0ddc7e5bc3c7ffe1b2226a8316796f18b90eEli Friedman } 1141845009290e4d804ad377927bd8a08cca3036adcDuncan Sands 1151845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // Otherwise, if the instruction is in the entry block, and is not an invoke, 1161845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // then it obviously dominates all phi nodes. 1171845009290e4d804ad377927bd8a08cca3036adcDuncan Sands if (I->getParent() == &I->getParent()->getParent()->getEntryBlock() && 1181845009290e4d804ad377927bd8a08cca3036adcDuncan Sands !isa<InvokeInst>(I)) 1191845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return true; 1201845009290e4d804ad377927bd8a08cca3036adcDuncan Sands 1211845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return false; 1221845009290e4d804ad377927bd8a08cca3036adcDuncan Sands} 123a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 1243421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// ExpandBinOp - Simplify "A op (B op' C)" by distributing op over op', turning 1253421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// it into "(A op B) op' (A op C)". Here "op" is given by Opcode and "op'" is 1263421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// given by OpcodeToExpand, while "A" corresponds to LHS and "B op' C" to RHS. 1273421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// Also performs the transform "(A op' B) op C" -> "(A op C) op' (B op C)". 1283421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// Returns the simplified value, or null if no simplification was performed. 1293421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sandsstatic Value *ExpandBinOp(unsigned Opcode, Value *LHS, Value *RHS, 1300aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands unsigned OpcToExpand, const Query &Q, 131618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier unsigned MaxRecurse) { 132e21083aa3a79506f896d95d7147c3c4627a77ef0Benjamin Kramer Instruction::BinaryOps OpcodeToExpand = (Instruction::BinaryOps)OpcToExpand; 1333421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 1343421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (!MaxRecurse--) 135dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 1363421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1373421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Check whether the expression has the form "(A op' B) op C". 1383421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (BinaryOperator *Op0 = dyn_cast<BinaryOperator>(LHS)) 1393421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Op0->getOpcode() == OpcodeToExpand) { 1403421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // It does! Try turning it into "(A op C) op' (B op C)". 1413421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands Value *A = Op0->getOperand(0), *B = Op0->getOperand(1), *C = RHS; 1423421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Do "A op C" and "B op C" both simplify? 1430aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *L = SimplifyBinOp(Opcode, A, C, Q, MaxRecurse)) 1440aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *R = SimplifyBinOp(Opcode, B, C, Q, MaxRecurse)) { 1453421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // They do! Return "L op' R" if it simplifies or is already available. 1463421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // If "L op' R" equals "A op' B" then "L op' R" is just the LHS. 147124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if ((L == A && R == B) || (Instruction::isCommutative(OpcodeToExpand) 148124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands && L == B && R == A)) { 149a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumExpand; 1503421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return LHS; 151a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 1523421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Otherwise return "L op' R" if it simplifies. 1530aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyBinOp(OpcodeToExpand, L, R, Q, MaxRecurse)) { 154a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumExpand; 1553421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 156a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 1573421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 1583421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 1593421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1603421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Check whether the expression has the form "A op (B op' C)". 1613421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (BinaryOperator *Op1 = dyn_cast<BinaryOperator>(RHS)) 1623421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Op1->getOpcode() == OpcodeToExpand) { 1633421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // It does! Try turning it into "(A op B) op' (A op C)". 1643421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands Value *A = LHS, *B = Op1->getOperand(0), *C = Op1->getOperand(1); 1653421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Do "A op B" and "A op C" both simplify? 1660aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *L = SimplifyBinOp(Opcode, A, B, Q, MaxRecurse)) 1670aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *R = SimplifyBinOp(Opcode, A, C, Q, MaxRecurse)) { 1683421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // They do! Return "L op' R" if it simplifies or is already available. 1693421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // If "L op' R" equals "B op' C" then "L op' R" is just the RHS. 170124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if ((L == B && R == C) || (Instruction::isCommutative(OpcodeToExpand) 171124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands && L == C && R == B)) { 172a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumExpand; 1733421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return RHS; 174a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 1753421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Otherwise return "L op' R" if it simplifies. 1760aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyBinOp(OpcodeToExpand, L, R, Q, MaxRecurse)) { 177a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumExpand; 1783421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 179a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 1803421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 1813421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 1823421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 183dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 1843421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands} 1853421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1863421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// FactorizeBinOp - Simplify "LHS Opcode RHS" by factorizing out a common term 1873421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// using the operation OpCodeToExtract. For example, when Opcode is Add and 1883421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// OpCodeToExtract is Mul then this tries to turn "(A*B)+(A*C)" into "A*(B+C)". 1893421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// Returns the simplified value, or null if no simplification was performed. 1903421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sandsstatic Value *FactorizeBinOp(unsigned Opcode, Value *LHS, Value *RHS, 1910aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands unsigned OpcToExtract, const Query &Q, 192618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier unsigned MaxRecurse) { 193e21083aa3a79506f896d95d7147c3c4627a77ef0Benjamin Kramer Instruction::BinaryOps OpcodeToExtract = (Instruction::BinaryOps)OpcToExtract; 1943421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 1953421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (!MaxRecurse--) 196dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 1973421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1983421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands BinaryOperator *Op0 = dyn_cast<BinaryOperator>(LHS); 1993421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands BinaryOperator *Op1 = dyn_cast<BinaryOperator>(RHS); 2003421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 2013421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (!Op0 || Op0->getOpcode() != OpcodeToExtract || 2023421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands !Op1 || Op1->getOpcode() != OpcodeToExtract) 203dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 2043421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 2053421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // The expression has the form "(A op' B) op (C op' D)". 20682fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands Value *A = Op0->getOperand(0), *B = Op0->getOperand(1); 20782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands Value *C = Op1->getOperand(0), *D = Op1->getOperand(1); 2083421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 2093421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Use left distributivity, i.e. "X op' (Y op Z) = (X op' Y) op (X op' Z)". 2103421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Does the instruction have the form "(A op' B) op (A op' D)" or, in the 2113421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // commutative case, "(A op' B) op (C op' A)"? 212124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (A == C || (Instruction::isCommutative(OpcodeToExtract) && A == D)) { 213124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands Value *DD = A == C ? D : C; 2143421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Form "A op' (B op DD)" if it simplifies completely. 2153421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Does "B op DD" simplify? 2160aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyBinOp(Opcode, B, DD, Q, MaxRecurse)) { 2173421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // It does! Return "A op' V" if it simplifies or is already available. 2181cd05bb605e3c3eee9197d3f10b628c60d0cc07aDuncan Sands // If V equals B then "A op' V" is just the LHS. If V equals DD then 2191cd05bb605e3c3eee9197d3f10b628c60d0cc07aDuncan Sands // "A op' V" is just the RHS. 220124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (V == B || V == DD) { 221a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumFactor; 222124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands return V == B ? LHS : RHS; 223a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 2243421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Otherwise return "A op' V" if it simplifies. 2250aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *W = SimplifyBinOp(OpcodeToExtract, A, V, Q, MaxRecurse)) { 226a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumFactor; 2273421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return W; 228a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 2293421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 2303421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 2313421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 2323421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Use right distributivity, i.e. "(X op Y) op' Z = (X op' Z) op (Y op' Z)". 2333421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Does the instruction have the form "(A op' B) op (C op' B)" or, in the 2343421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // commutative case, "(A op' B) op (B op' D)"? 235124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (B == D || (Instruction::isCommutative(OpcodeToExtract) && B == C)) { 236124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands Value *CC = B == D ? C : D; 2373421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Form "(A op CC) op' B" if it simplifies completely.. 2383421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Does "A op CC" simplify? 2390aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyBinOp(Opcode, A, CC, Q, MaxRecurse)) { 2403421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // It does! Return "V op' B" if it simplifies or is already available. 2411cd05bb605e3c3eee9197d3f10b628c60d0cc07aDuncan Sands // If V equals A then "V op' B" is just the LHS. If V equals CC then 2421cd05bb605e3c3eee9197d3f10b628c60d0cc07aDuncan Sands // "V op' B" is just the RHS. 243124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (V == A || V == CC) { 244a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumFactor; 245124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands return V == A ? LHS : RHS; 246a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 2473421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Otherwise return "V op' B" if it simplifies. 2480aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *W = SimplifyBinOp(OpcodeToExtract, V, B, Q, MaxRecurse)) { 249a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumFactor; 2503421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return W; 251a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 2523421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 2533421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 2543421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 255dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 2563421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands} 2573421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 2583421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// SimplifyAssociativeBinOp - Generic simplifications for associative binary 2593421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// operations. Returns the simpler value, or null if none was found. 260e21083aa3a79506f896d95d7147c3c4627a77ef0Benjamin Kramerstatic Value *SimplifyAssociativeBinOp(unsigned Opc, Value *LHS, Value *RHS, 2610aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 262e21083aa3a79506f896d95d7147c3c4627a77ef0Benjamin Kramer Instruction::BinaryOps Opcode = (Instruction::BinaryOps)Opc; 263566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands assert(Instruction::isAssociative(Opcode) && "Not an associative operation!"); 264566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 265566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 266566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (!MaxRecurse--) 267dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 268566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 269566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands BinaryOperator *Op0 = dyn_cast<BinaryOperator>(LHS); 270566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands BinaryOperator *Op1 = dyn_cast<BinaryOperator>(RHS); 271566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 272566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Transform: "(A op B) op C" ==> "A op (B op C)" if it simplifies completely. 273566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Op0 && Op0->getOpcode() == Opcode) { 274566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *A = Op0->getOperand(0); 275566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *B = Op0->getOperand(1); 276566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *C = RHS; 277566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 278566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Does "B op C" simplify? 2790aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyBinOp(Opcode, B, C, Q, MaxRecurse)) { 280566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // It does! Return "A op V" if it simplifies or is already available. 281566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // If V equals B then "A op V" is just the LHS. 282124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (V == B) return LHS; 283566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Otherwise return "A op V" if it simplifies. 2840aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *W = SimplifyBinOp(Opcode, A, V, Q, MaxRecurse)) { 285a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumReassoc; 286566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return W; 287a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 288566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 289566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 290566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 291566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Transform: "A op (B op C)" ==> "(A op B) op C" if it simplifies completely. 292566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Op1 && Op1->getOpcode() == Opcode) { 293566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *A = LHS; 294566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *B = Op1->getOperand(0); 295566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *C = Op1->getOperand(1); 296566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 297566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Does "A op B" simplify? 2980aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyBinOp(Opcode, A, B, Q, MaxRecurse)) { 299566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // It does! Return "V op C" if it simplifies or is already available. 300566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // If V equals B then "V op C" is just the RHS. 301124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (V == B) return RHS; 302566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Otherwise return "V op C" if it simplifies. 3030aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *W = SimplifyBinOp(Opcode, V, C, Q, MaxRecurse)) { 304a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumReassoc; 305566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return W; 306a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 307566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 308566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 309566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 310566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // The remaining transforms require commutativity as well as associativity. 311566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (!Instruction::isCommutative(Opcode)) 312dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 313566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 314566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Transform: "(A op B) op C" ==> "(C op A) op B" if it simplifies completely. 315566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Op0 && Op0->getOpcode() == Opcode) { 316566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *A = Op0->getOperand(0); 317566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *B = Op0->getOperand(1); 318566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *C = RHS; 319566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 320566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Does "C op A" simplify? 3210aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyBinOp(Opcode, C, A, Q, MaxRecurse)) { 322566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // It does! Return "V op B" if it simplifies or is already available. 323566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // If V equals A then "V op B" is just the LHS. 324124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (V == A) return LHS; 325566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Otherwise return "V op B" if it simplifies. 3260aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *W = SimplifyBinOp(Opcode, V, B, Q, MaxRecurse)) { 327a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumReassoc; 328566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return W; 329a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 330566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 331566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 332566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 333566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Transform: "A op (B op C)" ==> "B op (C op A)" if it simplifies completely. 334566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Op1 && Op1->getOpcode() == Opcode) { 335566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *A = LHS; 336566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *B = Op1->getOperand(0); 337566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *C = Op1->getOperand(1); 338566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 339566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Does "C op A" simplify? 3400aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyBinOp(Opcode, C, A, Q, MaxRecurse)) { 341566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // It does! Return "B op V" if it simplifies or is already available. 342566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // If V equals C then "B op V" is just the RHS. 343124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (V == C) return RHS; 344566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Otherwise return "B op V" if it simplifies. 3450aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *W = SimplifyBinOp(Opcode, B, V, Q, MaxRecurse)) { 346a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumReassoc; 347566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return W; 348a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 349566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 350566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 351566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 352dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 353566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands} 354566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 355b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// ThreadBinOpOverSelect - In the case of a binary operation with a select 356b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// instruction as an operand, try to simplify the binop by seeing whether 357b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// evaluating it on both branches of the select results in the same value. 358b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// Returns the common value if so, otherwise returns null. 359b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sandsstatic Value *ThreadBinOpOverSelect(unsigned Opcode, Value *LHS, Value *RHS, 3600aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 3610312a93693abc2eb682b2b101c889959888fd883Duncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 3620312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (!MaxRecurse--) 363dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 3640312a93693abc2eb682b2b101c889959888fd883Duncan Sands 365b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands SelectInst *SI; 366b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (isa<SelectInst>(LHS)) { 367b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands SI = cast<SelectInst>(LHS); 368b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } else { 369b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands assert(isa<SelectInst>(RHS) && "No select instruction operand!"); 370b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands SI = cast<SelectInst>(RHS); 371b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } 372b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 373b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // Evaluate the BinOp on the true and false branches of the select. 374b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Value *TV; 375b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Value *FV; 376b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (SI == LHS) { 3770aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands TV = SimplifyBinOp(Opcode, SI->getTrueValue(), RHS, Q, MaxRecurse); 3780aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands FV = SimplifyBinOp(Opcode, SI->getFalseValue(), RHS, Q, MaxRecurse); 379b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } else { 3800aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands TV = SimplifyBinOp(Opcode, LHS, SI->getTrueValue(), Q, MaxRecurse); 3810aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands FV = SimplifyBinOp(Opcode, LHS, SI->getFalseValue(), Q, MaxRecurse); 382b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } 383b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 3847cf85e74e3885005ca8e5fdb155fa5351e255b85Duncan Sands // If they simplified to the same value, then return the common value. 385124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands // If they both failed to simplify then return null. 386124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (TV == FV) 387b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return TV; 388b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 389b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // If one branch simplified to undef, return the other one. 390b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (TV && isa<UndefValue>(TV)) 391b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return FV; 392b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (FV && isa<UndefValue>(FV)) 393b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return TV; 394b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 395b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // If applying the operation did not change the true and false select values, 396b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // then the result of the binop is the select itself. 397124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (TV == SI->getTrueValue() && FV == SI->getFalseValue()) 398b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return SI; 399b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 400b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // If one branch simplified and the other did not, and the simplified 401b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // value is equal to the unsimplified one, return the simplified value. 402b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // For example, select (cond, X, X & Z) & Z -> X & Z. 403b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if ((FV && !TV) || (TV && !FV)) { 404b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // Check that the simplified value has the form "X op Y" where "op" is the 405b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // same as the original operation. 406b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Instruction *Simplified = dyn_cast<Instruction>(FV ? FV : TV); 407b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (Simplified && Simplified->getOpcode() == Opcode) { 408b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // The value that didn't simplify is "UnsimplifiedLHS op UnsimplifiedRHS". 409b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // We already know that "op" is the same as for the simplified value. See 410b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // if the operands match too. If so, return the simplified value. 411b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Value *UnsimplifiedBranch = FV ? SI->getTrueValue() : SI->getFalseValue(); 412b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Value *UnsimplifiedLHS = SI == LHS ? UnsimplifiedBranch : LHS; 413b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Value *UnsimplifiedRHS = SI == LHS ? RHS : UnsimplifiedBranch; 414124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (Simplified->getOperand(0) == UnsimplifiedLHS && 415124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands Simplified->getOperand(1) == UnsimplifiedRHS) 416b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return Simplified; 417b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (Simplified->isCommutative() && 418124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands Simplified->getOperand(1) == UnsimplifiedLHS && 419124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands Simplified->getOperand(0) == UnsimplifiedRHS) 420b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return Simplified; 421b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } 422b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } 423b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 424dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 425b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands} 426b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 427b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// ThreadCmpOverSelect - In the case of a comparison with a select instruction, 428b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// try to simplify the comparison by seeing whether both branches of the select 429b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// result in the same value. Returns the common value if so, otherwise returns 430b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// null. 431b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sandsstatic Value *ThreadCmpOverSelect(CmpInst::Predicate Pred, Value *LHS, 4320aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Value *RHS, const Query &Q, 433a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands unsigned MaxRecurse) { 4340312a93693abc2eb682b2b101c889959888fd883Duncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 4350312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (!MaxRecurse--) 436dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 4370312a93693abc2eb682b2b101c889959888fd883Duncan Sands 438b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // Make sure the select is on the LHS. 439b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (!isa<SelectInst>(LHS)) { 440b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands std::swap(LHS, RHS); 441b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Pred = CmpInst::getSwappedPredicate(Pred); 442b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } 443b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands assert(isa<SelectInst>(LHS) && "Not comparing with a select instruction!"); 444b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands SelectInst *SI = cast<SelectInst>(LHS); 4456dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands Value *Cond = SI->getCondition(); 4466dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands Value *TV = SI->getTrueValue(); 4476dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands Value *FV = SI->getFalseValue(); 448b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 44950ca4d37f7f3b460c6441eb5ad14625a7d86b5d9Duncan Sands // Now that we have "cmp select(Cond, TV, FV), RHS", analyse it. 450b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // Does "cmp TV, RHS" simplify? 4510aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Value *TCmp = SimplifyCmpInst(Pred, TV, RHS, Q, MaxRecurse); 4526dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (TCmp == Cond) { 4536dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // It not only simplified, it simplified to the select condition. Replace 4546dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // it with 'true'. 4556dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands TCmp = getTrue(Cond->getType()); 4566dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands } else if (!TCmp) { 4576dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // It didn't simplify. However if "cmp TV, RHS" is equal to the select 4586dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // condition then we can replace it with 'true'. Otherwise give up. 4596dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (!isSameCompare(Cond, Pred, TV, RHS)) 460dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 4616dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands TCmp = getTrue(Cond->getType()); 46250ca4d37f7f3b460c6441eb5ad14625a7d86b5d9Duncan Sands } 46350ca4d37f7f3b460c6441eb5ad14625a7d86b5d9Duncan Sands 4646dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // Does "cmp FV, RHS" simplify? 4650aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Value *FCmp = SimplifyCmpInst(Pred, FV, RHS, Q, MaxRecurse); 4666dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (FCmp == Cond) { 4676dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // It not only simplified, it simplified to the select condition. Replace 4686dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // it with 'false'. 4696dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands FCmp = getFalse(Cond->getType()); 4706dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands } else if (!FCmp) { 4716dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // It didn't simplify. However if "cmp FV, RHS" is equal to the select 4726dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // condition then we can replace it with 'false'. Otherwise give up. 4736dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (!isSameCompare(Cond, Pred, FV, RHS)) 474dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 4756dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands FCmp = getFalse(Cond->getType()); 4766dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands } 4776dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands 4786dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // If both sides simplified to the same value, then use it as the result of 4796dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // the original comparison. 4806dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (TCmp == FCmp) 4816dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return TCmp; 482aa97bb54f02784abefa0ae170af5937915bdb329Duncan Sands 483aa97bb54f02784abefa0ae170af5937915bdb329Duncan Sands // The remaining cases only make sense if the select condition has the same 484aa97bb54f02784abefa0ae170af5937915bdb329Duncan Sands // type as the result of the comparison, so bail out if this is not so. 485aa97bb54f02784abefa0ae170af5937915bdb329Duncan Sands if (Cond->getType()->isVectorTy() != RHS->getType()->isVectorTy()) 486dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 4876dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // If the false value simplified to false, then the result of the compare 4886dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // is equal to "Cond && TCmp". This also catches the case when the false 4896dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // value simplified to false and the true value to true, returning "Cond". 4906dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (match(FCmp, m_Zero())) 4910aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyAndInst(Cond, TCmp, Q, MaxRecurse)) 4926dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return V; 4936dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // If the true value simplified to true, then the result of the compare 4946dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // is equal to "Cond || FCmp". 4956dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (match(TCmp, m_One())) 4960aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyOrInst(Cond, FCmp, Q, MaxRecurse)) 4976dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return V; 4986dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // Finally, if the false value simplified to true and the true value to 4996dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // false, then the result of the compare is equal to "!Cond". 5006dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (match(FCmp, m_One()) && match(TCmp, m_Zero())) 5016dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (Value *V = 5026dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands SimplifyXorInst(Cond, Constant::getAllOnesValue(Cond->getType()), 5030aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse)) 5046dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return V; 5056dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands 506dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 507b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands} 508b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 509a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// ThreadBinOpOverPHI - In the case of a binary operation with an operand that 510a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// is a PHI instruction, try to simplify the binop by seeing whether evaluating 511a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// it on the incoming phi values yields the same result for every value. If so 512a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// returns the common value, otherwise returns null. 513a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *ThreadBinOpOverPHI(unsigned Opcode, Value *LHS, Value *RHS, 5140aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 5150312a93693abc2eb682b2b101c889959888fd883Duncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 5160312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (!MaxRecurse--) 517dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 5180312a93693abc2eb682b2b101c889959888fd883Duncan Sands 519a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands PHINode *PI; 520a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands if (isa<PHINode>(LHS)) { 521a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands PI = cast<PHINode>(LHS); 5221845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // Bail out if RHS and the phi may be mutually interdependent due to a loop. 5230aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (!ValueDominatesPHI(RHS, PI, Q.DT)) 524dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 525a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands } else { 526a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands assert(isa<PHINode>(RHS) && "No PHI instruction operand!"); 527a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands PI = cast<PHINode>(RHS); 5281845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // Bail out if LHS and the phi may be mutually interdependent due to a loop. 5290aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (!ValueDominatesPHI(LHS, PI, Q.DT)) 530dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 531a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands } 532a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 533a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // Evaluate the BinOp on the incoming phi values. 534dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Value *CommonValue = nullptr; 535a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands for (unsigned i = 0, e = PI->getNumIncomingValues(); i != e; ++i) { 536552008946530e01efdad15044e1f621883d14a3aDuncan Sands Value *Incoming = PI->getIncomingValue(i); 537ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // If the incoming value is the phi node itself, it can safely be skipped. 538552008946530e01efdad15044e1f621883d14a3aDuncan Sands if (Incoming == PI) continue; 539a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands Value *V = PI == LHS ? 5400aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands SimplifyBinOp(Opcode, Incoming, RHS, Q, MaxRecurse) : 5410aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands SimplifyBinOp(Opcode, LHS, Incoming, Q, MaxRecurse); 542a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the operation failed to simplify, or simplified to a different value 543a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // to previously, then give up. 544a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands if (!V || (CommonValue && V != CommonValue)) 545dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 546a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands CommonValue = V; 547a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands } 548a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 549a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return CommonValue; 550a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 551a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 552a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// ThreadCmpOverPHI - In the case of a comparison with a PHI instruction, try 553a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// try to simplify the comparison by seeing whether comparing with all of the 554a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// incoming phi values yields the same result every time. If so returns the 555a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// common result, otherwise returns null. 556a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *ThreadCmpOverPHI(CmpInst::Predicate Pred, Value *LHS, Value *RHS, 5570aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 5580312a93693abc2eb682b2b101c889959888fd883Duncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 5590312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (!MaxRecurse--) 560dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 5610312a93693abc2eb682b2b101c889959888fd883Duncan Sands 562a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // Make sure the phi is on the LHS. 563a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands if (!isa<PHINode>(LHS)) { 564a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands std::swap(LHS, RHS); 565a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands Pred = CmpInst::getSwappedPredicate(Pred); 566a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands } 567a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands assert(isa<PHINode>(LHS) && "Not comparing with a phi instruction!"); 568a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands PHINode *PI = cast<PHINode>(LHS); 569a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 5701845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // Bail out if RHS and the phi may be mutually interdependent due to a loop. 5710aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (!ValueDominatesPHI(RHS, PI, Q.DT)) 572dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 5731845009290e4d804ad377927bd8a08cca3036adcDuncan Sands 574a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // Evaluate the BinOp on the incoming phi values. 575dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Value *CommonValue = nullptr; 576a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands for (unsigned i = 0, e = PI->getNumIncomingValues(); i != e; ++i) { 577552008946530e01efdad15044e1f621883d14a3aDuncan Sands Value *Incoming = PI->getIncomingValue(i); 578ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // If the incoming value is the phi node itself, it can safely be skipped. 579552008946530e01efdad15044e1f621883d14a3aDuncan Sands if (Incoming == PI) continue; 5800aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Value *V = SimplifyCmpInst(Pred, Incoming, RHS, Q, MaxRecurse); 581a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the operation failed to simplify, or simplified to a different value 582a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // to previously, then give up. 583a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands if (!V || (CommonValue && V != CommonValue)) 584dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 585a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands CommonValue = V; 586a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands } 587a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 588a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return CommonValue; 589a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 590a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 5918aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner/// SimplifyAddInst - Given operands for an Add, see if we can 592d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner/// fold the result. If not, this returns null. 593ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sandsstatic Value *SimplifyAddInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, 5940aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 595d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 596d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 597d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Constant *Ops[] = { CLHS, CRHS }; 5980aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands return ConstantFoldInstOperands(Instruction::Add, CLHS->getType(), Ops, 59936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Q.DL, Q.TLI); 6008aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner } 60112a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 6028aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner // Canonicalize the constant to the RHS. 6038aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner std::swap(Op0, Op1); 6048aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner } 60512a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 606fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X + undef -> undef 607f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 608fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return Op1; 60912a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 610fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X + 0 -> X 611fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands if (match(Op1, m_Zero())) 612fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return Op0; 613fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 614fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X + (Y - X) -> Y 615fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // (Y - X) + X -> Y 616ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands // Eg: X + -X -> 0 617dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Value *Y = nullptr; 618124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (match(Op1, m_Sub(m_Value(Y), m_Specific(Op0))) || 619124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands match(Op0, m_Sub(m_Value(Y), m_Specific(Op1)))) 620fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return Y; 621fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 622fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X + ~X -> -1 since ~X = -X-1 623124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (match(Op0, m_Not(m_Specific(Op1))) || 624124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands match(Op1, m_Not(m_Specific(Op0)))) 625fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return Constant::getAllOnesValue(Op0->getType()); 62687689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands 62782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands /// i1 add -> xor. 62875d289ed6201e82718343d7a36d2a2fa082f6217Duncan Sands if (MaxRecurse && Op0->getType()->isIntegerTy(1)) 6290aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyXorInst(Op0, Op1, Q, MaxRecurse-1)) 63007f30fbd734069b80b90c6aeea0ae645ce3880c0Duncan Sands return V; 63182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 632566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Try some generic simplifications for associative operations. 6330aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyAssociativeBinOp(Instruction::Add, Op0, Op1, Q, 634566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands MaxRecurse)) 635566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return V; 636566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 6373421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Mul distributes over Add. Try some generic simplifications based on this. 6383421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = FactorizeBinOp(Instruction::Add, Op0, Op1, Instruction::Mul, 6390aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse)) 6403421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 6413421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 64287689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // Threading Add over selects and phi nodes is pointless, so don't bother. 64387689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // Threading over the select in "A + select(cond, B, C)" means evaluating 64487689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // "A+B" and "A+C" and seeing if they are equal; but they are equal if and 64587689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // only if B and C are equal. If B and C are equal then (since we assume 64687689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // that operands have already been simplified) "select(cond, B, C)" should 64787689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // have been simplified to the common value of B and C already. Analysing 64887689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // "A+B" and "A+C" thus gains nothing, but costs compile time. Similarly 64987689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // for threading over phi nodes. 65087689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands 651dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 6528aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner} 6538aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner 654ee9a2e322af96accc9e55ed6373c0057453714b1Duncan SandsValue *llvm::SimplifyAddInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, 65536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const DataLayout *DL, const TargetLibraryInfo *TLI, 656618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT) { 65736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return ::SimplifyAddInst(Op0, Op1, isNSW, isNUW, Query (DL, TLI, DT), 6580aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands RecursionLimit); 659ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands} 660ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands 661fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth/// \brief Compute the base pointer and cumulative constant offsets for V. 662fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth/// 663fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth/// This strips all constant offsets off of V, leaving it the base pointer, and 664fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth/// accumulates the total constant offset applied in the returned constant. It 665fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth/// returns 0 if V is not a pointer, and returns the constant '0' if there are 666fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth/// no constant offsets applied. 667819f9d6bf91c439967ef623d0c047e7f672683faDan Gohman/// 668819f9d6bf91c439967ef623d0c047e7f672683faDan Gohman/// This is very similar to GetPointerBaseWithConstantOffset except it doesn't 669819f9d6bf91c439967ef623d0c047e7f672683faDan Gohman/// follow non-inbounds geps. This allows it to remain usable for icmp ult/etc. 670819f9d6bf91c439967ef623d0c047e7f672683faDan Gohman/// folding. 67136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hinesstatic Constant *stripAndComputeConstantOffsets(const DataLayout *DL, 672baca5334db904819e6c0d26cd5f5203f82c44f6eBenjamin Kramer Value *&V, 673baca5334db904819e6c0d26cd5f5203f82c44f6eBenjamin Kramer bool AllowNonInbounds = false) { 674d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramer assert(V->getType()->getScalarType()->isPointerTy()); 675fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth 6763e3de565e9c7258fb97773b3a64fc091355cb2deDan Gohman // Without DataLayout, just be conservative for now. Theoretically, more could 6773e3de565e9c7258fb97773b3a64fc091355cb2deDan Gohman // be done in this case. 67836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (!DL) 6793e3de565e9c7258fb97773b3a64fc091355cb2deDan Gohman return ConstantInt::get(IntegerType::get(V->getContext(), 64), 0); 6803e3de565e9c7258fb97773b3a64fc091355cb2deDan Gohman 68136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Type *IntPtrTy = DL->getIntPtrType(V->getType())->getScalarType(); 6826b4dde71cfdcb2e1f2105dd8a677c14d8c3bb4b4Matt Arsenault APInt Offset = APInt::getNullValue(IntPtrTy->getIntegerBitWidth()); 683fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth 684fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth // Even though we don't look through PHI nodes, we could be called on an 685fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth // instruction in an unreachable block, which may be on a cycle. 686fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth SmallPtrSet<Value *, 4> Visited; 687fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth Visited.insert(V); 688fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth do { 689fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth if (GEPOperator *GEP = dyn_cast<GEPOperator>(V)) { 690baca5334db904819e6c0d26cd5f5203f82c44f6eBenjamin Kramer if ((!AllowNonInbounds && !GEP->isInBounds()) || 69136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines !GEP->accumulateConstantOffset(*DL, Offset)) 692fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth break; 693fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth V = GEP->getPointerOperand(); 694fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth } else if (Operator::getOpcode(V) == Instruction::BitCast) { 6956b4dde71cfdcb2e1f2105dd8a677c14d8c3bb4b4Matt Arsenault V = cast<Operator>(V)->getOperand(0); 696fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth } else if (GlobalAlias *GA = dyn_cast<GlobalAlias>(V)) { 697fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth if (GA->mayBeOverridden()) 698fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth break; 699fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth V = GA->getAliasee(); 700fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth } else { 701fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth break; 702fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth } 703d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramer assert(V->getType()->getScalarType()->isPointerTy() && 704d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramer "Unexpected operand type!"); 705fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth } while (Visited.insert(V)); 706fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth 707d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramer Constant *OffsetIntPtr = ConstantInt::get(IntPtrTy, Offset); 708d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramer if (V->getType()->isVectorTy()) 709d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramer return ConstantVector::getSplat(V->getType()->getVectorNumElements(), 710d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramer OffsetIntPtr); 711d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramer return OffsetIntPtr; 712fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth} 713fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth 714fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth/// \brief Compute the constant difference between two pointer values. 715fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth/// If the difference is not a constant, returns zero. 71636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hinesstatic Constant *computePointerDifference(const DataLayout *DL, 717fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth Value *LHS, Value *RHS) { 71836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Constant *LHSOffset = stripAndComputeConstantOffsets(DL, LHS); 71936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Constant *RHSOffset = stripAndComputeConstantOffsets(DL, RHS); 720fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth 721fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth // If LHS and RHS are not related via constant offsets to the same base 722fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth // value, there is nothing we can do here. 723fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth if (LHS != RHS) 724dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 725fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth 726fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth // Otherwise, the difference of LHS - RHS can be computed as: 727fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth // LHS - RHS 728fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth // = (LHSOffset + Base) - (RHSOffset + Base) 729fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth // = LHSOffset - RHSOffset 730fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth return ConstantExpr::getSub(LHSOffset, RHSOffset); 731fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth} 732fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth 733fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands/// SimplifySubInst - Given operands for a Sub, see if we can 734fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands/// fold the result. If not, this returns null. 735ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sandsstatic Value *SimplifySubInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, 7360aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 737fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands if (Constant *CLHS = dyn_cast<Constant>(Op0)) 738fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 739fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands Constant *Ops[] = { CLHS, CRHS }; 740fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return ConstantFoldInstOperands(Instruction::Sub, CLHS->getType(), 74136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Ops, Q.DL, Q.TLI); 742fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands } 743fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 744fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X - undef -> undef 745fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // undef - X -> undef 746f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op0, m_Undef()) || match(Op1, m_Undef())) 747fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return UndefValue::get(Op0->getType()); 748fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 749fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X - 0 -> X 750fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands if (match(Op1, m_Zero())) 751fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return Op0; 752fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 753fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X - X -> 0 754124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (Op0 == Op1) 755fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return Constant::getNullValue(Op0->getType()); 756fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 757fe02c69f84ad52d42be934e4fe702f03e4991a6aDuncan Sands // (X*2) - X -> X 758fe02c69f84ad52d42be934e4fe702f03e4991a6aDuncan Sands // (X<<1) - X -> X 759dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Value *X = nullptr; 760fe02c69f84ad52d42be934e4fe702f03e4991a6aDuncan Sands if (match(Op0, m_Mul(m_Specific(Op1), m_ConstantInt<2>())) || 761fe02c69f84ad52d42be934e4fe702f03e4991a6aDuncan Sands match(Op0, m_Shl(m_Specific(Op1), m_One()))) 762fe02c69f84ad52d42be934e4fe702f03e4991a6aDuncan Sands return Op1; 763fe02c69f84ad52d42be934e4fe702f03e4991a6aDuncan Sands 764b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // (X + Y) - Z -> X + (Y - Z) or Y + (X - Z) if everything simplifies. 765b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // For example, (X + Y) - Y -> X; (Y + X) - Y -> X 766dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Value *Y = nullptr, *Z = Op1; 767b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands if (MaxRecurse && match(Op0, m_Add(m_Value(X), m_Value(Y)))) { // (X + Y) - Z 768b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // See if "V === Y - Z" simplifies. 7690aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyBinOp(Instruction::Sub, Y, Z, Q, MaxRecurse-1)) 770b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does! Now see if "X + V" simplifies. 7710aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *W = SimplifyBinOp(Instruction::Add, X, V, Q, MaxRecurse-1)) { 772b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does, we successfully reassociated! 773b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands ++NumReassoc; 774b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands return W; 775b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands } 776b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // See if "V === X - Z" simplifies. 7770aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyBinOp(Instruction::Sub, X, Z, Q, MaxRecurse-1)) 778b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does! Now see if "Y + V" simplifies. 7790aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *W = SimplifyBinOp(Instruction::Add, Y, V, Q, MaxRecurse-1)) { 780b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does, we successfully reassociated! 781b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands ++NumReassoc; 782b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands return W; 783b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands } 784b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands } 78582fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 786b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // X - (Y + Z) -> (X - Y) - Z or (X - Z) - Y if everything simplifies. 787b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // For example, X - (X + 1) -> -1 788b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands X = Op0; 789b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands if (MaxRecurse && match(Op1, m_Add(m_Value(Y), m_Value(Z)))) { // X - (Y + Z) 790b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // See if "V === X - Y" simplifies. 7910aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyBinOp(Instruction::Sub, X, Y, Q, MaxRecurse-1)) 792b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does! Now see if "V - Z" simplifies. 7930aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *W = SimplifyBinOp(Instruction::Sub, V, Z, Q, MaxRecurse-1)) { 794b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does, we successfully reassociated! 795b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands ++NumReassoc; 796b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands return W; 797b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands } 798b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // See if "V === X - Z" simplifies. 7990aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyBinOp(Instruction::Sub, X, Z, Q, MaxRecurse-1)) 800b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does! Now see if "V - Y" simplifies. 8010aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *W = SimplifyBinOp(Instruction::Sub, V, Y, Q, MaxRecurse-1)) { 802b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does, we successfully reassociated! 803b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands ++NumReassoc; 804b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands return W; 805b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands } 806b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands } 807b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands 808b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // Z - (X - Y) -> (Z - X) + Y if everything simplifies. 809b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // For example, X - (X - Y) -> Y. 810b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands Z = Op0; 811c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands if (MaxRecurse && match(Op1, m_Sub(m_Value(X), m_Value(Y)))) // Z - (X - Y) 812c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands // See if "V === Z - X" simplifies. 8130aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyBinOp(Instruction::Sub, Z, X, Q, MaxRecurse-1)) 814b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does! Now see if "V + Y" simplifies. 8150aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *W = SimplifyBinOp(Instruction::Add, V, Y, Q, MaxRecurse-1)) { 816c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands // It does, we successfully reassociated! 817c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands ++NumReassoc; 818c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands return W; 819c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands } 820c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands 821bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands // trunc(X) - trunc(Y) -> trunc(X - Y) if everything simplifies. 822bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands if (MaxRecurse && match(Op0, m_Trunc(m_Value(X))) && 823bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands match(Op1, m_Trunc(m_Value(Y)))) 824bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands if (X->getType() == Y->getType()) 825bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands // See if "V === X - Y" simplifies. 826bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands if (Value *V = SimplifyBinOp(Instruction::Sub, X, Y, Q, MaxRecurse-1)) 827bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands // It does! Now see if "trunc V" simplifies. 828bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands if (Value *W = SimplifyTruncInst(V, Op0->getType(), Q, MaxRecurse-1)) 829bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands // It does, return the simplified "trunc V". 830bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands return W; 831bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands 832bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands // Variations on GEP(base, I, ...) - GEP(base, i, ...) -> GEP(null, I-i, ...). 8333e3de565e9c7258fb97773b3a64fc091355cb2deDan Gohman if (match(Op0, m_PtrToInt(m_Value(X))) && 834bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands match(Op1, m_PtrToInt(m_Value(Y)))) 83536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (Constant *Result = computePointerDifference(Q.DL, X, Y)) 836bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands return ConstantExpr::getIntegerCast(Result, Op0->getType(), true); 837bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands 8383421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Mul distributes over Sub. Try some generic simplifications based on this. 8393421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = FactorizeBinOp(Instruction::Sub, Op0, Op1, Instruction::Mul, 8400aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse)) 8413421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 8423421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 843b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // i1 sub -> xor. 844b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands if (MaxRecurse && Op0->getType()->isIntegerTy(1)) 8450aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyXorInst(Op0, Op1, Q, MaxRecurse-1)) 846b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands return V; 847b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands 848fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // Threading Sub over selects and phi nodes is pointless, so don't bother. 849fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // Threading over the select in "A - select(cond, B, C)" means evaluating 850fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // "A-B" and "A-C" and seeing if they are equal; but they are equal if and 851fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // only if B and C are equal. If B and C are equal then (since we assume 852fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // that operands have already been simplified) "select(cond, B, C)" should 853fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // have been simplified to the common value of B and C already. Analysing 854fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // "A-B" and "A-C" thus gains nothing, but costs compile time. Similarly 855fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // for threading over phi nodes. 856fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 857dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 858fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands} 859fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 860ee9a2e322af96accc9e55ed6373c0057453714b1Duncan SandsValue *llvm::SimplifySubInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, 86136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const DataLayout *DL, const TargetLibraryInfo *TLI, 862618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT) { 86336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return ::SimplifySubInst(Op0, Op1, isNSW, isNUW, Query (DL, TLI, DT), 8640aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands RecursionLimit); 865ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands} 866ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands 86709ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman/// Given operands for an FAdd, see if we can fold the result. If not, this 86809ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman/// returns null. 86909ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilsemanstatic Value *SimplifyFAddInst(Value *Op0, Value *Op1, FastMathFlags FMF, 87009ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman const Query &Q, unsigned MaxRecurse) { 87109ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 87209ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 87309ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman Constant *Ops[] = { CLHS, CRHS }; 87409ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman return ConstantFoldInstOperands(Instruction::FAdd, CLHS->getType(), 87536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Ops, Q.DL, Q.TLI); 87609ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman } 87709ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 87809ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman // Canonicalize the constant to the RHS. 87909ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman std::swap(Op0, Op1); 88009ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman } 88109ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 88209ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman // fadd X, -0 ==> X 88309ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if (match(Op1, m_NegZero())) 88409ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman return Op0; 88509ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 88609ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman // fadd X, 0 ==> X, when we know X is not -0 88709ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if (match(Op1, m_Zero()) && 88809ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman (FMF.noSignedZeros() || CannotBeNegativeZero(Op0))) 88909ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman return Op0; 89009ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 89109ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman // fadd [nnan ninf] X, (fsub [nnan ninf] 0, X) ==> 0 89209ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman // where nnan and ninf have to occur at least once somewhere in this 89309ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman // expression 894dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Value *SubOp = nullptr; 89509ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if (match(Op1, m_FSub(m_AnyZero(), m_Specific(Op0)))) 89609ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman SubOp = Op1; 89709ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman else if (match(Op0, m_FSub(m_AnyZero(), m_Specific(Op1)))) 89809ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman SubOp = Op0; 89909ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if (SubOp) { 90009ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman Instruction *FSub = cast<Instruction>(SubOp); 90109ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if ((FMF.noNaNs() || FSub->hasNoNaNs()) && 90209ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman (FMF.noInfs() || FSub->hasNoInfs())) 90309ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman return Constant::getNullValue(Op0->getType()); 90409ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman } 90509ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 906dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 90709ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman} 90809ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 90909ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman/// Given operands for an FSub, see if we can fold the result. If not, this 91009ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman/// returns null. 91109ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilsemanstatic Value *SimplifyFSubInst(Value *Op0, Value *Op1, FastMathFlags FMF, 91209ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman const Query &Q, unsigned MaxRecurse) { 91309ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 91409ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 91509ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman Constant *Ops[] = { CLHS, CRHS }; 91609ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman return ConstantFoldInstOperands(Instruction::FSub, CLHS->getType(), 91736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Ops, Q.DL, Q.TLI); 91809ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman } 91909ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman } 92009ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 92109ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman // fsub X, 0 ==> X 92209ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if (match(Op1, m_Zero())) 92309ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman return Op0; 92409ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 92509ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman // fsub X, -0 ==> X, when we know X is not -0 92609ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if (match(Op1, m_NegZero()) && 92709ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman (FMF.noSignedZeros() || CannotBeNegativeZero(Op0))) 92809ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman return Op0; 92909ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 93009ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman // fsub 0, (fsub -0.0, X) ==> X 93109ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman Value *X; 93209ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if (match(Op0, m_AnyZero())) { 93309ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if (match(Op1, m_FSub(m_NegZero(), m_Value(X)))) 93409ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman return X; 93509ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if (FMF.noSignedZeros() && match(Op1, m_FSub(m_AnyZero(), m_Value(X)))) 93609ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman return X; 93709ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman } 93809ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 93909ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman // fsub nnan ninf x, x ==> 0.0 94009ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if (FMF.noNaNs() && FMF.noInfs() && Op0 == Op1) 94109ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman return Constant::getNullValue(Op0->getType()); 94209ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 943dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 94409ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman} 94509ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 946eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman/// Given the operands for an FMul, see if we can fold the result 947eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilsemanstatic Value *SimplifyFMulInst(Value *Op0, Value *Op1, 948eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman FastMathFlags FMF, 949eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman const Query &Q, 950eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman unsigned MaxRecurse) { 951eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 952eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 953eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman Constant *Ops[] = { CLHS, CRHS }; 954eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman return ConstantFoldInstOperands(Instruction::FMul, CLHS->getType(), 95536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Ops, Q.DL, Q.TLI); 956eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman } 957eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman 95809ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman // Canonicalize the constant to the RHS. 95909ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman std::swap(Op0, Op1); 960eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman } 961eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman 96209ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman // fmul X, 1.0 ==> X 96309ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if (match(Op1, m_FPOne())) 96409ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman return Op0; 96509ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 96609ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman // fmul nnan nsz X, 0 ==> 0 96709ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if (FMF.noNaNs() && FMF.noSignedZeros() && match(Op1, m_AnyZero())) 96809ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman return Op1; 96909ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 970dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 971eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman} 972eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman 97382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands/// SimplifyMulInst - Given operands for a Mul, see if we can 97482fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands/// fold the result. If not, this returns null. 9750aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyMulInst(Value *Op0, Value *Op1, const Query &Q, 9760aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands unsigned MaxRecurse) { 97782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 97882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 97982fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands Constant *Ops[] = { CLHS, CRHS }; 98082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return ConstantFoldInstOperands(Instruction::Mul, CLHS->getType(), 98136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Ops, Q.DL, Q.TLI); 98282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands } 98382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 98482fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // Canonicalize the constant to the RHS. 98582fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands std::swap(Op0, Op1); 98682fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands } 98782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 98882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // X * undef -> 0 989f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 99082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return Constant::getNullValue(Op0->getType()); 99182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 99282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // X * 0 -> 0 99382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (match(Op1, m_Zero())) 99482fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return Op1; 99582fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 99682fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // X * 1 -> X 99782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (match(Op1, m_One())) 99882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return Op0; 99982fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 10001895e98ef38afbe011575cc25f4889d96e37421bDuncan Sands // (X / Y) * Y -> X if the division is exact. 1001dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Value *X = nullptr; 100255c6d57734cd2f141dc2d6912fc22746d5eeae54Benjamin Kramer if (match(Op0, m_Exact(m_IDiv(m_Value(X), m_Specific(Op1)))) || // (X / Y) * Y 100355c6d57734cd2f141dc2d6912fc22746d5eeae54Benjamin Kramer match(Op1, m_Exact(m_IDiv(m_Value(X), m_Specific(Op0))))) // Y * (X / Y) 100455c6d57734cd2f141dc2d6912fc22746d5eeae54Benjamin Kramer return X; 10051895e98ef38afbe011575cc25f4889d96e37421bDuncan Sands 10065413880654585f01ea9880f24f07f27c8da56ba8Nick Lewycky // i1 mul -> and. 100775d289ed6201e82718343d7a36d2a2fa082f6217Duncan Sands if (MaxRecurse && Op0->getType()->isIntegerTy(1)) 10080aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyAndInst(Op0, Op1, Q, MaxRecurse-1)) 100907f30fbd734069b80b90c6aeea0ae645ce3880c0Duncan Sands return V; 101082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 101182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // Try some generic simplifications for associative operations. 10120aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyAssociativeBinOp(Instruction::Mul, Op0, Op1, Q, 101382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands MaxRecurse)) 101482fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return V; 101582fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 101682fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // Mul distributes over Add. Try some generic simplifications based on this. 101782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (Value *V = ExpandBinOp(Instruction::Mul, Op0, Op1, Instruction::Add, 10180aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse)) 101982fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return V; 102082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 102182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // If the operation is with the result of a select instruction, check whether 102282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // operating on either branch of the select always yields the same value. 102382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) 10240aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadBinOpOverSelect(Instruction::Mul, Op0, Op1, Q, 102582fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands MaxRecurse)) 102682fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return V; 102782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 102882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // If the operation is with the result of a phi instruction, check whether 102982fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // operating on all incoming values of the phi always yields the same value. 103082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (isa<PHINode>(Op0) || isa<PHINode>(Op1)) 10310aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadBinOpOverPHI(Instruction::Mul, Op0, Op1, Q, 103282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands MaxRecurse)) 103382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return V; 103482fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 1035dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 103682fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands} 103782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 103809ee250e728ccdb7afc6354d777f8319c5a0465cMichael IlsemanValue *llvm::SimplifyFAddInst(Value *Op0, Value *Op1, FastMathFlags FMF, 103936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const DataLayout *DL, const TargetLibraryInfo *TLI, 104009ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman const DominatorTree *DT) { 104136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return ::SimplifyFAddInst(Op0, Op1, FMF, Query (DL, TLI, DT), RecursionLimit); 104209ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman} 104309ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 104409ee250e728ccdb7afc6354d777f8319c5a0465cMichael IlsemanValue *llvm::SimplifyFSubInst(Value *Op0, Value *Op1, FastMathFlags FMF, 104536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const DataLayout *DL, const TargetLibraryInfo *TLI, 104609ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman const DominatorTree *DT) { 104736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return ::SimplifyFSubInst(Op0, Op1, FMF, Query (DL, TLI, DT), RecursionLimit); 104809ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman} 104909ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 1050eb61c920f12cacee38815bf10821d2f294b66f3aMichael IlsemanValue *llvm::SimplifyFMulInst(Value *Op0, Value *Op1, 1051eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman FastMathFlags FMF, 105236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const DataLayout *DL, 1053eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman const TargetLibraryInfo *TLI, 1054eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman const DominatorTree *DT) { 105536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return ::SimplifyFMulInst(Op0, Op1, FMF, Query (DL, TLI, DT), RecursionLimit); 1056eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman} 1057eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman 105836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen HinesValue *llvm::SimplifyMulInst(Value *Op0, Value *Op1, const DataLayout *DL, 1059618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 106082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands const DominatorTree *DT) { 106136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return ::SimplifyMulInst(Op0, Op1, Query (DL, TLI, DT), RecursionLimit); 106282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands} 106382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 1064593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands/// SimplifyDiv - Given operands for an SDiv or UDiv, see if we can 1065593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands/// fold the result. If not, this returns null. 1066479b4b9ef06dd84097202ffa6aea07913cdf651cAnders Carlssonstatic Value *SimplifyDiv(Instruction::BinaryOps Opcode, Value *Op0, Value *Op1, 10670aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 1068593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Constant *C0 = dyn_cast<Constant>(Op0)) { 1069593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Constant *C1 = dyn_cast<Constant>(Op1)) { 1070593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands Constant *Ops[] = { C0, C1 }; 107136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return ConstantFoldInstOperands(Opcode, C0->getType(), Ops, Q.DL, Q.TLI); 1072593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands } 1073593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands } 1074593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1075a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands bool isSigned = Opcode == Instruction::SDiv; 1076a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands 1077593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // X / undef -> undef 1078f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 1079593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return Op1; 1080593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1081593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // undef / X -> 0 1082f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op0, m_Undef())) 1083593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return Constant::getNullValue(Op0->getType()); 1084593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1085593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // 0 / X -> 0, we don't need to preserve faults! 1086593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (match(Op0, m_Zero())) 1087593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return Op0; 1088593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1089593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // X / 1 -> X 1090593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (match(Op1, m_One())) 1091593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return Op0; 1092593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1093593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Op0->getType()->isIntegerTy(1)) 1094593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // It can't be division by zero, hence it must be division by one. 1095593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return Op0; 1096593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1097593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // X / X -> 1 1098593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Op0 == Op1) 1099593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return ConstantInt::get(Op0->getType(), 1); 1100593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1101593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // (X * Y) / Y -> X if the multiplication does not overflow. 1102dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Value *X = nullptr, *Y = nullptr; 1103593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (match(Op0, m_Mul(m_Value(X), m_Value(Y))) && (X == Op1 || Y == Op1)) { 1104593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Y != Op1) std::swap(X, Y); // Ensure expression is (X * Y) / Y, Y = Op1 110532a43cc0fc3cd42702d7859eaa58dd42f561a54dDuncan Sands OverflowingBinaryOperator *Mul = cast<OverflowingBinaryOperator>(Op0); 11064b720718fbda1194f925e0a9d931bc220e8b0e3aDuncan Sands // If the Mul knows it does not overflow, then we are good to go. 11074b720718fbda1194f925e0a9d931bc220e8b0e3aDuncan Sands if ((isSigned && Mul->hasNoSignedWrap()) || 11084b720718fbda1194f925e0a9d931bc220e8b0e3aDuncan Sands (!isSigned && Mul->hasNoUnsignedWrap())) 11094b720718fbda1194f925e0a9d931bc220e8b0e3aDuncan Sands return X; 1110593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // If X has the form X = A / Y then X * Y cannot overflow. 1111593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (BinaryOperator *Div = dyn_cast<BinaryOperator>(X)) 1112593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Div->getOpcode() == Opcode && Div->getOperand(1) == Y) 1113593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return X; 1114593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands } 1115593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1116a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands // (X rem Y) / Y -> 0 1117a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands if ((isSigned && match(Op0, m_SRem(m_Value(), m_Specific(Op1)))) || 1118a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands (!isSigned && match(Op0, m_URem(m_Value(), m_Specific(Op1))))) 1119a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands return Constant::getNullValue(Op0->getType()); 1120a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands 1121a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands // If the operation is with the result of a select instruction, check whether 1122a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands // operating on either branch of the select always yields the same value. 1123a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) 11240aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadBinOpOverSelect(Opcode, Op0, Op1, Q, MaxRecurse)) 1125a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands return V; 1126a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands 1127a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands // If the operation is with the result of a phi instruction, check whether 1128a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands // operating on all incoming values of the phi always yields the same value. 1129a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands if (isa<PHINode>(Op0) || isa<PHINode>(Op1)) 11300aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadBinOpOverPHI(Opcode, Op0, Op1, Q, MaxRecurse)) 1131a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands return V; 1132a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands 1133dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 1134593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands} 1135593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1136593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands/// SimplifySDivInst - Given operands for an SDiv, see if we can 1137593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands/// fold the result. If not, this returns null. 11380aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifySDivInst(Value *Op0, Value *Op1, const Query &Q, 11390aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands unsigned MaxRecurse) { 11400aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyDiv(Instruction::SDiv, Op0, Op1, Q, MaxRecurse)) 1141593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return V; 1142593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1143dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 1144593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands} 1145593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 114636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen HinesValue *llvm::SimplifySDivInst(Value *Op0, Value *Op1, const DataLayout *DL, 1147618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 11481fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel const DominatorTree *DT) { 114936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return ::SimplifySDivInst(Op0, Op1, Query (DL, TLI, DT), RecursionLimit); 1150593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands} 1151593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1152593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands/// SimplifyUDivInst - Given operands for a UDiv, see if we can 1153593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands/// fold the result. If not, this returns null. 11540aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyUDivInst(Value *Op0, Value *Op1, const Query &Q, 11550aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands unsigned MaxRecurse) { 11560aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyDiv(Instruction::UDiv, Op0, Op1, Q, MaxRecurse)) 1157593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return V; 1158593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1159dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 1160593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands} 1161593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 116236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen HinesValue *llvm::SimplifyUDivInst(Value *Op0, Value *Op1, const DataLayout *DL, 1163618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 11641fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel const DominatorTree *DT) { 116536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return ::SimplifyUDivInst(Op0, Op1, Query (DL, TLI, DT), RecursionLimit); 1166593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands} 1167593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 11680aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyFDivInst(Value *Op0, Value *Op1, const Query &Q, 11690aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands unsigned) { 11701fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel // undef / X -> undef (the undef could be a snan). 1171f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op0, m_Undef())) 11721fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel return Op0; 11731fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel 11741fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel // X / undef -> undef 1175f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 11761fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel return Op1; 11771fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel 1178dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 11791fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel} 11801fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel 118136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen HinesValue *llvm::SimplifyFDivInst(Value *Op0, Value *Op1, const DataLayout *DL, 1182618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 11831fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel const DominatorTree *DT) { 118436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return ::SimplifyFDivInst(Op0, Op1, Query (DL, TLI, DT), RecursionLimit); 11851fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel} 11861fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel 1187f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands/// SimplifyRem - Given operands for an SRem or URem, see if we can 1188f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands/// fold the result. If not, this returns null. 1189f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sandsstatic Value *SimplifyRem(Instruction::BinaryOps Opcode, Value *Op0, Value *Op1, 11900aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 1191f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (Constant *C0 = dyn_cast<Constant>(Op0)) { 1192f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (Constant *C1 = dyn_cast<Constant>(Op1)) { 1193f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands Constant *Ops[] = { C0, C1 }; 119436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return ConstantFoldInstOperands(Opcode, C0->getType(), Ops, Q.DL, Q.TLI); 1195f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands } 1196f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands } 1197f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1198f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // X % undef -> undef 1199f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op1, m_Undef())) 1200f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Op1; 1201f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1202f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // undef % X -> 0 1203f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op0, m_Undef())) 1204f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Constant::getNullValue(Op0->getType()); 1205f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1206f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // 0 % X -> 0, we don't need to preserve faults! 1207f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op0, m_Zero())) 1208f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Op0; 1209f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1210f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // X % 0 -> undef, we don't need to preserve faults! 1211f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op1, m_Zero())) 1212f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return UndefValue::get(Op0->getType()); 1213f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1214f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // X % 1 -> 0 1215f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op1, m_One())) 1216f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Constant::getNullValue(Op0->getType()); 1217f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1218f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (Op0->getType()->isIntegerTy(1)) 1219f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // It can't be remainder by zero, hence it must be remainder by one. 1220f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Constant::getNullValue(Op0->getType()); 1221f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1222f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // X % X -> 0 1223f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (Op0 == Op1) 1224f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Constant::getNullValue(Op0->getType()); 1225f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1226f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // If the operation is with the result of a select instruction, check whether 1227f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // operating on either branch of the select always yields the same value. 1228f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) 12290aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadBinOpOverSelect(Opcode, Op0, Op1, Q, MaxRecurse)) 1230f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return V; 1231f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1232f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // If the operation is with the result of a phi instruction, check whether 1233f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // operating on all incoming values of the phi always yields the same value. 1234f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (isa<PHINode>(Op0) || isa<PHINode>(Op1)) 12350aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadBinOpOverPHI(Opcode, Op0, Op1, Q, MaxRecurse)) 1236f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return V; 1237f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1238dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 1239f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1240f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1241f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands/// SimplifySRemInst - Given operands for an SRem, see if we can 1242f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands/// fold the result. If not, this returns null. 12430aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifySRemInst(Value *Op0, Value *Op1, const Query &Q, 12440aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands unsigned MaxRecurse) { 12450aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyRem(Instruction::SRem, Op0, Op1, Q, MaxRecurse)) 1246f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return V; 1247f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1248dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 1249f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1250f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 125136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen HinesValue *llvm::SimplifySRemInst(Value *Op0, Value *Op1, const DataLayout *DL, 1252618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1253f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands const DominatorTree *DT) { 125436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return ::SimplifySRemInst(Op0, Op1, Query (DL, TLI, DT), RecursionLimit); 1255f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1256f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1257f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands/// SimplifyURemInst - Given operands for a URem, see if we can 1258f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands/// fold the result. If not, this returns null. 12590aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyURemInst(Value *Op0, Value *Op1, const Query &Q, 1260618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier unsigned MaxRecurse) { 12610aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyRem(Instruction::URem, Op0, Op1, Q, MaxRecurse)) 1262f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return V; 1263f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1264dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 1265f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1266f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 126736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen HinesValue *llvm::SimplifyURemInst(Value *Op0, Value *Op1, const DataLayout *DL, 1268618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1269f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands const DominatorTree *DT) { 127036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return ::SimplifyURemInst(Op0, Op1, Query (DL, TLI, DT), RecursionLimit); 1271f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1272f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 12730aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyFRemInst(Value *Op0, Value *Op1, const Query &, 1274618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier unsigned) { 1275f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // undef % X -> undef (the undef could be a snan). 1276f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op0, m_Undef())) 1277f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Op0; 1278f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1279f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // X % undef -> undef 1280f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op1, m_Undef())) 1281f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Op1; 1282f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1283dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 1284f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1285f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 128636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen HinesValue *llvm::SimplifyFRemInst(Value *Op0, Value *Op1, const DataLayout *DL, 1287618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1288f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands const DominatorTree *DT) { 128936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return ::SimplifyFRemInst(Op0, Op1, Query (DL, TLI, DT), RecursionLimit); 129036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines} 129136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 129236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines/// isUndefShift - Returns true if a shift by \c Amount always yields undef. 129336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hinesstatic bool isUndefShift(Value *Amount) { 129436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Constant *C = dyn_cast<Constant>(Amount); 129536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (!C) 129636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return false; 129736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 129836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // X shift by undef -> undef because it may shift by the bitwidth. 129936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (isa<UndefValue>(C)) 130036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return true; 130136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 130236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // Shifting by the bitwidth or more is undefined. 130336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (ConstantInt *CI = dyn_cast<ConstantInt>(C)) 130436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (CI->getValue().getLimitedValue() >= 130536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines CI->getType()->getScalarSizeInBits()) 130636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return true; 130736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 130836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // If all lanes of a vector shift are undefined the whole shift is. 130936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (isa<ConstantVector>(C) || isa<ConstantDataVector>(C)) { 131036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines for (unsigned I = 0, E = C->getType()->getVectorNumElements(); I != E; ++I) 131136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (!isUndefShift(C->getAggregateElement(I))) 131236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return false; 131336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return true; 131436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } 131536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 131636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return false; 1317f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1318f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1319cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands/// SimplifyShift - Given operands for an Shl, LShr or AShr, see if we can 1320c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands/// fold the result. If not, this returns null. 1321cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sandsstatic Value *SimplifyShift(unsigned Opcode, Value *Op0, Value *Op1, 13220aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 1323c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands if (Constant *C0 = dyn_cast<Constant>(Op0)) { 1324c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands if (Constant *C1 = dyn_cast<Constant>(Op1)) { 1325c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands Constant *Ops[] = { C0, C1 }; 132636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return ConstantFoldInstOperands(Opcode, C0->getType(), Ops, Q.DL, Q.TLI); 1327c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands } 1328c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands } 1329c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1330cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // 0 shift by X -> 0 1331c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands if (match(Op0, m_Zero())) 1332c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return Op0; 1333c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1334cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // X shift by 0 -> X 1335c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands if (match(Op1, m_Zero())) 1336c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return Op0; 1337c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 133836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // Fold undefined shifts. 133936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (isUndefShift(Op1)) 134036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return UndefValue::get(Op0->getType()); 1341c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1342cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // If the operation is with the result of a select instruction, check whether 1343cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // operating on either branch of the select always yields the same value. 1344cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) 13450aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadBinOpOverSelect(Opcode, Op0, Op1, Q, MaxRecurse)) 1346cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return V; 1347cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands 1348cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // If the operation is with the result of a phi instruction, check whether 1349cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // operating on all incoming values of the phi always yields the same value. 1350cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands if (isa<PHINode>(Op0) || isa<PHINode>(Op1)) 13510aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadBinOpOverPHI(Opcode, Op0, Op1, Q, MaxRecurse)) 1352cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return V; 1353cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands 1354dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 1355cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands} 1356cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands 1357cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands/// SimplifyShlInst - Given operands for an Shl, see if we can 1358cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands/// fold the result. If not, this returns null. 135981a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattnerstatic Value *SimplifyShlInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, 13600aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 13610aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyShift(Instruction::Shl, Op0, Op1, Q, MaxRecurse)) 1362cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return V; 1363cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands 1364cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // undef << X -> 0 1365f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op0, m_Undef())) 1366cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return Constant::getNullValue(Op0->getType()); 1367cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands 136881a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner // (X >> A) << A -> X 136981a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Value *X; 137055c6d57734cd2f141dc2d6912fc22746d5eeae54Benjamin Kramer if (match(Op0, m_Exact(m_Shr(m_Value(X), m_Specific(Op1))))) 137181a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner return X; 1372dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 1373c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands} 1374c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 137581a0dc911586c77421c2255aa417dc9b350b9e20Chris LattnerValue *llvm::SimplifyShlInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, 137636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const DataLayout *DL, const TargetLibraryInfo *TLI, 1377618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT) { 137836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return ::SimplifyShlInst(Op0, Op1, isNSW, isNUW, Query (DL, TLI, DT), 13790aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands RecursionLimit); 1380c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands} 1381c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1382c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands/// SimplifyLShrInst - Given operands for an LShr, see if we can 1383c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands/// fold the result. If not, this returns null. 138481a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattnerstatic Value *SimplifyLShrInst(Value *Op0, Value *Op1, bool isExact, 13850aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 13860aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyShift(Instruction::LShr, Op0, Op1, Q, MaxRecurse)) 1387cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return V; 1388c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 13898c5c6f0e090f91b6555cdd9d2eea238fff3befe6David Majnemer // X >> X -> 0 13908c5c6f0e090f91b6555cdd9d2eea238fff3befe6David Majnemer if (Op0 == Op1) 13918c5c6f0e090f91b6555cdd9d2eea238fff3befe6David Majnemer return Constant::getNullValue(Op0->getType()); 13928c5c6f0e090f91b6555cdd9d2eea238fff3befe6David Majnemer 1393c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands // undef >>l X -> 0 1394f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op0, m_Undef())) 1395c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return Constant::getNullValue(Op0->getType()); 1396c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 139781a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner // (X << A) >> A -> X 139881a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Value *X; 139981a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner if (match(Op0, m_Shl(m_Value(X), m_Specific(Op1))) && 140081a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner cast<OverflowingBinaryOperator>(Op0)->hasNoUnsignedWrap()) 140181a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner return X; 140252fb846578714d14bbde9b28884a6a8729217677Duncan Sands 1403dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 1404c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands} 1405c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 140681a0dc911586c77421c2255aa417dc9b350b9e20Chris LattnerValue *llvm::SimplifyLShrInst(Value *Op0, Value *Op1, bool isExact, 140736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const DataLayout *DL, 1408618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1409618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT) { 141036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return ::SimplifyLShrInst(Op0, Op1, isExact, Query (DL, TLI, DT), 14110aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands RecursionLimit); 1412c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands} 1413c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1414c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands/// SimplifyAShrInst - Given operands for an AShr, see if we can 1415c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands/// fold the result. If not, this returns null. 141681a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattnerstatic Value *SimplifyAShrInst(Value *Op0, Value *Op1, bool isExact, 14170aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 14180aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyShift(Instruction::AShr, Op0, Op1, Q, MaxRecurse)) 1419cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return V; 1420c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 14218c5c6f0e090f91b6555cdd9d2eea238fff3befe6David Majnemer // X >> X -> 0 14228c5c6f0e090f91b6555cdd9d2eea238fff3befe6David Majnemer if (Op0 == Op1) 14238c5c6f0e090f91b6555cdd9d2eea238fff3befe6David Majnemer return Constant::getNullValue(Op0->getType()); 14248c5c6f0e090f91b6555cdd9d2eea238fff3befe6David Majnemer 1425c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands // all ones >>a X -> all ones 1426c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands if (match(Op0, m_AllOnes())) 1427c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return Op0; 1428c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1429c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands // undef >>a X -> all ones 1430f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op0, m_Undef())) 1431c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return Constant::getAllOnesValue(Op0->getType()); 1432c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 143381a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner // (X << A) >> A -> X 143481a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Value *X; 143581a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner if (match(Op0, m_Shl(m_Value(X), m_Specific(Op1))) && 143681a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner cast<OverflowingBinaryOperator>(Op0)->hasNoSignedWrap()) 143781a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner return X; 143852fb846578714d14bbde9b28884a6a8729217677Duncan Sands 1439dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 1440c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands} 1441c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 144281a0dc911586c77421c2255aa417dc9b350b9e20Chris LattnerValue *llvm::SimplifyAShrInst(Value *Op0, Value *Op1, bool isExact, 144336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const DataLayout *DL, 1444618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1445618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT) { 144636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return ::SimplifyAShrInst(Op0, Op1, isExact, Query (DL, TLI, DT), 14470aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands RecursionLimit); 1448c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands} 1449c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 14508aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner/// SimplifyAndInst - Given operands for an And, see if we can 14518aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner/// fold the result. If not, this returns null. 14520aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyAndInst(Value *Op0, Value *Op1, const Query &Q, 1453618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier unsigned MaxRecurse) { 14548aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 14558aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 14568aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner Constant *Ops[] = { CLHS, CRHS }; 1457d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return ConstantFoldInstOperands(Instruction::And, CLHS->getType(), 145836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Ops, Q.DL, Q.TLI); 1459d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 146012a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1461d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // Canonicalize the constant to the RHS. 1462d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner std::swap(Op0, Op1); 1463d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 146412a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1465d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X & undef -> 0 1466f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 1467d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Constant::getNullValue(Op0->getType()); 146812a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1469d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X & X = X 1470124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (Op0 == Op1) 1471d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 147212a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 14732b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // X & 0 = 0 14742b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (match(Op1, m_Zero())) 1475d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op1; 147612a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 14772b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // X & -1 = X 14782b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (match(Op1, m_AllOnes())) 14792b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return Op0; 148012a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1481d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // A & ~A = ~A & A = 0 148281a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner if (match(Op0, m_Not(m_Specific(Op1))) || 148381a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner match(Op1, m_Not(m_Specific(Op0)))) 1484d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Constant::getNullValue(Op0->getType()); 148512a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1486d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // (A | ?) & A = A 1487dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Value *A = nullptr, *B = nullptr; 1488d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (match(Op0, m_Or(m_Value(A), m_Value(B))) && 1489124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands (A == Op1 || B == Op1)) 1490d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op1; 149112a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1492d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // A & (A | ?) = A 1493d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (match(Op1, m_Or(m_Value(A), m_Value(B))) && 1494124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands (A == Op0 || B == Op0)) 1495d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 149612a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1497dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands // A & (-A) = A if A is a power of two or zero. 1498dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands if (match(Op0, m_Neg(m_Specific(Op1))) || 1499dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands match(Op1, m_Neg(m_Specific(Op0)))) { 1500dbaa2376f7b3c027e895ff4bee3ae08351f3ea88Rafael Espindola if (isKnownToBeAPowerOfTwo(Op0, /*OrZero*/true)) 1501dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands return Op0; 1502dbaa2376f7b3c027e895ff4bee3ae08351f3ea88Rafael Espindola if (isKnownToBeAPowerOfTwo(Op1, /*OrZero*/true)) 1503dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands return Op1; 1504dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands } 1505dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands 1506566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Try some generic simplifications for associative operations. 15070aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyAssociativeBinOp(Instruction::And, Op0, Op1, Q, 15080aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands MaxRecurse)) 1509566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return V; 15106844c8ea5a67e551be7106d6b7b9e1a64eecbe51Benjamin Kramer 15113421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // And distributes over Or. Try some generic simplifications based on this. 15123421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = ExpandBinOp(Instruction::And, Op0, Op1, Instruction::Or, 15130aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse)) 15143421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 15153421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 15163421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // And distributes over Xor. Try some generic simplifications based on this. 15173421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = ExpandBinOp(Instruction::And, Op0, Op1, Instruction::Xor, 15180aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse)) 15193421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 15203421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 15213421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Or distributes over And. Try some generic simplifications based on this. 15223421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = FactorizeBinOp(Instruction::And, Op0, Op1, Instruction::Or, 15230aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse)) 15243421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 15253421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1526b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // If the operation is with the result of a select instruction, check whether 1527b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // operating on either branch of the select always yields the same value. 15280312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) 15290aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadBinOpOverSelect(Instruction::And, Op0, Op1, Q, 15300aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands MaxRecurse)) 1531a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return V; 1532a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 1533a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the operation is with the result of a phi instruction, check whether 1534a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // operating on all incoming values of the phi always yields the same value. 15350312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<PHINode>(Op0) || isa<PHINode>(Op1)) 15360aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadBinOpOverPHI(Instruction::And, Op0, Op1, Q, 15370312a93693abc2eb682b2b101c889959888fd883Duncan Sands MaxRecurse)) 1538b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return V; 1539b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 1540dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 1541d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner} 15429f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 154336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen HinesValue *llvm::SimplifyAndInst(Value *Op0, Value *Op1, const DataLayout *DL, 1544618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 15451845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const DominatorTree *DT) { 154636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return ::SimplifyAndInst(Op0, Op1, Query (DL, TLI, DT), RecursionLimit); 1547a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 1548a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 1549d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner/// SimplifyOrInst - Given operands for an Or, see if we can 15509f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner/// fold the result. If not, this returns null. 15510aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyOrInst(Value *Op0, Value *Op1, const Query &Q, 15520aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands unsigned MaxRecurse) { 1553d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 1554d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 1555d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Constant *Ops[] = { CLHS, CRHS }; 1556d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return ConstantFoldInstOperands(Instruction::Or, CLHS->getType(), 155736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Ops, Q.DL, Q.TLI); 1558d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 155912a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1560d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // Canonicalize the constant to the RHS. 1561d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner std::swap(Op0, Op1); 1562d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 156312a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1564d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X | undef -> -1 1565f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 1566d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Constant::getAllOnesValue(Op0->getType()); 156712a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1568d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X | X = X 1569124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (Op0 == Op1) 1570d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 1571d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 15722b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // X | 0 = X 15732b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (match(Op1, m_Zero())) 1574d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 157512a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 15762b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // X | -1 = -1 15772b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (match(Op1, m_AllOnes())) 15782b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return Op1; 157912a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1580d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // A | ~A = ~A | A = -1 158181a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner if (match(Op0, m_Not(m_Specific(Op1))) || 158281a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner match(Op1, m_Not(m_Specific(Op0)))) 1583d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Constant::getAllOnesValue(Op0->getType()); 158412a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1585d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // (A & ?) | A = A 1586dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Value *A = nullptr, *B = nullptr; 1587d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (match(Op0, m_And(m_Value(A), m_Value(B))) && 1588124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands (A == Op1 || B == Op1)) 1589d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op1; 159012a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1591d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // A | (A & ?) = A 1592d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (match(Op1, m_And(m_Value(A), m_Value(B))) && 1593124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands (A == Op0 || B == Op0)) 1594d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 159512a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 159638f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer // ~(A & ?) | A = -1 159738f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer if (match(Op0, m_Not(m_And(m_Value(A), m_Value(B)))) && 159838f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer (A == Op1 || B == Op1)) 159938f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer return Constant::getAllOnesValue(Op1->getType()); 160038f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer 160138f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer // A | ~(A & ?) = -1 160238f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer if (match(Op1, m_Not(m_And(m_Value(A), m_Value(B)))) && 160338f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer (A == Op0 || B == Op0)) 160438f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer return Constant::getAllOnesValue(Op0->getType()); 160538f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer 1606566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Try some generic simplifications for associative operations. 16070aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyAssociativeBinOp(Instruction::Or, Op0, Op1, Q, 16080aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands MaxRecurse)) 1609566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return V; 16106844c8ea5a67e551be7106d6b7b9e1a64eecbe51Benjamin Kramer 16113421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Or distributes over And. Try some generic simplifications based on this. 16120aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ExpandBinOp(Instruction::Or, Op0, Op1, Instruction::And, Q, 16130aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands MaxRecurse)) 16143421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 16153421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 16163421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // And distributes over Or. Try some generic simplifications based on this. 16173421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = FactorizeBinOp(Instruction::Or, Op0, Op1, Instruction::And, 16180aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse)) 16193421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 16203421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1621b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // If the operation is with the result of a select instruction, check whether 1622b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // operating on either branch of the select always yields the same value. 16230312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) 16240aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadBinOpOverSelect(Instruction::Or, Op0, Op1, Q, 16250312a93693abc2eb682b2b101c889959888fd883Duncan Sands MaxRecurse)) 1626a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return V; 1627a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 1628a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the operation is with the result of a phi instruction, check whether 1629a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // operating on all incoming values of the phi always yields the same value. 16300312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<PHINode>(Op0) || isa<PHINode>(Op1)) 16310aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadBinOpOverPHI(Instruction::Or, Op0, Op1, Q, MaxRecurse)) 1632b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return V; 1633b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 1634dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 16359f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner} 16369f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 163736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen HinesValue *llvm::SimplifyOrInst(Value *Op0, Value *Op1, const DataLayout *DL, 1638618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 16391845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const DominatorTree *DT) { 164036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return ::SimplifyOrInst(Op0, Op1, Query (DL, TLI, DT), RecursionLimit); 1641a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 1642d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 16432b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands/// SimplifyXorInst - Given operands for a Xor, see if we can 16442b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands/// fold the result. If not, this returns null. 16450aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyXorInst(Value *Op0, Value *Op1, const Query &Q, 16460aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands unsigned MaxRecurse) { 16472b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 16482b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 16492b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands Constant *Ops[] = { CLHS, CRHS }; 16502b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return ConstantFoldInstOperands(Instruction::Xor, CLHS->getType(), 165136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Ops, Q.DL, Q.TLI); 16522b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands } 16532b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 16542b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // Canonicalize the constant to the RHS. 16552b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands std::swap(Op0, Op1); 16562b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands } 16572b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 16582b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // A ^ undef -> undef 1659f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 1660f8b1a5ea9602bb65a5cf59d3d34f2851a08cdc3eDuncan Sands return Op1; 16612b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 16622b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // A ^ 0 = A 16632b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (match(Op1, m_Zero())) 16642b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return Op0; 16652b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 1666f23d4adbfaf870d5fa67c6bff0da7891d3a98f9dEli Friedman // A ^ A = 0 1667f23d4adbfaf870d5fa67c6bff0da7891d3a98f9dEli Friedman if (Op0 == Op1) 1668f23d4adbfaf870d5fa67c6bff0da7891d3a98f9dEli Friedman return Constant::getNullValue(Op0->getType()); 1669f23d4adbfaf870d5fa67c6bff0da7891d3a98f9dEli Friedman 16702b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // A ^ ~A = ~A ^ A = -1 167181a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner if (match(Op0, m_Not(m_Specific(Op1))) || 167281a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner match(Op1, m_Not(m_Specific(Op0)))) 16732b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return Constant::getAllOnesValue(Op0->getType()); 16742b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 1675566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Try some generic simplifications for associative operations. 16760aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyAssociativeBinOp(Instruction::Xor, Op0, Op1, Q, 16770aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands MaxRecurse)) 1678566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return V; 16792b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 16803421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // And distributes over Xor. Try some generic simplifications based on this. 16813421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = FactorizeBinOp(Instruction::Xor, Op0, Op1, Instruction::And, 16820aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse)) 16833421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 16843421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 168587689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // Threading Xor over selects and phi nodes is pointless, so don't bother. 168687689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // Threading over the select in "A ^ select(cond, B, C)" means evaluating 168787689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // "A^B" and "A^C" and seeing if they are equal; but they are equal if and 168887689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // only if B and C are equal. If B and C are equal then (since we assume 168987689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // that operands have already been simplified) "select(cond, B, C)" should 169087689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // have been simplified to the common value of B and C already. Analysing 169187689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // "A^B" and "A^C" thus gains nothing, but costs compile time. Similarly 169287689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // for threading over phi nodes. 16932b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 1694dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 16952b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands} 16962b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 169736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen HinesValue *llvm::SimplifyXorInst(Value *Op0, Value *Op1, const DataLayout *DL, 1698618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 16992b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands const DominatorTree *DT) { 170036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return ::SimplifyXorInst(Op0, Op1, Query (DL, TLI, DT), RecursionLimit); 17012b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands} 17022b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 1703db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattnerstatic Type *GetCompareTy(Value *Op) { 1704210c5d4880b525e064088b6fec713260128c16ebChris Lattner return CmpInst::makeCmpResultType(Op->getType()); 1705210c5d4880b525e064088b6fec713260128c16ebChris Lattner} 1706210c5d4880b525e064088b6fec713260128c16ebChris Lattner 1707e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands/// ExtractEquivalentCondition - Rummage around inside V looking for something 1708e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands/// equivalent to the comparison "LHS Pred RHS". Return such a value if found, 1709e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands/// otherwise return null. Helper function for analyzing max/min idioms. 1710e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sandsstatic Value *ExtractEquivalentCondition(Value *V, CmpInst::Predicate Pred, 1711e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands Value *LHS, Value *RHS) { 1712e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands SelectInst *SI = dyn_cast<SelectInst>(V); 1713e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (!SI) 1714dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 1715e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands CmpInst *Cmp = dyn_cast<CmpInst>(SI->getCondition()); 1716e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (!Cmp) 1717dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 1718e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands Value *CmpLHS = Cmp->getOperand(0), *CmpRHS = Cmp->getOperand(1); 1719e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Pred == Cmp->getPredicate() && LHS == CmpLHS && RHS == CmpRHS) 1720e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return Cmp; 1721e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Pred == CmpInst::getSwappedPredicate(Cmp->getPredicate()) && 1722e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands LHS == CmpRHS && RHS == CmpLHS) 1723e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return Cmp; 1724dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 1725e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands} 1726e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands 1727901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// A significant optimization not implemented here is assuming that alloca 1728901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// addresses are not equal to incoming argument values. They don't *alias*, 1729901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// as we say, but that doesn't mean they aren't equal, so we take a 1730901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// conservative approach. 1731901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// 1732901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// This is inspired in part by C++11 5.10p1: 1733901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// "Two pointers of the same type compare equal if and only if they are both 1734901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// null, both point to the same function, or both represent the same 1735901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// address." 1736901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// 1737901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// This is pretty permissive. 1738901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// 1739901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// It's also partly due to C11 6.5.9p6: 1740901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// "Two pointers compare equal if and only if both are null pointers, both are 1741901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// pointers to the same object (including a pointer to an object and a 1742901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// subobject at its beginning) or function, both are pointers to one past the 1743901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// last element of the same array object, or one is a pointer to one past the 1744901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// end of one array object and the other is a pointer to the start of a 174592c3742319cc219f8a57aa7d8eea5b17ec93ad06NAKAMURA Takumi// different array object that happens to immediately follow the first array 1746901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// object in the address space.) 1747901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// 1748901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// C11's version is more restrictive, however there's no reason why an argument 1749901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// couldn't be a one-past-the-end value for a stack object in the caller and be 1750901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// equal to the beginning of a stack object in the callee. 1751901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// 1752901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// If the C and C++ standards are ever made sufficiently restrictive in this 1753901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// area, it may be possible to update LLVM's semantics accordingly and reinstate 1754901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// this optimization. 175536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hinesstatic Constant *computePointerICmp(const DataLayout *DL, 1756fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman const TargetLibraryInfo *TLI, 175758725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth CmpInst::Predicate Pred, 175858725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth Value *LHS, Value *RHS) { 1759fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // First, skip past any trivial no-ops. 1760fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman LHS = LHS->stripPointerCasts(); 1761fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman RHS = RHS->stripPointerCasts(); 1762fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman 1763fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // A non-null pointer is not equal to a null pointer. 17646629210aaf9d2e4fcbecc80b35f72108304da4b4Benjamin Kramer if (llvm::isKnownNonNull(LHS, TLI) && isa<ConstantPointerNull>(RHS) && 1765fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman (Pred == CmpInst::ICMP_EQ || Pred == CmpInst::ICMP_NE)) 1766fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman return ConstantInt::get(GetCompareTy(LHS), 1767fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman !CmpInst::isTrueWhenEqual(Pred)); 1768fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman 176958725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth // We can only fold certain predicates on pointer comparisons. 177058725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth switch (Pred) { 177158725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth default: 1772dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 177358725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth 177458725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth // Equality comaprisons are easy to fold. 177558725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth case CmpInst::ICMP_EQ: 177658725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth case CmpInst::ICMP_NE: 177758725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth break; 177858725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth 177958725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth // We can only handle unsigned relational comparisons because 'inbounds' on 178058725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth // a GEP only protects against unsigned wrapping. 178158725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth case CmpInst::ICMP_UGT: 178258725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth case CmpInst::ICMP_UGE: 178358725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth case CmpInst::ICMP_ULT: 178458725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth case CmpInst::ICMP_ULE: 178558725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth // However, we have to switch them to their signed variants to handle 178658725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth // negative indices from the base pointer. 178758725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth Pred = ICmpInst::getSignedPredicate(Pred); 178858725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth break; 178958725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth } 179058725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth 1791fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // Strip off any constant offsets so that we can reason about them. 1792fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // It's tempting to use getUnderlyingObject or even just stripInBoundsOffsets 1793fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // here and compare base addresses like AliasAnalysis does, however there are 1794fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // numerous hazards. AliasAnalysis and its utilities rely on special rules 1795fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // governing loads and stores which don't apply to icmps. Also, AliasAnalysis 1796fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // doesn't need to guarantee pointer inequality when it says NoAlias. 179736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Constant *LHSOffset = stripAndComputeConstantOffsets(DL, LHS); 179836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Constant *RHSOffset = stripAndComputeConstantOffsets(DL, RHS); 1799fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman 1800fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // If LHS and RHS are related via constant offsets to the same base 1801fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // value, we can replace it with an icmp which just compares the offsets. 1802fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman if (LHS == RHS) 1803fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman return ConstantExpr::getICmp(Pred, LHSOffset, RHSOffset); 1804fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman 1805fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // Various optimizations for (in)equality comparisons. 1806fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman if (Pred == CmpInst::ICMP_EQ || Pred == CmpInst::ICMP_NE) { 1807fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // Different non-empty allocations that exist at the same time have 1808fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // different addresses (if the program can tell). Global variables always 1809fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // exist, so they always exist during the lifetime of each other and all 1810fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // allocas. Two different allocas usually have different addresses... 1811fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // 1812fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // However, if there's an @llvm.stackrestore dynamically in between two 1813fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // allocas, they may have the same address. It's tempting to reduce the 1814fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // scope of the problem by only looking at *static* allocas here. That would 1815fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // cover the majority of allocas while significantly reducing the likelihood 1816fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // of having an @llvm.stackrestore pop up in the middle. However, it's not 1817fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // actually impossible for an @llvm.stackrestore to pop up in the middle of 1818fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // an entry block. Also, if we have a block that's not attached to a 1819fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // function, we can't tell if it's "static" under the current definition. 1820fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // Theoretically, this problem could be fixed by creating a new kind of 1821fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // instruction kind specifically for static allocas. Such a new instruction 1822fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // could be required to be at the top of the entry block, thus preventing it 1823fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // from being subject to a @llvm.stackrestore. Instcombine could even 1824fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // convert regular allocas into these special allocas. It'd be nifty. 1825fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // However, until then, this problem remains open. 1826fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // 1827fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // So, we'll assume that two non-empty allocas have different addresses 1828fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // for now. 1829fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // 1830fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // With all that, if the offsets are within the bounds of their allocations 1831fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // (and not one-past-the-end! so we can't use inbounds!), and their 1832fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // allocations aren't the same, the pointers are not equal. 1833fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // 1834fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // Note that it's not necessary to check for LHS being a global variable 1835fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // address, due to canonicalization and constant folding. 1836fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman if (isa<AllocaInst>(LHS) && 1837fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman (isa<AllocaInst>(RHS) || isa<GlobalVariable>(RHS))) { 1838d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramer ConstantInt *LHSOffsetCI = dyn_cast<ConstantInt>(LHSOffset); 1839d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramer ConstantInt *RHSOffsetCI = dyn_cast<ConstantInt>(RHSOffset); 1840fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman uint64_t LHSSize, RHSSize; 1841d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramer if (LHSOffsetCI && RHSOffsetCI && 184236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines getObjectSize(LHS, LHSSize, DL, TLI) && 184336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines getObjectSize(RHS, RHSSize, DL, TLI)) { 1844d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramer const APInt &LHSOffsetValue = LHSOffsetCI->getValue(); 1845d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramer const APInt &RHSOffsetValue = RHSOffsetCI->getValue(); 1846fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman if (!LHSOffsetValue.isNegative() && 1847fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman !RHSOffsetValue.isNegative() && 1848fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman LHSOffsetValue.ult(LHSSize) && 1849fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman RHSOffsetValue.ult(RHSSize)) { 1850fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman return ConstantInt::get(GetCompareTy(LHS), 1851fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman !CmpInst::isTrueWhenEqual(Pred)); 1852fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman } 1853fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman } 185458725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth 1855fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // Repeat the above check but this time without depending on DataLayout 1856fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // or being able to compute a precise size. 1857fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman if (!cast<PointerType>(LHS->getType())->isEmptyTy() && 1858fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman !cast<PointerType>(RHS->getType())->isEmptyTy() && 1859fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman LHSOffset->isNullValue() && 1860fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman RHSOffset->isNullValue()) 1861fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman return ConstantInt::get(GetCompareTy(LHS), 1862fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman !CmpInst::isTrueWhenEqual(Pred)); 1863fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman } 1864baca5334db904819e6c0d26cd5f5203f82c44f6eBenjamin Kramer 1865baca5334db904819e6c0d26cd5f5203f82c44f6eBenjamin Kramer // Even if an non-inbounds GEP occurs along the path we can still optimize 1866baca5334db904819e6c0d26cd5f5203f82c44f6eBenjamin Kramer // equality comparisons concerning the result. We avoid walking the whole 1867baca5334db904819e6c0d26cd5f5203f82c44f6eBenjamin Kramer // chain again by starting where the last calls to 1868baca5334db904819e6c0d26cd5f5203f82c44f6eBenjamin Kramer // stripAndComputeConstantOffsets left off and accumulate the offsets. 186936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Constant *LHSNoBound = stripAndComputeConstantOffsets(DL, LHS, true); 187036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Constant *RHSNoBound = stripAndComputeConstantOffsets(DL, RHS, true); 1871baca5334db904819e6c0d26cd5f5203f82c44f6eBenjamin Kramer if (LHS == RHS) 1872baca5334db904819e6c0d26cd5f5203f82c44f6eBenjamin Kramer return ConstantExpr::getICmp(Pred, 1873baca5334db904819e6c0d26cd5f5203f82c44f6eBenjamin Kramer ConstantExpr::getAdd(LHSOffset, LHSNoBound), 1874baca5334db904819e6c0d26cd5f5203f82c44f6eBenjamin Kramer ConstantExpr::getAdd(RHSOffset, RHSNoBound)); 1875fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman } 187658725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth 1877fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // Otherwise, fail. 1878dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 187958725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth} 1880009e2650d69fe93bda1864340c5f000e56c52fb8Chris Lattner 18819dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// SimplifyICmpInst - Given operands for an ICmpInst, see if we can 18829dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// fold the result. If not, this returns null. 1883a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS, 18840aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 18859f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner CmpInst::Predicate Pred = (CmpInst::Predicate)Predicate; 18869dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner assert(CmpInst::isIntPredicate(Pred) && "Not an integer compare!"); 188712a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1888d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(LHS)) { 18898f73deaa8732a556046bf4ac6207be55972e3b74Chris Lattner if (Constant *CRHS = dyn_cast<Constant>(RHS)) 189036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return ConstantFoldCompareInstOperands(Pred, CLHS, CRHS, Q.DL, Q.TLI); 1891d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 1892d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // If we have a constant, make sure it is on the RHS. 1893d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner std::swap(LHS, RHS); 1894d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Pred = CmpInst::getSwappedPredicate(Pred); 1895d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 189612a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1897db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *ITy = GetCompareTy(LHS); // The return type. 1898db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *OpTy = LHS->getType(); // The operand type. 189912a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1900210c5d4880b525e064088b6fec713260128c16ebChris Lattner // icmp X, X -> true/false 1901c8e14b3d37b80abb6adb4b831af0452d9ecbf2b2Chris Lattner // X icmp undef -> true/false. For example, icmp ugt %X, undef -> false 1902c8e14b3d37b80abb6adb4b831af0452d9ecbf2b2Chris Lattner // because X could be 0. 1903124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (LHS == RHS || isa<UndefValue>(RHS)) 1904210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(ITy, CmpInst::isTrueWhenEqual(Pred)); 190512a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 19066dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // Special case logic when the operands have i1 type. 190766d004ef708642bbdc38fd761507f2e9ee3970cdNick Lewycky if (OpTy->getScalarType()->isIntegerTy(1)) { 19086dc91253ab1872e118b08511a09d5c934988354eDuncan Sands switch (Pred) { 19096dc91253ab1872e118b08511a09d5c934988354eDuncan Sands default: break; 19106dc91253ab1872e118b08511a09d5c934988354eDuncan Sands case ICmpInst::ICMP_EQ: 19116dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // X == 1 -> X 19126dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (match(RHS, m_One())) 19136dc91253ab1872e118b08511a09d5c934988354eDuncan Sands return LHS; 19146dc91253ab1872e118b08511a09d5c934988354eDuncan Sands break; 19156dc91253ab1872e118b08511a09d5c934988354eDuncan Sands case ICmpInst::ICMP_NE: 19166dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // X != 0 -> X 19176dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (match(RHS, m_Zero())) 19186dc91253ab1872e118b08511a09d5c934988354eDuncan Sands return LHS; 19196dc91253ab1872e118b08511a09d5c934988354eDuncan Sands break; 19206dc91253ab1872e118b08511a09d5c934988354eDuncan Sands case ICmpInst::ICMP_UGT: 19216dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // X >u 0 -> X 19226dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (match(RHS, m_Zero())) 19236dc91253ab1872e118b08511a09d5c934988354eDuncan Sands return LHS; 19246dc91253ab1872e118b08511a09d5c934988354eDuncan Sands break; 19256dc91253ab1872e118b08511a09d5c934988354eDuncan Sands case ICmpInst::ICMP_UGE: 19266dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // X >=u 1 -> X 19276dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (match(RHS, m_One())) 19286dc91253ab1872e118b08511a09d5c934988354eDuncan Sands return LHS; 19296dc91253ab1872e118b08511a09d5c934988354eDuncan Sands break; 19306dc91253ab1872e118b08511a09d5c934988354eDuncan Sands case ICmpInst::ICMP_SLT: 19316dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // X <s 0 -> X 19326dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (match(RHS, m_Zero())) 19336dc91253ab1872e118b08511a09d5c934988354eDuncan Sands return LHS; 19346dc91253ab1872e118b08511a09d5c934988354eDuncan Sands break; 19356dc91253ab1872e118b08511a09d5c934988354eDuncan Sands case ICmpInst::ICMP_SLE: 19366dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // X <=s -1 -> X 19376dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (match(RHS, m_One())) 19386dc91253ab1872e118b08511a09d5c934988354eDuncan Sands return LHS; 19396dc91253ab1872e118b08511a09d5c934988354eDuncan Sands break; 19406dc91253ab1872e118b08511a09d5c934988354eDuncan Sands } 19416dc91253ab1872e118b08511a09d5c934988354eDuncan Sands } 194212a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1943d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands // If we are comparing with zero then try hard since this is a common case. 1944d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (match(RHS, m_Zero())) { 1945d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands bool LHSKnownNonNegative, LHSKnownNegative; 1946d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands switch (Pred) { 1947858143816d43e58b17bfd11cb1b57afbd7f0f893Craig Topper default: llvm_unreachable("Unknown ICmp predicate!"); 1948d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_ULT: 1949f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 1950d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_UGE: 1951f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 1952d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_EQ: 1953d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_ULE: 195436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (isKnownNonZero(LHS, Q.DL)) 1955f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 1956d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands break; 1957d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_NE: 1958d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_UGT: 195936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (isKnownNonZero(LHS, Q.DL)) 1960f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 1961d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands break; 1962d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_SLT: 196336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, Q.DL); 1964d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNegative) 1965f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 1966d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNonNegative) 1967f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 1968d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands break; 1969d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_SLE: 197036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, Q.DL); 1971d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNegative) 1972f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 197336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (LHSKnownNonNegative && isKnownNonZero(LHS, Q.DL)) 1974f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 1975d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands break; 1976d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_SGE: 197736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, Q.DL); 1978d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNegative) 1979f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 1980d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNonNegative) 1981f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 1982d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands break; 1983d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_SGT: 198436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, Q.DL); 1985d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNegative) 1986f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 198736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (LHSKnownNonNegative && isKnownNonZero(LHS, Q.DL)) 1988f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 1989d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands break; 1990d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands } 1991d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands } 1992d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands 1993d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands // See if we are doing a comparison with a constant integer. 1994210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) { 19953a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // Rule out tautological comparisons (eg., ult 0 or uge 0). 19963a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky ConstantRange RHS_CR = ICmpInst::makeConstantRange(Pred, CI->getValue()); 19973a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (RHS_CR.isEmptySet()) 19983a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky return ConstantInt::getFalse(CI->getContext()); 19993a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (RHS_CR.isFullSet()) 20003a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky return ConstantInt::getTrue(CI->getContext()); 20013a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky 20023a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // Many binary operators with constant RHS have easy to compute constant 20033a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // range. Use them to check whether the comparison is a tautology. 2004dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines unsigned Width = CI->getBitWidth(); 20053a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt Lower = APInt(Width, 0); 20063a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt Upper = APInt(Width, 0); 20073a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky ConstantInt *CI2; 20083a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (match(LHS, m_URem(m_Value(), m_ConstantInt(CI2)))) { 20093a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'urem x, CI2' produces [0, CI2). 20103a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = CI2->getValue(); 20113a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_SRem(m_Value(), m_ConstantInt(CI2)))) { 20123a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'srem x, CI2' produces (-|CI2|, |CI2|). 20133a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = CI2->getValue().abs(); 20143a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Lower = (-Upper) + 1; 2015c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands } else if (match(LHS, m_UDiv(m_ConstantInt(CI2), m_Value()))) { 2016c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands // 'udiv CI2, x' produces [0, CI2]. 20177781ae5be570940178295f6f808215089a3fe411Eli Friedman Upper = CI2->getValue() + 1; 20183a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_UDiv(m_Value(), m_ConstantInt(CI2)))) { 20193a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'udiv x, CI2' produces [0, UINT_MAX / CI2]. 20203a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt NegOne = APInt::getAllOnesValue(Width); 20213a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (!CI2->isZero()) 20223a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = NegOne.udiv(CI2->getValue()) + 1; 2023dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines } else if (match(LHS, m_SDiv(m_ConstantInt(CI2), m_Value()))) { 2024dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // 'sdiv CI2, x' produces [-|CI2|, |CI2|]. 2025dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Upper = CI2->getValue().abs() + 1; 2026dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Lower = (-Upper) + 1; 20273a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_SDiv(m_Value(), m_ConstantInt(CI2)))) { 20283a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'sdiv x, CI2' produces [INT_MIN / CI2, INT_MAX / CI2]. 20293a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt IntMin = APInt::getSignedMinValue(Width); 20303a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt IntMax = APInt::getSignedMaxValue(Width); 20313a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt Val = CI2->getValue().abs(); 20323a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (!Val.isMinValue()) { 20333a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Lower = IntMin.sdiv(Val); 20343a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = IntMax.sdiv(Val) + 1; 20353a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } 20363a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_LShr(m_Value(), m_ConstantInt(CI2)))) { 20373a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'lshr x, CI2' produces [0, UINT_MAX >> CI2]. 20383a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt NegOne = APInt::getAllOnesValue(Width); 20393a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (CI2->getValue().ult(Width)) 20403a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = NegOne.lshr(CI2->getValue()) + 1; 2041dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines } else if (match(LHS, m_LShr(m_ConstantInt(CI2), m_Value()))) { 2042dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // 'lshr CI2, x' produces [CI2 >> (Width-1), CI2]. 2043dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines unsigned ShiftAmount = Width - 1; 2044dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!CI2->isZero() && cast<BinaryOperator>(LHS)->isExact()) 2045dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines ShiftAmount = CI2->getValue().countTrailingZeros(); 2046dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Lower = CI2->getValue().lshr(ShiftAmount); 2047dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Upper = CI2->getValue() + 1; 20483a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_AShr(m_Value(), m_ConstantInt(CI2)))) { 20493a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'ashr x, CI2' produces [INT_MIN >> CI2, INT_MAX >> CI2]. 20503a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt IntMin = APInt::getSignedMinValue(Width); 20513a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt IntMax = APInt::getSignedMaxValue(Width); 20523a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (CI2->getValue().ult(Width)) { 20533a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Lower = IntMin.ashr(CI2->getValue()); 20543a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = IntMax.ashr(CI2->getValue()) + 1; 20553a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } 2056dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines } else if (match(LHS, m_AShr(m_ConstantInt(CI2), m_Value()))) { 2057dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines unsigned ShiftAmount = Width - 1; 2058dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!CI2->isZero() && cast<BinaryOperator>(LHS)->isExact()) 2059dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines ShiftAmount = CI2->getValue().countTrailingZeros(); 2060dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (CI2->isNegative()) { 2061dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // 'ashr CI2, x' produces [CI2, CI2 >> (Width-1)] 2062dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Lower = CI2->getValue(); 2063dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Upper = CI2->getValue().ashr(ShiftAmount) + 1; 2064dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines } else { 2065dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // 'ashr CI2, x' produces [CI2 >> (Width-1), CI2] 2066dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Lower = CI2->getValue().ashr(ShiftAmount); 2067dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Upper = CI2->getValue() + 1; 2068dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines } 20693a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_Or(m_Value(), m_ConstantInt(CI2)))) { 20703a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'or x, CI2' produces [CI2, UINT_MAX]. 20713a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Lower = CI2->getValue(); 20723a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_And(m_Value(), m_ConstantInt(CI2)))) { 20733a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'and x, CI2' produces [0, CI2]. 20743a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = CI2->getValue() + 1; 20753a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } 20763a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (Lower != Upper) { 20773a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky ConstantRange LHS_CR = ConstantRange(Lower, Upper); 20783a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (RHS_CR.contains(LHS_CR)) 20793a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky return ConstantInt::getTrue(RHS->getContext()); 20803a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (RHS_CR.inverse().contains(LHS_CR)) 20813a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky return ConstantInt::getFalse(RHS->getContext()); 2082210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 2083210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 20841ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands 20859d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Compare of cast, for example (zext X) != 0 -> X != 0 20869d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (isa<CastInst>(LHS) && (isa<Constant>(RHS) || isa<CastInst>(RHS))) { 20879d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Instruction *LI = cast<CastInst>(LHS); 20889d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Value *SrcOp = LI->getOperand(0); 2089db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *SrcTy = SrcOp->getType(); 2090db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *DstTy = LI->getType(); 20919d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 20929d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Turn icmp (ptrtoint x), (ptrtoint/constant) into a compare of the input 20939d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // if the integer type is the same size as the pointer type. 209436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (MaxRecurse && Q.DL && isa<PtrToIntInst>(LI) && 209536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Q.DL->getTypeSizeInBits(SrcTy) == DstTy->getPrimitiveSizeInBits()) { 20969d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Constant *RHSC = dyn_cast<Constant>(RHS)) { 20979d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Transfer the cast to the constant. 20989d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(Pred, SrcOp, 20999d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantExpr::getIntToPtr(RHSC, SrcTy), 21000aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse-1)) 21019d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 21029d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } else if (PtrToIntInst *RI = dyn_cast<PtrToIntInst>(RHS)) { 21039d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (RI->getOperand(0)->getType() == SrcTy) 21049d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Compare without the cast. 21059d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(Pred, SrcOp, RI->getOperand(0), 21060aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse-1)) 21079d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 21089d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 21099d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 21109d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 21119d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (isa<ZExtInst>(LHS)) { 21129d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Turn icmp (zext X), (zext Y) into a compare of X and Y if they have the 21139d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // same type. 21149d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (ZExtInst *RI = dyn_cast<ZExtInst>(RHS)) { 21159d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (MaxRecurse && SrcTy == RI->getOperand(0)->getType()) 21169d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Compare X and Y. Note that signed predicates become unsigned. 21179d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(ICmpInst::getUnsignedPredicate(Pred), 21180aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands SrcOp, RI->getOperand(0), Q, 21199d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands MaxRecurse-1)) 21209d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 21219d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 21229d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Turn icmp (zext X), Cst into a compare of X and Cst if Cst is extended 21239d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // too. If not, then try to deduce the result of the comparison. 21249d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands else if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) { 21259d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Compute the constant that would happen if we truncated to SrcTy then 21269d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // reextended to DstTy. 21279d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant *Trunc = ConstantExpr::getTrunc(CI, SrcTy); 21289d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant *RExt = ConstantExpr::getCast(CastInst::ZExt, Trunc, DstTy); 21299d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 21309d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // If the re-extended constant didn't change then this is effectively 21319d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // also a case of comparing two zero-extended values. 21329d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (RExt == CI && MaxRecurse) 21339d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(ICmpInst::getUnsignedPredicate(Pred), 21340aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands SrcOp, Trunc, Q, MaxRecurse-1)) 21359d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 21369d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 21379d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Otherwise the upper bits of LHS are zero while RHS has a non-zero bit 21389d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // there. Use this to work out the result of the comparison. 21399d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (RExt != CI) { 21409d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands switch (Pred) { 2141858143816d43e58b17bfd11cb1b57afbd7f0f893Craig Topper default: llvm_unreachable("Unknown ICmp predicate!"); 21429d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // LHS <u RHS. 21439d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_EQ: 21449d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_UGT: 21459d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_UGE: 21469d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return ConstantInt::getFalse(CI->getContext()); 21479d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 21489d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_NE: 21499d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_ULT: 21509d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_ULE: 21519d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return ConstantInt::getTrue(CI->getContext()); 21529d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 21539d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // LHS is non-negative. If RHS is negative then LHS >s LHS. If RHS 21549d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // is non-negative then LHS <s RHS. 21559d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SGT: 21569d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SGE: 21579d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return CI->getValue().isNegative() ? 21589d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getTrue(CI->getContext()) : 21599d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getFalse(CI->getContext()); 21609d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 21619d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SLT: 21629d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SLE: 21639d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return CI->getValue().isNegative() ? 21649d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getFalse(CI->getContext()) : 21659d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getTrue(CI->getContext()); 21669d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 21679d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 21689d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 21699d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 21709d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 21719d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (isa<SExtInst>(LHS)) { 21729d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Turn icmp (sext X), (sext Y) into a compare of X and Y if they have the 21739d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // same type. 21749d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (SExtInst *RI = dyn_cast<SExtInst>(RHS)) { 21759d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (MaxRecurse && SrcTy == RI->getOperand(0)->getType()) 21769d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Compare X and Y. Note that the predicate does not change. 21779d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(Pred, SrcOp, RI->getOperand(0), 21780aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse-1)) 21799d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 21809d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 21819d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Turn icmp (sext X), Cst into a compare of X and Cst if Cst is extended 21829d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // too. If not, then try to deduce the result of the comparison. 21839d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands else if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) { 21849d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Compute the constant that would happen if we truncated to SrcTy then 21859d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // reextended to DstTy. 21869d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant *Trunc = ConstantExpr::getTrunc(CI, SrcTy); 21879d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant *RExt = ConstantExpr::getCast(CastInst::SExt, Trunc, DstTy); 21889d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 21899d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // If the re-extended constant didn't change then this is effectively 21909d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // also a case of comparing two sign-extended values. 21919d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (RExt == CI && MaxRecurse) 21920aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyICmpInst(Pred, SrcOp, Trunc, Q, MaxRecurse-1)) 21939d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 21949d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 21959d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Otherwise the upper bits of LHS are all equal, while RHS has varying 21969d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // bits there. Use this to work out the result of the comparison. 21979d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (RExt != CI) { 21989d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands switch (Pred) { 2199858143816d43e58b17bfd11cb1b57afbd7f0f893Craig Topper default: llvm_unreachable("Unknown ICmp predicate!"); 22009d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_EQ: 22019d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return ConstantInt::getFalse(CI->getContext()); 22029d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_NE: 22039d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return ConstantInt::getTrue(CI->getContext()); 22049d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 22059d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // If RHS is non-negative then LHS <s RHS. If RHS is negative then 22069d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // LHS >s RHS. 22079d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SGT: 22089d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SGE: 22099d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return CI->getValue().isNegative() ? 22109d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getTrue(CI->getContext()) : 22119d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getFalse(CI->getContext()); 22129d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SLT: 22139d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SLE: 22149d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return CI->getValue().isNegative() ? 22159d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getFalse(CI->getContext()) : 22169d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getTrue(CI->getContext()); 22179d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 22189d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // If LHS is non-negative then LHS <u RHS. If LHS is negative then 22199d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // LHS >u RHS. 22209d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_UGT: 22219d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_UGE: 222294c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // Comparison is true iff the LHS <s 0. 22239d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (MaxRecurse) 22249d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(ICmpInst::ICMP_SLT, SrcOp, 22259d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant::getNullValue(SrcTy), 22260aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse-1)) 22279d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 22289d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands break; 22299d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_ULT: 22309d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_ULE: 223194c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // Comparison is true iff the LHS >=s 0. 22329d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (MaxRecurse) 22339d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(ICmpInst::ICMP_SGE, SrcOp, 22349d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant::getNullValue(SrcTy), 22350aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse-1)) 22369d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 22379d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands break; 22389d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 22399d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 22409d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 22419d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 22429d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 22439d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 224452fb846578714d14bbde9b28884a6a8729217677Duncan Sands // Special logic for binary operators. 224552fb846578714d14bbde9b28884a6a8729217677Duncan Sands BinaryOperator *LBO = dyn_cast<BinaryOperator>(LHS); 224652fb846578714d14bbde9b28884a6a8729217677Duncan Sands BinaryOperator *RBO = dyn_cast<BinaryOperator>(RHS); 224752fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (MaxRecurse && (LBO || RBO)) { 224852fb846578714d14bbde9b28884a6a8729217677Duncan Sands // Analyze the case when either LHS or RHS is an add instruction. 2249dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Value *A = nullptr, *B = nullptr, *C = nullptr, *D = nullptr; 225052fb846578714d14bbde9b28884a6a8729217677Duncan Sands // LHS = A + B (or A and B are null); RHS = C + D (or C and D are null). 225152fb846578714d14bbde9b28884a6a8729217677Duncan Sands bool NoLHSWrapProblem = false, NoRHSWrapProblem = false; 225252fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (LBO && LBO->getOpcode() == Instruction::Add) { 225352fb846578714d14bbde9b28884a6a8729217677Duncan Sands A = LBO->getOperand(0); B = LBO->getOperand(1); 225452fb846578714d14bbde9b28884a6a8729217677Duncan Sands NoLHSWrapProblem = ICmpInst::isEquality(Pred) || 225552fb846578714d14bbde9b28884a6a8729217677Duncan Sands (CmpInst::isUnsigned(Pred) && LBO->hasNoUnsignedWrap()) || 225652fb846578714d14bbde9b28884a6a8729217677Duncan Sands (CmpInst::isSigned(Pred) && LBO->hasNoSignedWrap()); 225752fb846578714d14bbde9b28884a6a8729217677Duncan Sands } 225852fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (RBO && RBO->getOpcode() == Instruction::Add) { 225952fb846578714d14bbde9b28884a6a8729217677Duncan Sands C = RBO->getOperand(0); D = RBO->getOperand(1); 226052fb846578714d14bbde9b28884a6a8729217677Duncan Sands NoRHSWrapProblem = ICmpInst::isEquality(Pred) || 226152fb846578714d14bbde9b28884a6a8729217677Duncan Sands (CmpInst::isUnsigned(Pred) && RBO->hasNoUnsignedWrap()) || 226252fb846578714d14bbde9b28884a6a8729217677Duncan Sands (CmpInst::isSigned(Pred) && RBO->hasNoSignedWrap()); 226352fb846578714d14bbde9b28884a6a8729217677Duncan Sands } 226452fb846578714d14bbde9b28884a6a8729217677Duncan Sands 226552fb846578714d14bbde9b28884a6a8729217677Duncan Sands // icmp (X+Y), X -> icmp Y, 0 for equalities or if there is no overflow. 226652fb846578714d14bbde9b28884a6a8729217677Duncan Sands if ((A == RHS || B == RHS) && NoLHSWrapProblem) 226752fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (Value *V = SimplifyICmpInst(Pred, A == RHS ? B : A, 226852fb846578714d14bbde9b28884a6a8729217677Duncan Sands Constant::getNullValue(RHS->getType()), 22690aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse-1)) 227052fb846578714d14bbde9b28884a6a8729217677Duncan Sands return V; 227152fb846578714d14bbde9b28884a6a8729217677Duncan Sands 227252fb846578714d14bbde9b28884a6a8729217677Duncan Sands // icmp X, (X+Y) -> icmp 0, Y for equalities or if there is no overflow. 227352fb846578714d14bbde9b28884a6a8729217677Duncan Sands if ((C == LHS || D == LHS) && NoRHSWrapProblem) 227452fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (Value *V = SimplifyICmpInst(Pred, 227552fb846578714d14bbde9b28884a6a8729217677Duncan Sands Constant::getNullValue(LHS->getType()), 22760aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands C == LHS ? D : C, Q, MaxRecurse-1)) 227752fb846578714d14bbde9b28884a6a8729217677Duncan Sands return V; 227852fb846578714d14bbde9b28884a6a8729217677Duncan Sands 227952fb846578714d14bbde9b28884a6a8729217677Duncan Sands // icmp (X+Y), (X+Z) -> icmp Y,Z for equalities or if there is no overflow. 228052fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (A && C && (A == C || A == D || B == C || B == D) && 228152fb846578714d14bbde9b28884a6a8729217677Duncan Sands NoLHSWrapProblem && NoRHSWrapProblem) { 228252fb846578714d14bbde9b28884a6a8729217677Duncan Sands // Determine Y and Z in the form icmp (X+Y), (X+Z). 2283aceb03eb58778ae4a2811d2c2bbd23e0e0cf49b5Duncan Sands Value *Y, *Z; 2284aceb03eb58778ae4a2811d2c2bbd23e0e0cf49b5Duncan Sands if (A == C) { 22854f0dfbb454ea8110459e2d1ee5f92e74cb3e8a5cDuncan Sands // C + B == C + D -> B == D 2286aceb03eb58778ae4a2811d2c2bbd23e0e0cf49b5Duncan Sands Y = B; 2287aceb03eb58778ae4a2811d2c2bbd23e0e0cf49b5Duncan Sands Z = D; 2288aceb03eb58778ae4a2811d2c2bbd23e0e0cf49b5Duncan Sands } else if (A == D) { 22894f0dfbb454ea8110459e2d1ee5f92e74cb3e8a5cDuncan Sands // D + B == C + D -> B == C 2290aceb03eb58778ae4a2811d2c2bbd23e0e0cf49b5Duncan Sands Y = B; 2291aceb03eb58778ae4a2811d2c2bbd23e0e0cf49b5Duncan Sands Z = C; 2292aceb03eb58778ae4a2811d2c2bbd23e0e0cf49b5Duncan Sands } else if (B == C) { 22934f0dfbb454ea8110459e2d1ee5f92e74cb3e8a5cDuncan Sands // A + C == C + D -> A == D 2294aceb03eb58778ae4a2811d2c2bbd23e0e0cf49b5Duncan Sands Y = A; 2295aceb03eb58778ae4a2811d2c2bbd23e0e0cf49b5Duncan Sands Z = D; 22964f0dfbb454ea8110459e2d1ee5f92e74cb3e8a5cDuncan Sands } else { 22974f0dfbb454ea8110459e2d1ee5f92e74cb3e8a5cDuncan Sands assert(B == D); 22984f0dfbb454ea8110459e2d1ee5f92e74cb3e8a5cDuncan Sands // A + D == C + D -> A == C 2299aceb03eb58778ae4a2811d2c2bbd23e0e0cf49b5Duncan Sands Y = A; 2300aceb03eb58778ae4a2811d2c2bbd23e0e0cf49b5Duncan Sands Z = C; 2301aceb03eb58778ae4a2811d2c2bbd23e0e0cf49b5Duncan Sands } 23020aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyICmpInst(Pred, Y, Z, Q, MaxRecurse-1)) 230352fb846578714d14bbde9b28884a6a8729217677Duncan Sands return V; 230452fb846578714d14bbde9b28884a6a8729217677Duncan Sands } 230552fb846578714d14bbde9b28884a6a8729217677Duncan Sands } 230652fb846578714d14bbde9b28884a6a8729217677Duncan Sands 2307dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // 0 - (zext X) pred C 2308dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!CmpInst::isUnsigned(Pred) && match(LHS, m_Neg(m_ZExt(m_Value())))) { 2309dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (ConstantInt *RHSC = dyn_cast<ConstantInt>(RHS)) { 2310dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (RHSC->getValue().isStrictlyPositive()) { 2311dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (Pred == ICmpInst::ICMP_SLT) 2312dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return ConstantInt::getTrue(RHSC->getContext()); 2313dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (Pred == ICmpInst::ICMP_SGE) 2314dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return ConstantInt::getFalse(RHSC->getContext()); 2315dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (Pred == ICmpInst::ICMP_EQ) 2316dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return ConstantInt::getFalse(RHSC->getContext()); 2317dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (Pred == ICmpInst::ICMP_NE) 2318dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return ConstantInt::getTrue(RHSC->getContext()); 2319dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines } 2320dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (RHSC->getValue().isNonNegative()) { 2321dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (Pred == ICmpInst::ICMP_SLE) 2322dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return ConstantInt::getTrue(RHSC->getContext()); 2323dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (Pred == ICmpInst::ICMP_SGT) 2324dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return ConstantInt::getFalse(RHSC->getContext()); 2325dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines } 2326dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines } 2327dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines } 2328dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 23298a23270ce60fdd5dafa1c8dfbf9f46c8efe244b7Nick Lewycky // icmp pred (urem X, Y), Y 233084dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky if (LBO && match(LBO, m_URem(m_Value(), m_Specific(RHS)))) { 2331786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky bool KnownNonNegative, KnownNegative; 233288cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky switch (Pred) { 233388cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky default: 233488cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky break; 2335786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky case ICmpInst::ICMP_SGT: 2336786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky case ICmpInst::ICMP_SGE: 233736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines ComputeSignBit(RHS, KnownNonNegative, KnownNegative, Q.DL); 2338786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky if (!KnownNonNegative) 2339786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky break; 2340786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky // fall-through 234188cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky case ICmpInst::ICMP_EQ: 234288cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky case ICmpInst::ICMP_UGT: 234388cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky case ICmpInst::ICMP_UGE: 2344f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 2345786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky case ICmpInst::ICMP_SLT: 2346786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky case ICmpInst::ICMP_SLE: 234736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines ComputeSignBit(RHS, KnownNonNegative, KnownNegative, Q.DL); 2348786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky if (!KnownNonNegative) 2349786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky break; 2350786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky // fall-through 235188cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky case ICmpInst::ICMP_NE: 235288cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky case ICmpInst::ICMP_ULT: 235388cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky case ICmpInst::ICMP_ULE: 2354f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 235588cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky } 235688cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky } 23578a23270ce60fdd5dafa1c8dfbf9f46c8efe244b7Nick Lewycky 23588a23270ce60fdd5dafa1c8dfbf9f46c8efe244b7Nick Lewycky // icmp pred X, (urem Y, X) 235984dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky if (RBO && match(RBO, m_URem(m_Value(), m_Specific(LHS)))) { 236084dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky bool KnownNonNegative, KnownNegative; 236184dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky switch (Pred) { 236284dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky default: 236384dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky break; 236484dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_SGT: 236584dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_SGE: 236636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines ComputeSignBit(LHS, KnownNonNegative, KnownNegative, Q.DL); 236784dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky if (!KnownNonNegative) 236884dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky break; 236984dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky // fall-through 2370a0e2f38b25ce7c51c22ed40d8a315fe1dd98926dNick Lewycky case ICmpInst::ICMP_NE: 237184dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_UGT: 237284dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_UGE: 2373f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 237484dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_SLT: 237584dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_SLE: 237636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines ComputeSignBit(LHS, KnownNonNegative, KnownNegative, Q.DL); 237784dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky if (!KnownNonNegative) 237884dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky break; 237984dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky // fall-through 2380a0e2f38b25ce7c51c22ed40d8a315fe1dd98926dNick Lewycky case ICmpInst::ICMP_EQ: 238184dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_ULT: 238284dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_ULE: 2383f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 238484dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky } 238584dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky } 238688cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky 2387c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands // x udiv y <=u x. 2388c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands if (LBO && match(LBO, m_UDiv(m_Specific(RHS), m_Value()))) { 2389c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands // icmp pred (X /u Y), X 2390c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands if (Pred == ICmpInst::ICMP_UGT) 2391c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands return getFalse(ITy); 2392c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands if (Pred == ICmpInst::ICMP_ULE) 2393c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands return getTrue(ITy); 2394c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands } 2395c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands 239658bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (MaxRecurse && LBO && RBO && LBO->getOpcode() == RBO->getOpcode() && 239758bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky LBO->getOperand(1) == RBO->getOperand(1)) { 239858bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky switch (LBO->getOpcode()) { 239958bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky default: break; 240058bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::UDiv: 240158bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::LShr: 240258bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (ICmpInst::isSigned(Pred)) 240358bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 240458bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky // fall-through 240558bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::SDiv: 240658bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::AShr: 2407b6e7cd655c6ee119dbeacc321ee92387f983edb0Eli Friedman if (!LBO->isExact() || !RBO->isExact()) 240858bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 240958bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (Value *V = SimplifyICmpInst(Pred, LBO->getOperand(0), 24100aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands RBO->getOperand(0), Q, MaxRecurse-1)) 241158bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky return V; 241258bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 241358bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::Shl: { 2414c9d904ee2ca36ab6238ed93c7ad2ea67b5fd0a23Duncan Sands bool NUW = LBO->hasNoUnsignedWrap() && RBO->hasNoUnsignedWrap(); 241558bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky bool NSW = LBO->hasNoSignedWrap() && RBO->hasNoSignedWrap(); 241658bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (!NUW && !NSW) 241758bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 241858bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (!NSW && ICmpInst::isSigned(Pred)) 241958bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 242058bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (Value *V = SimplifyICmpInst(Pred, LBO->getOperand(0), 24210aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands RBO->getOperand(0), Q, MaxRecurse-1)) 242258bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky return V; 242358bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 242458bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky } 242558bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky } 242658bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky } 242758bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky 2428ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Simplify comparisons involving max/min. 2429ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands Value *A, *B; 2430ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands CmpInst::Predicate P = CmpInst::BAD_ICMP_PREDICATE; 243194c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru CmpInst::Predicate EqP; // Chosen so that "A == max/min(A,B)" iff "A EqP B". 2432ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands 24338140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Signed variants on "max(a,b)>=a -> true". 2434ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (match(LHS, m_SMax(m_Value(A), m_Value(B))) && (A == RHS || B == RHS)) { 2435ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != RHS) std::swap(A, B); // smax(A, B) pred A. 243694c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru EqP = CmpInst::ICMP_SGE; // "A == smax(A, B)" iff "A sge B". 2437ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as smax(A, B) pred A. 2438ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = Pred; 2439ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } else if (match(RHS, m_SMax(m_Value(A), m_Value(B))) && 2440ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands (A == LHS || B == LHS)) { 2441ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != LHS) std::swap(A, B); // A pred smax(A, B). 244294c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru EqP = CmpInst::ICMP_SGE; // "A == smax(A, B)" iff "A sge B". 2443ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as smax(A, B) swapped-pred A. 2444ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = CmpInst::getSwappedPredicate(Pred); 2445ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } else if (match(LHS, m_SMin(m_Value(A), m_Value(B))) && 2446ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands (A == RHS || B == RHS)) { 2447ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != RHS) std::swap(A, B); // smin(A, B) pred A. 244894c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru EqP = CmpInst::ICMP_SLE; // "A == smin(A, B)" iff "A sle B". 2449ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as smax(-A, -B) swapped-pred -A. 2450ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Note that we do not need to actually form -A or -B thanks to EqP. 2451ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = CmpInst::getSwappedPredicate(Pred); 2452ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } else if (match(RHS, m_SMin(m_Value(A), m_Value(B))) && 2453ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands (A == LHS || B == LHS)) { 2454ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != LHS) std::swap(A, B); // A pred smin(A, B). 245594c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru EqP = CmpInst::ICMP_SLE; // "A == smin(A, B)" iff "A sle B". 2456ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as smax(-A, -B) pred -A. 2457ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Note that we do not need to actually form -A or -B thanks to EqP. 2458ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = Pred; 2459ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } 2460ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (P != CmpInst::BAD_ICMP_PREDICATE) { 2461ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Cases correspond to "max(A, B) p A". 2462ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands switch (P) { 2463ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands default: 2464ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands break; 2465ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_EQ: 2466ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_SLE: 2467e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Equivalent to "A EqP B". This may be the same as the condition tested 2468e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // in the max/min; if so, we can just return that. 2469e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(LHS, EqP, A, B)) 2470e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2471e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(RHS, EqP, A, B)) 2472e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2473e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Otherwise, see if "A EqP B" simplifies. 2474ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (MaxRecurse) 24750aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyICmpInst(EqP, A, B, Q, MaxRecurse-1)) 2476ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands return V; 2477ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands break; 2478ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_NE: 2479e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands case CmpInst::ICMP_SGT: { 2480e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands CmpInst::Predicate InvEqP = CmpInst::getInversePredicate(EqP); 2481e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Equivalent to "A InvEqP B". This may be the same as the condition 2482e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // tested in the max/min; if so, we can just return that. 2483e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(LHS, InvEqP, A, B)) 2484e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2485e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(RHS, InvEqP, A, B)) 2486e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2487e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Otherwise, see if "A InvEqP B" simplifies. 2488ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (MaxRecurse) 24890aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyICmpInst(InvEqP, A, B, Q, MaxRecurse-1)) 2490ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands return V; 2491ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands break; 2492e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands } 2493ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_SGE: 2494ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Always true. 2495f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 2496ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_SLT: 2497ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Always false. 2498f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 2499ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } 2500ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } 2501ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands 25028140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Unsigned variants on "max(a,b)>=a -> true". 2503ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = CmpInst::BAD_ICMP_PREDICATE; 2504ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (match(LHS, m_UMax(m_Value(A), m_Value(B))) && (A == RHS || B == RHS)) { 2505ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != RHS) std::swap(A, B); // umax(A, B) pred A. 250694c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru EqP = CmpInst::ICMP_UGE; // "A == umax(A, B)" iff "A uge B". 2507ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as umax(A, B) pred A. 2508ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = Pred; 2509ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } else if (match(RHS, m_UMax(m_Value(A), m_Value(B))) && 2510ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands (A == LHS || B == LHS)) { 2511ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != LHS) std::swap(A, B); // A pred umax(A, B). 251294c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru EqP = CmpInst::ICMP_UGE; // "A == umax(A, B)" iff "A uge B". 2513ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as umax(A, B) swapped-pred A. 2514ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = CmpInst::getSwappedPredicate(Pred); 2515ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } else if (match(LHS, m_UMin(m_Value(A), m_Value(B))) && 2516ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands (A == RHS || B == RHS)) { 2517ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != RHS) std::swap(A, B); // umin(A, B) pred A. 251894c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru EqP = CmpInst::ICMP_ULE; // "A == umin(A, B)" iff "A ule B". 2519ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as umax(-A, -B) swapped-pred -A. 2520ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Note that we do not need to actually form -A or -B thanks to EqP. 2521ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = CmpInst::getSwappedPredicate(Pred); 2522ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } else if (match(RHS, m_UMin(m_Value(A), m_Value(B))) && 2523ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands (A == LHS || B == LHS)) { 2524ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != LHS) std::swap(A, B); // A pred umin(A, B). 252594c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru EqP = CmpInst::ICMP_ULE; // "A == umin(A, B)" iff "A ule B". 2526ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as umax(-A, -B) pred -A. 2527ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Note that we do not need to actually form -A or -B thanks to EqP. 2528ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = Pred; 2529ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } 2530ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (P != CmpInst::BAD_ICMP_PREDICATE) { 2531ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Cases correspond to "max(A, B) p A". 2532ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands switch (P) { 2533ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands default: 2534ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands break; 2535ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_EQ: 2536ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_ULE: 2537e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Equivalent to "A EqP B". This may be the same as the condition tested 2538e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // in the max/min; if so, we can just return that. 2539e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(LHS, EqP, A, B)) 2540e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2541e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(RHS, EqP, A, B)) 2542e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2543e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Otherwise, see if "A EqP B" simplifies. 2544ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (MaxRecurse) 25450aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyICmpInst(EqP, A, B, Q, MaxRecurse-1)) 2546ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands return V; 2547ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands break; 2548ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_NE: 2549e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands case CmpInst::ICMP_UGT: { 2550e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands CmpInst::Predicate InvEqP = CmpInst::getInversePredicate(EqP); 2551e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Equivalent to "A InvEqP B". This may be the same as the condition 2552e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // tested in the max/min; if so, we can just return that. 2553e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(LHS, InvEqP, A, B)) 2554e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2555e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(RHS, InvEqP, A, B)) 2556e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2557e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Otherwise, see if "A InvEqP B" simplifies. 2558ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (MaxRecurse) 25590aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyICmpInst(InvEqP, A, B, Q, MaxRecurse-1)) 2560ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands return V; 2561ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands break; 2562e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands } 2563ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_UGE: 2564ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Always true. 2565f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 2566ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_ULT: 2567ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Always false. 2568f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 2569ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } 2570ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } 2571ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands 25728140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Variants on "max(x,y) >= min(x,z)". 25738140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands Value *C, *D; 25748140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (match(LHS, m_SMax(m_Value(A), m_Value(B))) && 25758140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands match(RHS, m_SMin(m_Value(C), m_Value(D))) && 25768140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands (A == C || A == D || B == C || B == D)) { 25778140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // max(x, ?) pred min(x, ?). 25788140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_SGE) 25798140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always true. 2580f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 25818140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_SLT) 25828140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always false. 2583f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 25848140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands } else if (match(LHS, m_SMin(m_Value(A), m_Value(B))) && 25858140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands match(RHS, m_SMax(m_Value(C), m_Value(D))) && 25868140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands (A == C || A == D || B == C || B == D)) { 25878140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // min(x, ?) pred max(x, ?). 25888140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_SLE) 25898140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always true. 2590f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 25918140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_SGT) 25928140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always false. 2593f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 25948140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands } else if (match(LHS, m_UMax(m_Value(A), m_Value(B))) && 25958140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands match(RHS, m_UMin(m_Value(C), m_Value(D))) && 25968140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands (A == C || A == D || B == C || B == D)) { 25978140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // max(x, ?) pred min(x, ?). 25988140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_UGE) 25998140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always true. 2600f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 26018140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_ULT) 26028140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always false. 2603f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 26048140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands } else if (match(LHS, m_UMin(m_Value(A), m_Value(B))) && 26058140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands match(RHS, m_UMax(m_Value(C), m_Value(D))) && 26068140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands (A == C || A == D || B == C || B == D)) { 26078140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // min(x, ?) pred max(x, ?). 26088140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_ULE) 26098140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always true. 2610f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 26118140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_UGT) 26128140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always false. 2613f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 26148140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands } 26158140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands 261658725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth // Simplify comparisons of related pointers using a powerful, recursive 261758725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth // GEP-walk when we have target data available.. 26183e3de565e9c7258fb97773b3a64fc091355cb2deDan Gohman if (LHS->getType()->isPointerTy()) 261936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (Constant *C = computePointerICmp(Q.DL, Q.TLI, Pred, LHS, RHS)) 262058725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth return C; 262158725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth 2622f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky if (GetElementPtrInst *GLHS = dyn_cast<GetElementPtrInst>(LHS)) { 2623f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky if (GEPOperator *GRHS = dyn_cast<GEPOperator>(RHS)) { 2624f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky if (GLHS->getPointerOperand() == GRHS->getPointerOperand() && 2625f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky GLHS->hasAllConstantIndices() && GRHS->hasAllConstantIndices() && 2626f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky (ICmpInst::isEquality(Pred) || 2627f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky (GLHS->isInBounds() && GRHS->isInBounds() && 2628f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky Pred == ICmpInst::getSignedPredicate(Pred)))) { 2629f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky // The bases are equal and the indices are constant. Build a constant 2630f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky // expression GEP with the same indices and a null base pointer to see 2631f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky // what constant folding can make out of it. 2632f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky Constant *Null = Constant::getNullValue(GLHS->getPointerOperandType()); 2633f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky SmallVector<Value *, 4> IndicesLHS(GLHS->idx_begin(), GLHS->idx_end()); 2634f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky Constant *NewLHS = ConstantExpr::getGetElementPtr(Null, IndicesLHS); 2635f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky 2636f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky SmallVector<Value *, 4> IndicesRHS(GRHS->idx_begin(), GRHS->idx_end()); 2637f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky Constant *NewRHS = ConstantExpr::getGetElementPtr(Null, IndicesRHS); 2638f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky return ConstantExpr::getICmp(Pred, NewLHS, NewRHS); 2639f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky } 2640f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky } 2641f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky } 2642f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky 26431ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands // If the comparison is with the result of a select instruction, check whether 26441ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands // comparing with either branch of the select always yields the same value. 26450312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<SelectInst>(LHS) || isa<SelectInst>(RHS)) 26460aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadCmpOverSelect(Pred, LHS, RHS, Q, MaxRecurse)) 2647a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return V; 2648a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 2649a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the comparison is with the result of a phi instruction, check whether 2650a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // doing the compare with each incoming phi value yields a common result. 26510312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<PHINode>(LHS) || isa<PHINode>(RHS)) 26520aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadCmpOverPHI(Pred, LHS, RHS, Q, MaxRecurse)) 26533bbb0cc42b67b4bf2c488285666999963bab0f7eDuncan Sands return V; 26541ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands 2655dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 26569dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner} 26579dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 2658a74a58c83be492b7d5b7383656f049909394cff4Duncan SandsValue *llvm::SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS, 265936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const DataLayout *DL, 2660618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 2661618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT) { 266236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return ::SimplifyICmpInst(Predicate, LHS, RHS, Query (DL, TLI, DT), 26630aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands RecursionLimit); 2664a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 2665a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 26669dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// SimplifyFCmpInst - Given operands for an FCmpInst, see if we can 26679dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// fold the result. If not, this returns null. 2668a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *SimplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS, 26690aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 26709dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner CmpInst::Predicate Pred = (CmpInst::Predicate)Predicate; 26719dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner assert(CmpInst::isFPPredicate(Pred) && "Not an FP compare!"); 26729dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 2673d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(LHS)) { 26749dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner if (Constant *CRHS = dyn_cast<Constant>(RHS)) 267536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return ConstantFoldCompareInstOperands(Pred, CLHS, CRHS, Q.DL, Q.TLI); 267612a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2677d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // If we have a constant, make sure it is on the RHS. 2678d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner std::swap(LHS, RHS); 2679d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Pred = CmpInst::getSwappedPredicate(Pred); 2680d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 268112a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2682210c5d4880b525e064088b6fec713260128c16ebChris Lattner // Fold trivial predicates. 2683210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (Pred == FCmpInst::FCMP_FALSE) 2684210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(GetCompareTy(LHS), 0); 2685210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (Pred == FCmpInst::FCMP_TRUE) 2686210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(GetCompareTy(LHS), 1); 2687210c5d4880b525e064088b6fec713260128c16ebChris Lattner 2688210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (isa<UndefValue>(RHS)) // fcmp pred X, undef -> undef 2689210c5d4880b525e064088b6fec713260128c16ebChris Lattner return UndefValue::get(GetCompareTy(LHS)); 2690210c5d4880b525e064088b6fec713260128c16ebChris Lattner 2691210c5d4880b525e064088b6fec713260128c16ebChris Lattner // fcmp x,x -> true/false. Not all compares are foldable. 2692124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (LHS == RHS) { 2693210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (CmpInst::isTrueWhenEqual(Pred)) 2694210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(GetCompareTy(LHS), 1); 2695210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (CmpInst::isFalseWhenEqual(Pred)) 2696210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(GetCompareTy(LHS), 0); 2697210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 269812a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2699210c5d4880b525e064088b6fec713260128c16ebChris Lattner // Handle fcmp with constant RHS 2700210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (Constant *RHSC = dyn_cast<Constant>(RHS)) { 2701210c5d4880b525e064088b6fec713260128c16ebChris Lattner // If the constant is a nan, see if we can fold the comparison based on it. 2702210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (ConstantFP *CFP = dyn_cast<ConstantFP>(RHSC)) { 2703210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (CFP->getValueAPF().isNaN()) { 2704210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (FCmpInst::isOrdered(Pred)) // True "if ordered and foo" 2705210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::getFalse(CFP->getContext()); 2706210c5d4880b525e064088b6fec713260128c16ebChris Lattner assert(FCmpInst::isUnordered(Pred) && 2707210c5d4880b525e064088b6fec713260128c16ebChris Lattner "Comparison must be either ordered or unordered!"); 2708210c5d4880b525e064088b6fec713260128c16ebChris Lattner // True if unordered. 2709210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::getTrue(CFP->getContext()); 2710210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 27116b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // Check whether the constant is an infinity. 27126b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman if (CFP->getValueAPF().isInfinity()) { 27136b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman if (CFP->getValueAPF().isNegative()) { 27146b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman switch (Pred) { 27156b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman case FCmpInst::FCMP_OLT: 27166b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // No value is ordered and less than negative infinity. 27176b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman return ConstantInt::getFalse(CFP->getContext()); 27186b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman case FCmpInst::FCMP_UGE: 27196b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // All values are unordered with or at least negative infinity. 27206b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman return ConstantInt::getTrue(CFP->getContext()); 27216b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman default: 27226b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman break; 27236b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } 27246b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } else { 27256b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman switch (Pred) { 27266b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman case FCmpInst::FCMP_OGT: 27276b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // No value is ordered and greater than infinity. 27286b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman return ConstantInt::getFalse(CFP->getContext()); 27296b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman case FCmpInst::FCMP_ULE: 27306b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // All values are unordered with and at most infinity. 27316b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman return ConstantInt::getTrue(CFP->getContext()); 27326b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman default: 27336b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman break; 27346b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } 27356b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } 27366b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } 2737210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 2738210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 273912a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 274092826def593df7a422c7b07f09342febce81ddd3Duncan Sands // If the comparison is with the result of a select instruction, check whether 274192826def593df7a422c7b07f09342febce81ddd3Duncan Sands // comparing with either branch of the select always yields the same value. 27420312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<SelectInst>(LHS) || isa<SelectInst>(RHS)) 27430aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadCmpOverSelect(Pred, LHS, RHS, Q, MaxRecurse)) 2744a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return V; 2745a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 2746a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the comparison is with the result of a phi instruction, check whether 2747a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // doing the compare with each incoming phi value yields a common result. 27480312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<PHINode>(LHS) || isa<PHINode>(RHS)) 27490aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadCmpOverPHI(Pred, LHS, RHS, Q, MaxRecurse)) 27503bbb0cc42b67b4bf2c488285666999963bab0f7eDuncan Sands return V; 275192826def593df7a422c7b07f09342febce81ddd3Duncan Sands 2752dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 27539f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner} 27549f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 2755a74a58c83be492b7d5b7383656f049909394cff4Duncan SandsValue *llvm::SimplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS, 275636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const DataLayout *DL, 2757618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 2758618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT) { 275936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return ::SimplifyFCmpInst(Predicate, LHS, RHS, Query (DL, TLI, DT), 27600aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands RecursionLimit); 2761a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 2762a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 2763047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner/// SimplifySelectInst - Given operands for a SelectInst, see if we can fold 2764047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner/// the result. If not, this returns null. 27650aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifySelectInst(Value *CondVal, Value *TrueVal, 27660aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Value *FalseVal, const Query &Q, 27670aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands unsigned MaxRecurse) { 2768047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner // select true, X, Y -> X 2769047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner // select false, X, Y -> Y 277036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (Constant *CB = dyn_cast<Constant>(CondVal)) { 277136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (CB->isAllOnesValue()) 277236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return TrueVal; 277336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (CB->isNullValue()) 277436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return FalseVal; 277536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } 277612a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2777047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner // select C, X, X -> X 2778124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (TrueVal == FalseVal) 2779047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return TrueVal; 278012a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2781047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner if (isa<UndefValue>(CondVal)) { // select undef, X, Y -> X or Y 2782047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner if (isa<Constant>(TrueVal)) 2783047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return TrueVal; 2784047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return FalseVal; 2785047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner } 278668c0dbc14fb7599987fb3e27be4e12c1ac36535eDan Gohman if (isa<UndefValue>(TrueVal)) // select C, undef, X -> X 278768c0dbc14fb7599987fb3e27be4e12c1ac36535eDan Gohman return FalseVal; 278868c0dbc14fb7599987fb3e27be4e12c1ac36535eDan Gohman if (isa<UndefValue>(FalseVal)) // select C, X, undef -> X 278968c0dbc14fb7599987fb3e27be4e12c1ac36535eDan Gohman return TrueVal; 279012a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2791dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 2792047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner} 2793047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner 27940aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan SandsValue *llvm::SimplifySelectInst(Value *Cond, Value *TrueVal, Value *FalseVal, 279536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const DataLayout *DL, 27960aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const TargetLibraryInfo *TLI, 27970aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const DominatorTree *DT) { 279836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return ::SimplifySelectInst(Cond, TrueVal, FalseVal, Query (DL, TLI, DT), 27990aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands RecursionLimit); 28000aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands} 28010aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands 2802c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner/// SimplifyGEPInst - Given operands for an GetElementPtrInst, see if we can 2803c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner/// fold the result. If not, this returns null. 28040aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyGEPInst(ArrayRef<Value *> Ops, const Query &Q, unsigned) { 280585bbff6c94695f07cc1a9765b4d384ed18d2fd7cDuncan Sands // The type of the GEP pointer operand. 280636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines PointerType *PtrTy = cast<PointerType>(Ops[0]->getType()->getScalarType()); 280785bbff6c94695f07cc1a9765b4d384ed18d2fd7cDuncan Sands 2808c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner // getelementptr P -> P. 2809b9b54ebfed02f0654897d37e8a4448d3f8087558Jay Foad if (Ops.size() == 1) 2810c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner return Ops[0]; 2811c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner 281285bbff6c94695f07cc1a9765b4d384ed18d2fd7cDuncan Sands if (isa<UndefValue>(Ops[0])) { 281385bbff6c94695f07cc1a9765b4d384ed18d2fd7cDuncan Sands // Compute the (pointer) type returned by the GEP instruction. 2814a9203109f4ac95aa7e9624f2838e3d89623ec902Jay Foad Type *LastType = GetElementPtrInst::getIndexedType(PtrTy, Ops.slice(1)); 2815db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *GEPTy = PointerType::get(LastType, PtrTy->getAddressSpace()); 281636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (VectorType *VT = dyn_cast<VectorType>(Ops[0]->getType())) 281736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines GEPTy = VectorType::get(GEPTy, VT->getNumElements()); 281885bbff6c94695f07cc1a9765b4d384ed18d2fd7cDuncan Sands return UndefValue::get(GEPTy); 281985bbff6c94695f07cc1a9765b4d384ed18d2fd7cDuncan Sands } 2820c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner 2821b9b54ebfed02f0654897d37e8a4448d3f8087558Jay Foad if (Ops.size() == 2) { 2822e60d79faf7ef7bc4847f9e5d067af00b98dced7bDuncan Sands // getelementptr P, 0 -> P. 282336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (match(Ops[1], m_Zero())) 282436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return Ops[0]; 2825e60d79faf7ef7bc4847f9e5d067af00b98dced7bDuncan Sands // getelementptr P, N -> P if P points to a type of zero size. 282636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (Q.DL) { 2827db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty = PtrTy->getElementType(); 282836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (Ty->isSized() && Q.DL->getTypeAllocSize(Ty) == 0) 2829e60d79faf7ef7bc4847f9e5d067af00b98dced7bDuncan Sands return Ops[0]; 2830e60d79faf7ef7bc4847f9e5d067af00b98dced7bDuncan Sands } 2831e60d79faf7ef7bc4847f9e5d067af00b98dced7bDuncan Sands } 283212a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2833c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner // Check to see if this is constant foldable. 2834b9b54ebfed02f0654897d37e8a4448d3f8087558Jay Foad for (unsigned i = 0, e = Ops.size(); i != e; ++i) 2835c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner if (!isa<Constant>(Ops[i])) 2836dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 283712a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2838dab3d29605a5c83db41b28176273ef55961120c1Jay Foad return ConstantExpr::getGetElementPtr(cast<Constant>(Ops[0]), Ops.slice(1)); 2839c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner} 2840c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner 284136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen HinesValue *llvm::SimplifyGEPInst(ArrayRef<Value *> Ops, const DataLayout *DL, 28420aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const TargetLibraryInfo *TLI, 28430aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const DominatorTree *DT) { 284436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return ::SimplifyGEPInst(Ops, Query (DL, TLI, DT), RecursionLimit); 28450aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands} 28460aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands 2847dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands/// SimplifyInsertValueInst - Given operands for an InsertValueInst, see if we 2848dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands/// can fold the result. If not, this returns null. 28490aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyInsertValueInst(Value *Agg, Value *Val, 28500aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands ArrayRef<unsigned> Idxs, const Query &Q, 28510aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands unsigned) { 2852dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands if (Constant *CAgg = dyn_cast<Constant>(Agg)) 2853dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands if (Constant *CVal = dyn_cast<Constant>(Val)) 2854dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands return ConstantFoldInsertValueInstruction(CAgg, CVal, Idxs); 2855dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands 2856dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands // insertvalue x, undef, n -> x 2857dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands if (match(Val, m_Undef())) 2858dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands return Agg; 2859dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands 2860dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands // insertvalue x, (extractvalue y, n), n 2861dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands if (ExtractValueInst *EV = dyn_cast<ExtractValueInst>(Val)) 2862ae707bd5594e52a8b385760f99ff58aa8fede948Benjamin Kramer if (EV->getAggregateOperand()->getType() == Agg->getType() && 2863ae707bd5594e52a8b385760f99ff58aa8fede948Benjamin Kramer EV->getIndices() == Idxs) { 2864dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands // insertvalue undef, (extractvalue y, n), n -> y 2865dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands if (match(Agg, m_Undef())) 2866dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands return EV->getAggregateOperand(); 2867dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands 2868dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands // insertvalue y, (extractvalue y, n), n -> y 2869dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands if (Agg == EV->getAggregateOperand()) 2870dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands return Agg; 2871dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands } 2872dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands 2873dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 2874dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands} 2875dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands 28760aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan SandsValue *llvm::SimplifyInsertValueInst(Value *Agg, Value *Val, 28770aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands ArrayRef<unsigned> Idxs, 287836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const DataLayout *DL, 28790aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const TargetLibraryInfo *TLI, 28800aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const DominatorTree *DT) { 288136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return ::SimplifyInsertValueInst(Agg, Val, Idxs, Query (DL, TLI, DT), 28820aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands RecursionLimit); 28830aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands} 28840aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands 2885ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands/// SimplifyPHINode - See if we can fold the given phi. If not, returns null. 28860aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyPHINode(PHINode *PN, const Query &Q) { 2887ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // If all of the PHI's incoming values are the same then replace the PHI node 2888ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // with the common value. 2889dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Value *CommonValue = nullptr; 2890ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands bool HasUndefInput = false; 2891ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) { 2892ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands Value *Incoming = PN->getIncomingValue(i); 2893ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // If the incoming value is the phi node itself, it can safely be skipped. 2894ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands if (Incoming == PN) continue; 2895ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands if (isa<UndefValue>(Incoming)) { 2896ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // Remember that we saw an undef value, but otherwise ignore them. 2897ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands HasUndefInput = true; 2898ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands continue; 2899ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands } 2900ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands if (CommonValue && Incoming != CommonValue) 2901dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; // Not the same, bail out. 2902ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands CommonValue = Incoming; 2903ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands } 2904ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands 2905ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // If CommonValue is null then all of the incoming values were either undef or 2906ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // equal to the phi node itself. 2907ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands if (!CommonValue) 2908ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands return UndefValue::get(PN->getType()); 2909ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands 2910ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // If we have a PHI node like phi(X, undef, X), where X is defined by some 2911ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // instruction, we cannot return X as the result of the PHI node unless it 2912ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // dominates the PHI block. 2913ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands if (HasUndefInput) 2914dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return ValueDominatesPHI(CommonValue, PN, Q.DT) ? CommonValue : nullptr; 2915ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands 2916ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands return CommonValue; 2917ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands} 2918ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands 2919bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sandsstatic Value *SimplifyTruncInst(Value *Op, Type *Ty, const Query &Q, unsigned) { 2920bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands if (Constant *C = dyn_cast<Constant>(Op)) 292136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return ConstantFoldInstOperands(Instruction::Trunc, Ty, C, Q.DL, Q.TLI); 2922bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands 2923dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 2924bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands} 2925bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands 292636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen HinesValue *llvm::SimplifyTruncInst(Value *Op, Type *Ty, const DataLayout *DL, 2927bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands const TargetLibraryInfo *TLI, 2928bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands const DominatorTree *DT) { 292936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return ::SimplifyTruncInst(Op, Ty, Query (DL, TLI, DT), RecursionLimit); 2930bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands} 2931bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands 2932d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner//=== Helper functions for higher up the class hierarchy. 29339dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 2934d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner/// SimplifyBinOp - Given operands for a BinaryOperator, see if we can 2935d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner/// fold the result. If not, this returns null. 2936a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *SimplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS, 29370aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 2938d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner switch (Opcode) { 293981a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner case Instruction::Add: 2940ffeb98ad3becfbb8e26270ef8751e37e4b6b0cd1Duncan Sands return SimplifyAddInst(LHS, RHS, /*isNSW*/false, /*isNUW*/false, 29410aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse); 2942d0a0d221da55f5e2d97909991d77e7ab91e75426Michael Ilseman case Instruction::FAdd: 2943d0a0d221da55f5e2d97909991d77e7ab91e75426Michael Ilseman return SimplifyFAddInst(LHS, RHS, FastMathFlags(), Q, MaxRecurse); 2944d0a0d221da55f5e2d97909991d77e7ab91e75426Michael Ilseman 294581a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner case Instruction::Sub: 2946ffeb98ad3becfbb8e26270ef8751e37e4b6b0cd1Duncan Sands return SimplifySubInst(LHS, RHS, /*isNSW*/false, /*isNUW*/false, 29470aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse); 2948d0a0d221da55f5e2d97909991d77e7ab91e75426Michael Ilseman case Instruction::FSub: 2949d0a0d221da55f5e2d97909991d77e7ab91e75426Michael Ilseman return SimplifyFSubInst(LHS, RHS, FastMathFlags(), Q, MaxRecurse); 2950d0a0d221da55f5e2d97909991d77e7ab91e75426Michael Ilseman 29510aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands case Instruction::Mul: return SimplifyMulInst (LHS, RHS, Q, MaxRecurse); 2952d0a0d221da55f5e2d97909991d77e7ab91e75426Michael Ilseman case Instruction::FMul: 2953d0a0d221da55f5e2d97909991d77e7ab91e75426Michael Ilseman return SimplifyFMulInst (LHS, RHS, FastMathFlags(), Q, MaxRecurse); 29540aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands case Instruction::SDiv: return SimplifySDivInst(LHS, RHS, Q, MaxRecurse); 29550aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands case Instruction::UDiv: return SimplifyUDivInst(LHS, RHS, Q, MaxRecurse); 29560aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands case Instruction::FDiv: return SimplifyFDivInst(LHS, RHS, Q, MaxRecurse); 29570aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands case Instruction::SRem: return SimplifySRemInst(LHS, RHS, Q, MaxRecurse); 29580aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands case Instruction::URem: return SimplifyURemInst(LHS, RHS, Q, MaxRecurse); 29590aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands case Instruction::FRem: return SimplifyFRemInst(LHS, RHS, Q, MaxRecurse); 296081a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner case Instruction::Shl: 2961ffeb98ad3becfbb8e26270ef8751e37e4b6b0cd1Duncan Sands return SimplifyShlInst(LHS, RHS, /*isNSW*/false, /*isNUW*/false, 29620aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse); 296381a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner case Instruction::LShr: 29640aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands return SimplifyLShrInst(LHS, RHS, /*isExact*/false, Q, MaxRecurse); 296581a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner case Instruction::AShr: 29660aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands return SimplifyAShrInst(LHS, RHS, /*isExact*/false, Q, MaxRecurse); 29670aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands case Instruction::And: return SimplifyAndInst(LHS, RHS, Q, MaxRecurse); 29680aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands case Instruction::Or: return SimplifyOrInst (LHS, RHS, Q, MaxRecurse); 29690aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands case Instruction::Xor: return SimplifyXorInst(LHS, RHS, Q, MaxRecurse); 2970d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner default: 2971d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(LHS)) 2972d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CRHS = dyn_cast<Constant>(RHS)) { 2973d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Constant *COps[] = {CLHS, CRHS}; 297436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return ConstantFoldInstOperands(Opcode, LHS->getType(), COps, Q.DL, 29750aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q.TLI); 2976d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 2977b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 2978566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // If the operation is associative, try some generic simplifications. 2979566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Instruction::isAssociative(Opcode)) 29800aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyAssociativeBinOp(Opcode, LHS, RHS, Q, MaxRecurse)) 2981566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return V; 2982566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 29830aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands // If the operation is with the result of a select instruction check whether 2984b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // operating on either branch of the select always yields the same value. 29850312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<SelectInst>(LHS) || isa<SelectInst>(RHS)) 29860aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadBinOpOverSelect(Opcode, LHS, RHS, Q, MaxRecurse)) 2987a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return V; 2988a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 2989a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the operation is with the result of a phi instruction, check whether 2990a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // operating on all incoming values of the phi always yields the same value. 29910312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<PHINode>(LHS) || isa<PHINode>(RHS)) 29920aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadBinOpOverPHI(Opcode, LHS, RHS, Q, MaxRecurse)) 2993b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return V; 2994b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 2995dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 2996d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 2997d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner} 29989dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 299912a86f5b3199e72e6d967781acc76340f5920e46Duncan SandsValue *llvm::SimplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS, 300036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const DataLayout *DL, const TargetLibraryInfo *TLI, 3001618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT) { 300236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return ::SimplifyBinOp(Opcode, LHS, RHS, Query (DL, TLI, DT), RecursionLimit); 3003a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 3004a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 30059dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// SimplifyCmpInst - Given operands for a CmpInst, see if we can 30069dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// fold the result. 3007a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *SimplifyCmpInst(unsigned Predicate, Value *LHS, Value *RHS, 30080aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 30099dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner if (CmpInst::isIntPredicate((CmpInst::Predicate)Predicate)) 30100aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands return SimplifyICmpInst(Predicate, LHS, RHS, Q, MaxRecurse); 30110aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands return SimplifyFCmpInst(Predicate, LHS, RHS, Q, MaxRecurse); 30129dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner} 30139dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 3014a74a58c83be492b7d5b7383656f049909394cff4Duncan SandsValue *llvm::SimplifyCmpInst(unsigned Predicate, Value *LHS, Value *RHS, 301536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const DataLayout *DL, const TargetLibraryInfo *TLI, 3016618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const DominatorTree *DT) { 301736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return ::SimplifyCmpInst(Predicate, LHS, RHS, Query (DL, TLI, DT), 30180aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands RecursionLimit); 3019a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 3020e34537856a544c83513e390ac9552a8bc3823346Chris Lattner 3021f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilsemanstatic bool IsIdempotent(Intrinsic::ID ID) { 3022f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman switch (ID) { 3023f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman default: return false; 3024f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman 3025f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman // Unary idempotent: f(f(x)) = f(x) 3026f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman case Intrinsic::fabs: 3027f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman case Intrinsic::floor: 3028f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman case Intrinsic::ceil: 3029f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman case Intrinsic::trunc: 3030f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman case Intrinsic::rint: 3031f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman case Intrinsic::nearbyint: 303241418d17cced656f91038b2482bc9d173b4974b0Hal Finkel case Intrinsic::round: 3033f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman return true; 3034f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman } 3035f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman} 3036f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman 3037f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilsemantemplate <typename IterTy> 3038f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilsemanstatic Value *SimplifyIntrinsic(Intrinsic::ID IID, IterTy ArgBegin, IterTy ArgEnd, 3039f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman const Query &Q, unsigned MaxRecurse) { 3040f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman // Perform idempotent optimizations 3041f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman if (!IsIdempotent(IID)) 3042dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 3043f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman 3044f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman // Unary Ops 3045f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman if (std::distance(ArgBegin, ArgEnd) == 1) 3046f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(*ArgBegin)) 3047f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman if (II->getIntrinsicID() == IID) 3048f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman return II; 3049f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman 3050dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 3051f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman} 3052f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman 3053c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruthtemplate <typename IterTy> 3054e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruthstatic Value *SimplifyCall(Value *V, IterTy ArgBegin, IterTy ArgEnd, 3055c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth const Query &Q, unsigned MaxRecurse) { 3056e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth Type *Ty = V->getType(); 3057c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth if (PointerType *PTy = dyn_cast<PointerType>(Ty)) 3058c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth Ty = PTy->getElementType(); 3059c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth FunctionType *FTy = cast<FunctionType>(Ty); 3060c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth 306171d050315704c23b235594d3fad5268c12d825e3Dan Gohman // call undef -> undef 3062e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth if (isa<UndefValue>(V)) 3063c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth return UndefValue::get(FTy->getReturnType()); 306471d050315704c23b235594d3fad5268c12d825e3Dan Gohman 3065e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth Function *F = dyn_cast<Function>(V); 3066e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth if (!F) 3067dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 3068e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth 3069f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman if (unsigned IID = F->getIntrinsicID()) 3070f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman if (Value *Ret = 3071f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman SimplifyIntrinsic((Intrinsic::ID) IID, ArgBegin, ArgEnd, Q, MaxRecurse)) 3072f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman return Ret; 3073f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman 3074e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth if (!canConstantFoldCallTo(F)) 3075dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 3076e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth 3077e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth SmallVector<Constant *, 4> ConstantArgs; 3078e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth ConstantArgs.reserve(ArgEnd - ArgBegin); 3079e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth for (IterTy I = ArgBegin, E = ArgEnd; I != E; ++I) { 3080e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth Constant *C = dyn_cast<Constant>(*I); 3081e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth if (!C) 3082dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 3083e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth ConstantArgs.push_back(C); 3084e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth } 3085e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth 3086e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth return ConstantFoldCall(F, ConstantArgs, Q.TLI); 308771d050315704c23b235594d3fad5268c12d825e3Dan Gohman} 308871d050315704c23b235594d3fad5268c12d825e3Dan Gohman 3089e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler CarruthValue *llvm::SimplifyCall(Value *V, User::op_iterator ArgBegin, 309036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines User::op_iterator ArgEnd, const DataLayout *DL, 3091c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth const TargetLibraryInfo *TLI, 3092c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth const DominatorTree *DT) { 309336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return ::SimplifyCall(V, ArgBegin, ArgEnd, Query(DL, TLI, DT), 3094c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth RecursionLimit); 3095c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth} 3096c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth 3097e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler CarruthValue *llvm::SimplifyCall(Value *V, ArrayRef<Value *> Args, 309836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const DataLayout *DL, const TargetLibraryInfo *TLI, 3099c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth const DominatorTree *DT) { 310036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return ::SimplifyCall(V, Args.begin(), Args.end(), Query(DL, TLI, DT), 3101c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth RecursionLimit); 3102c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth} 3103c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth 3104e34537856a544c83513e390ac9552a8bc3823346Chris Lattner/// SimplifyInstruction - See if we can compute a simplified version of this 3105e34537856a544c83513e390ac9552a8bc3823346Chris Lattner/// instruction. If not, this returns null. 310636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen HinesValue *llvm::SimplifyInstruction(Instruction *I, const DataLayout *DL, 3107618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 3108eff0581583ef10e2872e9baf537a04b67d992101Duncan Sands const DominatorTree *DT) { 3109d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands Value *Result; 3110d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands 3111e34537856a544c83513e390ac9552a8bc3823346Chris Lattner switch (I->getOpcode()) { 3112e34537856a544c83513e390ac9552a8bc3823346Chris Lattner default: 311336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Result = ConstantFoldInstruction(I, DL, TLI); 3114d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 311509ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman case Instruction::FAdd: 311609ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman Result = SimplifyFAddInst(I->getOperand(0), I->getOperand(1), 311736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines I->getFastMathFlags(), DL, TLI, DT); 311809ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman break; 31198aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner case Instruction::Add: 3120d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands Result = SimplifyAddInst(I->getOperand(0), I->getOperand(1), 3121d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands cast<BinaryOperator>(I)->hasNoSignedWrap(), 3122d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands cast<BinaryOperator>(I)->hasNoUnsignedWrap(), 312336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines DL, TLI, DT); 3124d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 312509ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman case Instruction::FSub: 312609ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman Result = SimplifyFSubInst(I->getOperand(0), I->getOperand(1), 312736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines I->getFastMathFlags(), DL, TLI, DT); 312809ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman break; 3129fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands case Instruction::Sub: 3130fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands Result = SimplifySubInst(I->getOperand(0), I->getOperand(1), 3131fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands cast<BinaryOperator>(I)->hasNoSignedWrap(), 3132fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands cast<BinaryOperator>(I)->hasNoUnsignedWrap(), 313336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines DL, TLI, DT); 3134fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands break; 3135eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman case Instruction::FMul: 3136eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman Result = SimplifyFMulInst(I->getOperand(0), I->getOperand(1), 313736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines I->getFastMathFlags(), DL, TLI, DT); 3138eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman break; 313982fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands case Instruction::Mul: 314036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Result = SimplifyMulInst(I->getOperand(0), I->getOperand(1), DL, TLI, DT); 314182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands break; 3142593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands case Instruction::SDiv: 314336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Result = SimplifySDivInst(I->getOperand(0), I->getOperand(1), DL, TLI, DT); 3144593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands break; 3145593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands case Instruction::UDiv: 314636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Result = SimplifyUDivInst(I->getOperand(0), I->getOperand(1), DL, TLI, DT); 3147593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands break; 31481fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel case Instruction::FDiv: 314936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Result = SimplifyFDivInst(I->getOperand(0), I->getOperand(1), DL, TLI, DT); 31501fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel break; 3151f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands case Instruction::SRem: 315236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Result = SimplifySRemInst(I->getOperand(0), I->getOperand(1), DL, TLI, DT); 3153f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands break; 3154f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands case Instruction::URem: 315536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Result = SimplifyURemInst(I->getOperand(0), I->getOperand(1), DL, TLI, DT); 3156f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands break; 3157f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands case Instruction::FRem: 315836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Result = SimplifyFRemInst(I->getOperand(0), I->getOperand(1), DL, TLI, DT); 3159f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands break; 3160c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands case Instruction::Shl: 316181a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Result = SimplifyShlInst(I->getOperand(0), I->getOperand(1), 316281a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner cast<BinaryOperator>(I)->hasNoSignedWrap(), 316381a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner cast<BinaryOperator>(I)->hasNoUnsignedWrap(), 316436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines DL, TLI, DT); 3165c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands break; 3166c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands case Instruction::LShr: 316781a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Result = SimplifyLShrInst(I->getOperand(0), I->getOperand(1), 316881a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner cast<BinaryOperator>(I)->isExact(), 316936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines DL, TLI, DT); 3170c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands break; 3171c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands case Instruction::AShr: 317281a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Result = SimplifyAShrInst(I->getOperand(0), I->getOperand(1), 317381a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner cast<BinaryOperator>(I)->isExact(), 317436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines DL, TLI, DT); 3175c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands break; 3176e34537856a544c83513e390ac9552a8bc3823346Chris Lattner case Instruction::And: 317736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Result = SimplifyAndInst(I->getOperand(0), I->getOperand(1), DL, TLI, DT); 3178d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 3179e34537856a544c83513e390ac9552a8bc3823346Chris Lattner case Instruction::Or: 318036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Result = SimplifyOrInst(I->getOperand(0), I->getOperand(1), DL, TLI, DT); 3181d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 31822b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands case Instruction::Xor: 318336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Result = SimplifyXorInst(I->getOperand(0), I->getOperand(1), DL, TLI, DT); 31842b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands break; 3185e34537856a544c83513e390ac9552a8bc3823346Chris Lattner case Instruction::ICmp: 3186d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands Result = SimplifyICmpInst(cast<ICmpInst>(I)->getPredicate(), 318736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines I->getOperand(0), I->getOperand(1), DL, TLI, DT); 3188d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 3189e34537856a544c83513e390ac9552a8bc3823346Chris Lattner case Instruction::FCmp: 3190d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands Result = SimplifyFCmpInst(cast<FCmpInst>(I)->getPredicate(), 319136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines I->getOperand(0), I->getOperand(1), DL, TLI, DT); 3192d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 3193047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner case Instruction::Select: 3194d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands Result = SimplifySelectInst(I->getOperand(0), I->getOperand(1), 319536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines I->getOperand(2), DL, TLI, DT); 3196d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 3197c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner case Instruction::GetElementPtr: { 3198c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner SmallVector<Value*, 8> Ops(I->op_begin(), I->op_end()); 319936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Result = SimplifyGEPInst(Ops, DL, TLI, DT); 3200d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 3201c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner } 3202dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands case Instruction::InsertValue: { 3203dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands InsertValueInst *IV = cast<InsertValueInst>(I); 3204dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands Result = SimplifyInsertValueInst(IV->getAggregateOperand(), 3205dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands IV->getInsertedValueOperand(), 320636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines IV->getIndices(), DL, TLI, DT); 3207dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands break; 3208dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands } 3209cd6636c737a82949ad13db2d0d918af6424fb78bDuncan Sands case Instruction::PHI: 321036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Result = SimplifyPHINode(cast<PHINode>(I), Query (DL, TLI, DT)); 3211d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 3212c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth case Instruction::Call: { 3213c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth CallSite CS(cast<CallInst>(I)); 3214c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth Result = SimplifyCall(CS.getCalledValue(), CS.arg_begin(), CS.arg_end(), 321536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines DL, TLI, DT); 321671d050315704c23b235594d3fad5268c12d825e3Dan Gohman break; 3217c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth } 3218bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands case Instruction::Trunc: 321936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Result = SimplifyTruncInst(I->getOperand(0), I->getType(), DL, TLI, DT); 3220bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands break; 3221e34537856a544c83513e390ac9552a8bc3823346Chris Lattner } 3222d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands 3223d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands /// If called on unreachable code, the above logic may report that the 3224d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands /// instruction simplified to itself. Make life easier for users by 3225f8b1a5ea9602bb65a5cf59d3d34f2851a08cdc3eDuncan Sands /// detecting that case here, returning a safe value instead. 3226f8b1a5ea9602bb65a5cf59d3d34f2851a08cdc3eDuncan Sands return Result == I ? UndefValue::get(I->getType()) : Result; 3227e34537856a544c83513e390ac9552a8bc3823346Chris Lattner} 3228e34537856a544c83513e390ac9552a8bc3823346Chris Lattner 32296b980541df5846ad335c377c8803b517968daee2Chandler Carruth/// \brief Implementation of recursive simplification through an instructions 32306b980541df5846ad335c377c8803b517968daee2Chandler Carruth/// uses. 323140d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// 32326b980541df5846ad335c377c8803b517968daee2Chandler Carruth/// This is the common implementation of the recursive simplification routines. 32336b980541df5846ad335c377c8803b517968daee2Chandler Carruth/// If we have a pre-simplified value in 'SimpleV', that is forcibly used to 32346b980541df5846ad335c377c8803b517968daee2Chandler Carruth/// replace the instruction 'I'. Otherwise, we simply add 'I' to the list of 32356b980541df5846ad335c377c8803b517968daee2Chandler Carruth/// instructions to process and attempt to simplify it using 32366b980541df5846ad335c377c8803b517968daee2Chandler Carruth/// InstructionSimplify. 32376b980541df5846ad335c377c8803b517968daee2Chandler Carruth/// 32386b980541df5846ad335c377c8803b517968daee2Chandler Carruth/// This routine returns 'true' only when *it* simplifies something. The passed 32396b980541df5846ad335c377c8803b517968daee2Chandler Carruth/// in simplified value does not count toward this. 32406b980541df5846ad335c377c8803b517968daee2Chandler Carruthstatic bool replaceAndRecursivelySimplifyImpl(Instruction *I, Value *SimpleV, 324136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const DataLayout *DL, 32426b980541df5846ad335c377c8803b517968daee2Chandler Carruth const TargetLibraryInfo *TLI, 32436b980541df5846ad335c377c8803b517968daee2Chandler Carruth const DominatorTree *DT) { 32446b980541df5846ad335c377c8803b517968daee2Chandler Carruth bool Simplified = false; 32456231d5be410e2d7967352b29ad01522fda15680dChandler Carruth SmallSetVector<Instruction *, 8> Worklist; 32466b980541df5846ad335c377c8803b517968daee2Chandler Carruth 32476b980541df5846ad335c377c8803b517968daee2Chandler Carruth // If we have an explicit value to collapse to, do that round of the 32486b980541df5846ad335c377c8803b517968daee2Chandler Carruth // simplification loop by hand initially. 32496b980541df5846ad335c377c8803b517968daee2Chandler Carruth if (SimpleV) { 325036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines for (User *U : I->users()) 325136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (U != I) 325236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Worklist.insert(cast<Instruction>(U)); 32536b980541df5846ad335c377c8803b517968daee2Chandler Carruth 32546b980541df5846ad335c377c8803b517968daee2Chandler Carruth // Replace the instruction with its simplified value. 32556b980541df5846ad335c377c8803b517968daee2Chandler Carruth I->replaceAllUsesWith(SimpleV); 32566b980541df5846ad335c377c8803b517968daee2Chandler Carruth 32576b980541df5846ad335c377c8803b517968daee2Chandler Carruth // Gracefully handle edge cases where the instruction is not wired into any 32586b980541df5846ad335c377c8803b517968daee2Chandler Carruth // parent block. 32596b980541df5846ad335c377c8803b517968daee2Chandler Carruth if (I->getParent()) 32606b980541df5846ad335c377c8803b517968daee2Chandler Carruth I->eraseFromParent(); 32616b980541df5846ad335c377c8803b517968daee2Chandler Carruth } else { 32626231d5be410e2d7967352b29ad01522fda15680dChandler Carruth Worklist.insert(I); 32636b980541df5846ad335c377c8803b517968daee2Chandler Carruth } 326412a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 32656231d5be410e2d7967352b29ad01522fda15680dChandler Carruth // Note that we must test the size on each iteration, the worklist can grow. 32666231d5be410e2d7967352b29ad01522fda15680dChandler Carruth for (unsigned Idx = 0; Idx != Worklist.size(); ++Idx) { 32676231d5be410e2d7967352b29ad01522fda15680dChandler Carruth I = Worklist[Idx]; 326812a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 32696b980541df5846ad335c377c8803b517968daee2Chandler Carruth // See if this instruction simplifies. 327036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines SimpleV = SimplifyInstruction(I, DL, TLI, DT); 32716b980541df5846ad335c377c8803b517968daee2Chandler Carruth if (!SimpleV) 32726b980541df5846ad335c377c8803b517968daee2Chandler Carruth continue; 32736b980541df5846ad335c377c8803b517968daee2Chandler Carruth 32746b980541df5846ad335c377c8803b517968daee2Chandler Carruth Simplified = true; 32756b980541df5846ad335c377c8803b517968daee2Chandler Carruth 32766b980541df5846ad335c377c8803b517968daee2Chandler Carruth // Stash away all the uses of the old instruction so we can check them for 32776b980541df5846ad335c377c8803b517968daee2Chandler Carruth // recursive simplifications after a RAUW. This is cheaper than checking all 32786b980541df5846ad335c377c8803b517968daee2Chandler Carruth // uses of To on the recursive step in most cases. 327936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines for (User *U : I->users()) 328036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Worklist.insert(cast<Instruction>(U)); 328112a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 32826b980541df5846ad335c377c8803b517968daee2Chandler Carruth // Replace the instruction with its simplified value. 32836b980541df5846ad335c377c8803b517968daee2Chandler Carruth I->replaceAllUsesWith(SimpleV); 32846b980541df5846ad335c377c8803b517968daee2Chandler Carruth 32856b980541df5846ad335c377c8803b517968daee2Chandler Carruth // Gracefully handle edge cases where the instruction is not wired into any 32866b980541df5846ad335c377c8803b517968daee2Chandler Carruth // parent block. 32876b980541df5846ad335c377c8803b517968daee2Chandler Carruth if (I->getParent()) 32886b980541df5846ad335c377c8803b517968daee2Chandler Carruth I->eraseFromParent(); 328940d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner } 32906b980541df5846ad335c377c8803b517968daee2Chandler Carruth return Simplified; 32916b980541df5846ad335c377c8803b517968daee2Chandler Carruth} 329212a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 32936b980541df5846ad335c377c8803b517968daee2Chandler Carruthbool llvm::recursivelySimplifyInstruction(Instruction *I, 329436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const DataLayout *DL, 32956b980541df5846ad335c377c8803b517968daee2Chandler Carruth const TargetLibraryInfo *TLI, 32966b980541df5846ad335c377c8803b517968daee2Chandler Carruth const DominatorTree *DT) { 3297dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return replaceAndRecursivelySimplifyImpl(I, nullptr, DL, TLI, DT); 32986b980541df5846ad335c377c8803b517968daee2Chandler Carruth} 329912a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 33006b980541df5846ad335c377c8803b517968daee2Chandler Carruthbool llvm::replaceAndRecursivelySimplify(Instruction *I, Value *SimpleV, 330136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const DataLayout *DL, 33026b980541df5846ad335c377c8803b517968daee2Chandler Carruth const TargetLibraryInfo *TLI, 33036b980541df5846ad335c377c8803b517968daee2Chandler Carruth const DominatorTree *DT) { 33046b980541df5846ad335c377c8803b517968daee2Chandler Carruth assert(I != SimpleV && "replaceAndRecursivelySimplify(X,X) is not valid!"); 33056b980541df5846ad335c377c8803b517968daee2Chandler Carruth assert(SimpleV && "Must provide a simplified value."); 330636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return replaceAndRecursivelySimplifyImpl(I, SimpleV, DL, TLI, DT); 330740d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner} 3308