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" 23ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines#include "llvm/Analysis/AliasAnalysis.h" 24de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar#include "llvm/Analysis/CaptureTracking.h" 259f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner#include "llvm/Analysis/ConstantFolding.h" 26fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman#include "llvm/Analysis/MemoryBuiltins.h" 2736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines#include "llvm/Analysis/ValueTracking.h" 28f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar#include "llvm/Analysis/VectorUtils.h" 2936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines#include "llvm/IR/ConstantRange.h" 300b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/DataLayout.h" 3136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines#include "llvm/IR/Dominators.h" 3236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines#include "llvm/IR/GetElementPtrTypeIterator.h" 330b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/GlobalAlias.h" 340b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Operator.h" 3536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines#include "llvm/IR/PatternMatch.h" 3636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines#include "llvm/IR/ValueHandle.h" 37ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines#include <algorithm> 389f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattnerusing namespace llvm; 39d06094f0682f2ede03caff4892b1a57469896d48Chris Lattnerusing namespace llvm::PatternMatch; 409f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 41dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines#define DEBUG_TYPE "instsimplify" 42dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 4381a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattnerenum { RecursionLimit = 3 }; 44a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 45a3c44a5280042dbc0cde995675c225ede4528c6eDuncan SandsSTATISTIC(NumExpand, "Number of expansions"); 46a3c44a5280042dbc0cde995675c225ede4528c6eDuncan SandsSTATISTIC(NumReassoc, "Number of reassociations"); 47a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands 4837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hinesnamespace { 490aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstruct Query { 504c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar const DataLayout &DL; 510aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const TargetLibraryInfo *TLI; 520aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const DominatorTree *DT; 53ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines AssumptionCache *AC; 5437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const Instruction *CxtI; 550aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands 564c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar Query(const DataLayout &DL, const TargetLibraryInfo *tli, 57ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const DominatorTree *dt, AssumptionCache *ac = nullptr, 5837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const Instruction *cxti = nullptr) 59ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines : DL(DL), TLI(tli), DT(dt), AC(ac), CxtI(cxti) {} 600aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands}; 6137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines} // end anonymous namespace 620aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands 630aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyAndInst(Value *, Value *, const Query &, unsigned); 640aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyBinOp(unsigned, Value *, Value *, const Query &, 65618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier unsigned); 66ebe69fe11e48d322045d5949c83283927a0d790bStephen Hinesstatic Value *SimplifyFPBinOp(unsigned, Value *, Value *, const FastMathFlags &, 67ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const Query &, unsigned); 680aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyCmpInst(unsigned, Value *, Value *, const Query &, 69618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier unsigned); 700aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyOrInst(Value *, Value *, const Query &, unsigned); 710aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyXorInst(Value *, Value *, const Query &, unsigned); 72bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sandsstatic Value *SimplifyTruncInst(Value *, Type *, const Query &, unsigned); 731845009290e4d804ad377927bd8a08cca3036adcDuncan Sands 74de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// For a boolean type, or a vector of boolean type, return false, or 75f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands/// a vector with every element false, as appropriate for the type. 76f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sandsstatic Constant *getFalse(Type *Ty) { 7766d004ef708642bbdc38fd761507f2e9ee3970cdNick Lewycky assert(Ty->getScalarType()->isIntegerTy(1) && 78f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands "Expected i1 type or a vector of i1!"); 79f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return Constant::getNullValue(Ty); 80f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands} 81f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands 82de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// For a boolean type, or a vector of boolean type, return true, or 83f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands/// a vector with every element true, as appropriate for the type. 84f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sandsstatic Constant *getTrue(Type *Ty) { 8566d004ef708642bbdc38fd761507f2e9ee3970cdNick Lewycky assert(Ty->getScalarType()->isIntegerTy(1) && 86f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands "Expected i1 type or a vector of i1!"); 87f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return Constant::getAllOnesValue(Ty); 88f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands} 89f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands 906dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands/// isSameCompare - Is V equivalent to the comparison "LHS Pred RHS"? 916dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sandsstatic bool isSameCompare(Value *V, CmpInst::Predicate Pred, Value *LHS, 926dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands Value *RHS) { 936dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands CmpInst *Cmp = dyn_cast<CmpInst>(V); 946dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (!Cmp) 956dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return false; 966dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands CmpInst::Predicate CPred = Cmp->getPredicate(); 976dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands Value *CLHS = Cmp->getOperand(0), *CRHS = Cmp->getOperand(1); 986dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (CPred == Pred && CLHS == LHS && CRHS == RHS) 996dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return true; 1006dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return CPred == CmpInst::getSwappedPredicate(Pred) && CLHS == RHS && 1016dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands CRHS == LHS; 1026dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands} 1036dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands 104de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Does the given value dominate the specified phi node? 1051845009290e4d804ad377927bd8a08cca3036adcDuncan Sandsstatic bool ValueDominatesPHI(Value *V, PHINode *P, const DominatorTree *DT) { 1061845009290e4d804ad377927bd8a08cca3036adcDuncan Sands Instruction *I = dyn_cast<Instruction>(V); 1071845009290e4d804ad377927bd8a08cca3036adcDuncan Sands if (!I) 1081845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // Arguments and constants dominate all instructions. 1091845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return true; 1101845009290e4d804ad377927bd8a08cca3036adcDuncan Sands 111ff739c1575df58f3926c2f3b6e00a6c45f773523Chandler Carruth // If we are processing instructions (and/or basic blocks) that have not been 112ff739c1575df58f3926c2f3b6e00a6c45f773523Chandler Carruth // fully added to a function, the parent nodes may still be null. Simply 113ff739c1575df58f3926c2f3b6e00a6c45f773523Chandler Carruth // return the conservative answer in these cases. 114ff739c1575df58f3926c2f3b6e00a6c45f773523Chandler Carruth if (!I->getParent() || !P->getParent() || !I->getParent()->getParent()) 115ff739c1575df58f3926c2f3b6e00a6c45f773523Chandler Carruth return false; 116ff739c1575df58f3926c2f3b6e00a6c45f773523Chandler Carruth 1171845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // If we have a DominatorTree then do a precise test. 1185b8f0ddc7e5bc3c7ffe1b2226a8316796f18b90eEli Friedman if (DT) { 1195b8f0ddc7e5bc3c7ffe1b2226a8316796f18b90eEli Friedman if (!DT->isReachableFromEntry(P->getParent())) 1205b8f0ddc7e5bc3c7ffe1b2226a8316796f18b90eEli Friedman return true; 1215b8f0ddc7e5bc3c7ffe1b2226a8316796f18b90eEli Friedman if (!DT->isReachableFromEntry(I->getParent())) 1225b8f0ddc7e5bc3c7ffe1b2226a8316796f18b90eEli Friedman return false; 1235b8f0ddc7e5bc3c7ffe1b2226a8316796f18b90eEli Friedman return DT->dominates(I, P); 1245b8f0ddc7e5bc3c7ffe1b2226a8316796f18b90eEli Friedman } 1251845009290e4d804ad377927bd8a08cca3036adcDuncan Sands 126f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar // Otherwise, if the instruction is in the entry block and is not an invoke, 1271845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // then it obviously dominates all phi nodes. 1281845009290e4d804ad377927bd8a08cca3036adcDuncan Sands if (I->getParent() == &I->getParent()->getParent()->getEntryBlock() && 1291845009290e4d804ad377927bd8a08cca3036adcDuncan Sands !isa<InvokeInst>(I)) 1301845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return true; 1311845009290e4d804ad377927bd8a08cca3036adcDuncan Sands 1321845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return false; 1331845009290e4d804ad377927bd8a08cca3036adcDuncan Sands} 134a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 135de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Simplify "A op (B op' C)" by distributing op over op', turning it into 136de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// "(A op B) op' (A op C)". Here "op" is given by Opcode and "op'" is 1373421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// given by OpcodeToExpand, while "A" corresponds to LHS and "B op' C" to RHS. 1383421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// Also performs the transform "(A op' B) op C" -> "(A op C) op' (B op C)". 1393421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// Returns the simplified value, or null if no simplification was performed. 1403421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sandsstatic Value *ExpandBinOp(unsigned Opcode, Value *LHS, Value *RHS, 1410aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands unsigned OpcToExpand, const Query &Q, 142618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier unsigned MaxRecurse) { 143e21083aa3a79506f896d95d7147c3c4627a77ef0Benjamin Kramer Instruction::BinaryOps OpcodeToExpand = (Instruction::BinaryOps)OpcToExpand; 1443421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 1453421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (!MaxRecurse--) 146dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 1473421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1483421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Check whether the expression has the form "(A op' B) op C". 1493421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (BinaryOperator *Op0 = dyn_cast<BinaryOperator>(LHS)) 1503421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Op0->getOpcode() == OpcodeToExpand) { 1513421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // It does! Try turning it into "(A op C) op' (B op C)". 1523421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands Value *A = Op0->getOperand(0), *B = Op0->getOperand(1), *C = RHS; 1533421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Do "A op C" and "B op C" both simplify? 1540aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *L = SimplifyBinOp(Opcode, A, C, Q, MaxRecurse)) 1550aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *R = SimplifyBinOp(Opcode, B, C, Q, MaxRecurse)) { 1563421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // They do! Return "L op' R" if it simplifies or is already available. 1573421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // If "L op' R" equals "A op' B" then "L op' R" is just the LHS. 158124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if ((L == A && R == B) || (Instruction::isCommutative(OpcodeToExpand) 159124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands && L == B && R == A)) { 160a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumExpand; 1613421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return LHS; 162a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 1633421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Otherwise return "L op' R" if it simplifies. 1640aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyBinOp(OpcodeToExpand, L, R, Q, MaxRecurse)) { 165a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumExpand; 1663421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 167a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 1683421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 1693421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 1703421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1713421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Check whether the expression has the form "A op (B op' C)". 1723421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (BinaryOperator *Op1 = dyn_cast<BinaryOperator>(RHS)) 1733421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Op1->getOpcode() == OpcodeToExpand) { 1743421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // It does! Try turning it into "(A op B) op' (A op C)". 1753421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands Value *A = LHS, *B = Op1->getOperand(0), *C = Op1->getOperand(1); 1763421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Do "A op B" and "A op C" both simplify? 1770aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *L = SimplifyBinOp(Opcode, A, B, Q, MaxRecurse)) 1780aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *R = SimplifyBinOp(Opcode, A, C, Q, MaxRecurse)) { 1793421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // They do! Return "L op' R" if it simplifies or is already available. 1803421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // If "L op' R" equals "B op' C" then "L op' R" is just the RHS. 181124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if ((L == B && R == C) || (Instruction::isCommutative(OpcodeToExpand) 182124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands && L == C && R == B)) { 183a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumExpand; 1843421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return RHS; 185a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 1863421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Otherwise return "L op' R" if it simplifies. 1870aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyBinOp(OpcodeToExpand, L, R, Q, MaxRecurse)) { 188a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumExpand; 1893421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 190a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 1913421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 1923421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 1933421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 194dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 1953421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands} 1963421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 197de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Generic simplifications for associative binary operations. 198de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Returns the simpler value, or null if none was found. 199e21083aa3a79506f896d95d7147c3c4627a77ef0Benjamin Kramerstatic Value *SimplifyAssociativeBinOp(unsigned Opc, Value *LHS, Value *RHS, 2000aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 201e21083aa3a79506f896d95d7147c3c4627a77ef0Benjamin Kramer Instruction::BinaryOps Opcode = (Instruction::BinaryOps)Opc; 202566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands assert(Instruction::isAssociative(Opcode) && "Not an associative operation!"); 203566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 204566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 205566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (!MaxRecurse--) 206dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 207566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 208566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands BinaryOperator *Op0 = dyn_cast<BinaryOperator>(LHS); 209566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands BinaryOperator *Op1 = dyn_cast<BinaryOperator>(RHS); 210566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 211566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Transform: "(A op B) op C" ==> "A op (B op C)" if it simplifies completely. 212566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Op0 && Op0->getOpcode() == Opcode) { 213566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *A = Op0->getOperand(0); 214566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *B = Op0->getOperand(1); 215566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *C = RHS; 216566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 217566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Does "B op C" simplify? 2180aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyBinOp(Opcode, B, C, Q, MaxRecurse)) { 219566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // It does! Return "A op V" if it simplifies or is already available. 220566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // If V equals B then "A op V" is just the LHS. 221124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (V == B) return LHS; 222566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Otherwise return "A op V" if it simplifies. 2230aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *W = SimplifyBinOp(Opcode, A, V, Q, MaxRecurse)) { 224a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumReassoc; 225566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return W; 226a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 227566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 228566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 229566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 230566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Transform: "A op (B op C)" ==> "(A op B) op C" if it simplifies completely. 231566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Op1 && Op1->getOpcode() == Opcode) { 232566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *A = LHS; 233566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *B = Op1->getOperand(0); 234566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *C = Op1->getOperand(1); 235566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 236566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Does "A op B" simplify? 2370aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyBinOp(Opcode, A, B, Q, MaxRecurse)) { 238566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // It does! Return "V op C" if it simplifies or is already available. 239566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // If V equals B then "V op C" is just the RHS. 240124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (V == B) return RHS; 241566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Otherwise return "V op C" if it simplifies. 2420aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *W = SimplifyBinOp(Opcode, V, C, Q, MaxRecurse)) { 243a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumReassoc; 244566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return W; 245a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 246566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 247566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 248566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 249566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // The remaining transforms require commutativity as well as associativity. 250566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (!Instruction::isCommutative(Opcode)) 251dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 252566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 253566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Transform: "(A op B) op C" ==> "(C op A) op B" if it simplifies completely. 254566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Op0 && Op0->getOpcode() == Opcode) { 255566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *A = Op0->getOperand(0); 256566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *B = Op0->getOperand(1); 257566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *C = RHS; 258566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 259566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Does "C op A" simplify? 2600aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyBinOp(Opcode, C, A, Q, MaxRecurse)) { 261566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // It does! Return "V op B" if it simplifies or is already available. 262566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // If V equals A then "V op B" is just the LHS. 263124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (V == A) return LHS; 264566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Otherwise return "V op B" if it simplifies. 2650aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *W = SimplifyBinOp(Opcode, V, B, Q, MaxRecurse)) { 266a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumReassoc; 267566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return W; 268a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 269566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 270566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 271566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 272566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Transform: "A op (B op C)" ==> "B op (C op A)" if it simplifies completely. 273566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Op1 && Op1->getOpcode() == Opcode) { 274566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *A = LHS; 275566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *B = Op1->getOperand(0); 276566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *C = Op1->getOperand(1); 277566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 278566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Does "C op A" simplify? 2790aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyBinOp(Opcode, C, A, Q, MaxRecurse)) { 280566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // It does! Return "B op V" if it simplifies or is already available. 281566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // If V equals C then "B op V" is just the RHS. 282124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (V == C) return RHS; 283566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Otherwise return "B op V" if it simplifies. 2840aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *W = SimplifyBinOp(Opcode, B, V, Q, MaxRecurse)) { 285a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumReassoc; 286566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return W; 287a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 288566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 289566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 290566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 291dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 292566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands} 293566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 294de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// In the case of a binary operation with a select instruction as an operand, 295de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// try to simplify the binop by seeing whether evaluating it on both branches 296de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// of the select results in the same value. Returns the common value if so, 297de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// otherwise returns null. 298b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sandsstatic Value *ThreadBinOpOverSelect(unsigned Opcode, Value *LHS, Value *RHS, 2990aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 3000312a93693abc2eb682b2b101c889959888fd883Duncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 3010312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (!MaxRecurse--) 302dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 3030312a93693abc2eb682b2b101c889959888fd883Duncan Sands 304b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands SelectInst *SI; 305b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (isa<SelectInst>(LHS)) { 306b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands SI = cast<SelectInst>(LHS); 307b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } else { 308b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands assert(isa<SelectInst>(RHS) && "No select instruction operand!"); 309b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands SI = cast<SelectInst>(RHS); 310b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } 311b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 312b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // Evaluate the BinOp on the true and false branches of the select. 313b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Value *TV; 314b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Value *FV; 315b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (SI == LHS) { 3160aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands TV = SimplifyBinOp(Opcode, SI->getTrueValue(), RHS, Q, MaxRecurse); 3170aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands FV = SimplifyBinOp(Opcode, SI->getFalseValue(), RHS, Q, MaxRecurse); 318b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } else { 3190aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands TV = SimplifyBinOp(Opcode, LHS, SI->getTrueValue(), Q, MaxRecurse); 3200aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands FV = SimplifyBinOp(Opcode, LHS, SI->getFalseValue(), Q, MaxRecurse); 321b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } 322b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 3237cf85e74e3885005ca8e5fdb155fa5351e255b85Duncan Sands // If they simplified to the same value, then return the common value. 324124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands // If they both failed to simplify then return null. 325124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (TV == FV) 326b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return TV; 327b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 328b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // If one branch simplified to undef, return the other one. 329b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (TV && isa<UndefValue>(TV)) 330b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return FV; 331b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (FV && isa<UndefValue>(FV)) 332b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return TV; 333b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 334b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // If applying the operation did not change the true and false select values, 335b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // then the result of the binop is the select itself. 336124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (TV == SI->getTrueValue() && FV == SI->getFalseValue()) 337b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return SI; 338b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 339b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // If one branch simplified and the other did not, and the simplified 340b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // value is equal to the unsimplified one, return the simplified value. 341b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // For example, select (cond, X, X & Z) & Z -> X & Z. 342b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if ((FV && !TV) || (TV && !FV)) { 343b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // Check that the simplified value has the form "X op Y" where "op" is the 344b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // same as the original operation. 345b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Instruction *Simplified = dyn_cast<Instruction>(FV ? FV : TV); 346b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (Simplified && Simplified->getOpcode() == Opcode) { 347b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // The value that didn't simplify is "UnsimplifiedLHS op UnsimplifiedRHS". 348b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // We already know that "op" is the same as for the simplified value. See 349b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // if the operands match too. If so, return the simplified value. 350b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Value *UnsimplifiedBranch = FV ? SI->getTrueValue() : SI->getFalseValue(); 351b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Value *UnsimplifiedLHS = SI == LHS ? UnsimplifiedBranch : LHS; 352b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Value *UnsimplifiedRHS = SI == LHS ? RHS : UnsimplifiedBranch; 353124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (Simplified->getOperand(0) == UnsimplifiedLHS && 354124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands Simplified->getOperand(1) == UnsimplifiedRHS) 355b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return Simplified; 356b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (Simplified->isCommutative() && 357124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands Simplified->getOperand(1) == UnsimplifiedLHS && 358124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands Simplified->getOperand(0) == UnsimplifiedRHS) 359b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return Simplified; 360b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } 361b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } 362b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 363dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 364b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands} 365b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 366de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// In the case of a comparison with a select instruction, try to simplify the 367de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// comparison by seeing whether both branches of the select result in the same 368de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// value. Returns the common value if so, otherwise returns null. 369b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sandsstatic Value *ThreadCmpOverSelect(CmpInst::Predicate Pred, Value *LHS, 3700aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Value *RHS, const Query &Q, 371a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands unsigned MaxRecurse) { 3720312a93693abc2eb682b2b101c889959888fd883Duncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 3730312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (!MaxRecurse--) 374dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 3750312a93693abc2eb682b2b101c889959888fd883Duncan Sands 376b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // Make sure the select is on the LHS. 377b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (!isa<SelectInst>(LHS)) { 378b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands std::swap(LHS, RHS); 379b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Pred = CmpInst::getSwappedPredicate(Pred); 380b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } 381b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands assert(isa<SelectInst>(LHS) && "Not comparing with a select instruction!"); 382b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands SelectInst *SI = cast<SelectInst>(LHS); 3836dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands Value *Cond = SI->getCondition(); 3846dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands Value *TV = SI->getTrueValue(); 3856dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands Value *FV = SI->getFalseValue(); 386b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 38750ca4d37f7f3b460c6441eb5ad14625a7d86b5d9Duncan Sands // Now that we have "cmp select(Cond, TV, FV), RHS", analyse it. 388b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // Does "cmp TV, RHS" simplify? 3890aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Value *TCmp = SimplifyCmpInst(Pred, TV, RHS, Q, MaxRecurse); 3906dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (TCmp == Cond) { 3916dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // It not only simplified, it simplified to the select condition. Replace 3926dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // it with 'true'. 3936dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands TCmp = getTrue(Cond->getType()); 3946dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands } else if (!TCmp) { 3956dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // It didn't simplify. However if "cmp TV, RHS" is equal to the select 3966dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // condition then we can replace it with 'true'. Otherwise give up. 3976dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (!isSameCompare(Cond, Pred, TV, RHS)) 398dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 3996dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands TCmp = getTrue(Cond->getType()); 40050ca4d37f7f3b460c6441eb5ad14625a7d86b5d9Duncan Sands } 40150ca4d37f7f3b460c6441eb5ad14625a7d86b5d9Duncan Sands 4026dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // Does "cmp FV, RHS" simplify? 4030aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Value *FCmp = SimplifyCmpInst(Pred, FV, RHS, Q, MaxRecurse); 4046dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (FCmp == Cond) { 4056dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // It not only simplified, it simplified to the select condition. Replace 4066dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // it with 'false'. 4076dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands FCmp = getFalse(Cond->getType()); 4086dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands } else if (!FCmp) { 4096dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // It didn't simplify. However if "cmp FV, RHS" is equal to the select 4106dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // condition then we can replace it with 'false'. Otherwise give up. 4116dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (!isSameCompare(Cond, Pred, FV, RHS)) 412dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 4136dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands FCmp = getFalse(Cond->getType()); 4146dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands } 4156dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands 4166dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // If both sides simplified to the same value, then use it as the result of 4176dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // the original comparison. 4186dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (TCmp == FCmp) 4196dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return TCmp; 420aa97bb54f02784abefa0ae170af5937915bdb329Duncan Sands 421aa97bb54f02784abefa0ae170af5937915bdb329Duncan Sands // The remaining cases only make sense if the select condition has the same 422aa97bb54f02784abefa0ae170af5937915bdb329Duncan Sands // type as the result of the comparison, so bail out if this is not so. 423aa97bb54f02784abefa0ae170af5937915bdb329Duncan Sands if (Cond->getType()->isVectorTy() != RHS->getType()->isVectorTy()) 424dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 4256dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // If the false value simplified to false, then the result of the compare 4266dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // is equal to "Cond && TCmp". This also catches the case when the false 4276dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // value simplified to false and the true value to true, returning "Cond". 4286dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (match(FCmp, m_Zero())) 4290aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyAndInst(Cond, TCmp, Q, MaxRecurse)) 4306dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return V; 4316dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // If the true value simplified to true, then the result of the compare 4326dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // is equal to "Cond || FCmp". 4336dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (match(TCmp, m_One())) 4340aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyOrInst(Cond, FCmp, Q, MaxRecurse)) 4356dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return V; 4366dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // Finally, if the false value simplified to true and the true value to 4376dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands // false, then the result of the compare is equal to "!Cond". 4386dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (match(FCmp, m_One()) && match(TCmp, m_Zero())) 4396dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands if (Value *V = 4406dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands SimplifyXorInst(Cond, Constant::getAllOnesValue(Cond->getType()), 4410aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse)) 4426dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands return V; 4436dc9e2bf7455fa1494078d5d52f1363b05183f20Duncan Sands 444dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 445b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands} 446b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 447de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// In the case of a binary operation with an operand that is a PHI instruction, 448de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// try to simplify the binop by seeing whether evaluating it on the incoming 449de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// phi values yields the same result for every value. If so returns the common 450de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// value, otherwise returns null. 451a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *ThreadBinOpOverPHI(unsigned Opcode, Value *LHS, Value *RHS, 4520aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 4530312a93693abc2eb682b2b101c889959888fd883Duncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 4540312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (!MaxRecurse--) 455dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 4560312a93693abc2eb682b2b101c889959888fd883Duncan Sands 457a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands PHINode *PI; 458a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands if (isa<PHINode>(LHS)) { 459a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands PI = cast<PHINode>(LHS); 4601845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // Bail out if RHS and the phi may be mutually interdependent due to a loop. 4610aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (!ValueDominatesPHI(RHS, PI, Q.DT)) 462dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 463a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands } else { 464a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands assert(isa<PHINode>(RHS) && "No PHI instruction operand!"); 465a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands PI = cast<PHINode>(RHS); 4661845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // Bail out if LHS and the phi may be mutually interdependent due to a loop. 4670aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (!ValueDominatesPHI(LHS, PI, Q.DT)) 468dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 469a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands } 470a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 471a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // Evaluate the BinOp on the incoming phi values. 472dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Value *CommonValue = nullptr; 4736948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar for (Value *Incoming : PI->incoming_values()) { 474ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // If the incoming value is the phi node itself, it can safely be skipped. 475552008946530e01efdad15044e1f621883d14a3aDuncan Sands if (Incoming == PI) continue; 476a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands Value *V = PI == LHS ? 4770aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands SimplifyBinOp(Opcode, Incoming, RHS, Q, MaxRecurse) : 4780aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands SimplifyBinOp(Opcode, LHS, Incoming, Q, MaxRecurse); 479a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the operation failed to simplify, or simplified to a different value 480a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // to previously, then give up. 481a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands if (!V || (CommonValue && V != CommonValue)) 482dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 483a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands CommonValue = V; 484a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands } 485a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 486a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return CommonValue; 487a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 488a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 489de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// In the case of a comparison with a PHI instruction, try to simplify the 490de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// comparison by seeing whether comparing with all of the incoming phi values 491de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// yields the same result every time. If so returns the common result, 492de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// otherwise returns null. 493a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *ThreadCmpOverPHI(CmpInst::Predicate Pred, Value *LHS, Value *RHS, 4940aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 4950312a93693abc2eb682b2b101c889959888fd883Duncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 4960312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (!MaxRecurse--) 497dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 4980312a93693abc2eb682b2b101c889959888fd883Duncan Sands 499a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // Make sure the phi is on the LHS. 500a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands if (!isa<PHINode>(LHS)) { 501a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands std::swap(LHS, RHS); 502a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands Pred = CmpInst::getSwappedPredicate(Pred); 503a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands } 504a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands assert(isa<PHINode>(LHS) && "Not comparing with a phi instruction!"); 505a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands PHINode *PI = cast<PHINode>(LHS); 506a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 5071845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // Bail out if RHS and the phi may be mutually interdependent due to a loop. 5080aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (!ValueDominatesPHI(RHS, PI, Q.DT)) 509dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 5101845009290e4d804ad377927bd8a08cca3036adcDuncan Sands 511a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // Evaluate the BinOp on the incoming phi values. 512dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Value *CommonValue = nullptr; 5136948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar for (Value *Incoming : PI->incoming_values()) { 514ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // If the incoming value is the phi node itself, it can safely be skipped. 515552008946530e01efdad15044e1f621883d14a3aDuncan Sands if (Incoming == PI) continue; 5160aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Value *V = SimplifyCmpInst(Pred, Incoming, RHS, Q, MaxRecurse); 517a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the operation failed to simplify, or simplified to a different value 518a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // to previously, then give up. 519a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands if (!V || (CommonValue && V != CommonValue)) 520dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 521a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands CommonValue = V; 522a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands } 523a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 524a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return CommonValue; 525a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 526a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 527de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Given operands for an Add, see if we can fold the result. 528de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// If not, this returns null. 529ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sandsstatic Value *SimplifyAddInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, 5300aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 531d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 532de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (Constant *CRHS = dyn_cast<Constant>(Op1)) 533de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return ConstantFoldBinaryOpOperands(Instruction::Add, CLHS, CRHS, Q.DL); 53412a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 5358aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner // Canonicalize the constant to the RHS. 5368aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner std::swap(Op0, Op1); 5378aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner } 53812a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 539fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X + undef -> undef 540f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 541fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return Op1; 54212a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 543fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X + 0 -> X 544fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands if (match(Op1, m_Zero())) 545fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return Op0; 546fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 547fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X + (Y - X) -> Y 548fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // (Y - X) + X -> Y 549ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands // Eg: X + -X -> 0 550dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Value *Y = nullptr; 551124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (match(Op1, m_Sub(m_Value(Y), m_Specific(Op0))) || 552124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands match(Op0, m_Sub(m_Value(Y), m_Specific(Op1)))) 553fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return Y; 554fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 555fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X + ~X -> -1 since ~X = -X-1 556124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (match(Op0, m_Not(m_Specific(Op1))) || 557124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands match(Op1, m_Not(m_Specific(Op0)))) 558fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return Constant::getAllOnesValue(Op0->getType()); 55987689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands 56082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands /// i1 add -> xor. 56175d289ed6201e82718343d7a36d2a2fa082f6217Duncan Sands if (MaxRecurse && Op0->getType()->isIntegerTy(1)) 5620aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyXorInst(Op0, Op1, Q, MaxRecurse-1)) 56307f30fbd734069b80b90c6aeea0ae645ce3880c0Duncan Sands return V; 56482fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 565566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Try some generic simplifications for associative operations. 5660aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyAssociativeBinOp(Instruction::Add, Op0, Op1, Q, 567566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands MaxRecurse)) 568566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return V; 569566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 57087689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // Threading Add over selects and phi nodes is pointless, so don't bother. 57187689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // Threading over the select in "A + select(cond, B, C)" means evaluating 57287689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // "A+B" and "A+C" and seeing if they are equal; but they are equal if and 57387689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // only if B and C are equal. If B and C are equal then (since we assume 57487689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // that operands have already been simplified) "select(cond, B, C)" should 57587689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // have been simplified to the common value of B and C already. Analysing 57687689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // "A+B" and "A+C" thus gains nothing, but costs compile time. Similarly 57787689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // for threading over phi nodes. 57887689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands 579dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 5808aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner} 5818aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner 582ee9a2e322af96accc9e55ed6373c0057453714b1Duncan SandsValue *llvm::SimplifyAddInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, 5834c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar const DataLayout &DL, const TargetLibraryInfo *TLI, 584ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const DominatorTree *DT, AssumptionCache *AC, 58537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const Instruction *CxtI) { 586ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return ::SimplifyAddInst(Op0, Op1, isNSW, isNUW, Query(DL, TLI, DT, AC, CxtI), 587ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines RecursionLimit); 588ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands} 589ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands 590fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth/// \brief Compute the base pointer and cumulative constant offsets for V. 591fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth/// 592fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth/// This strips all constant offsets off of V, leaving it the base pointer, and 593fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth/// accumulates the total constant offset applied in the returned constant. It 594fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth/// returns 0 if V is not a pointer, and returns the constant '0' if there are 595fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth/// no constant offsets applied. 596819f9d6bf91c439967ef623d0c047e7f672683faDan Gohman/// 597819f9d6bf91c439967ef623d0c047e7f672683faDan Gohman/// This is very similar to GetPointerBaseWithConstantOffset except it doesn't 598819f9d6bf91c439967ef623d0c047e7f672683faDan Gohman/// follow non-inbounds geps. This allows it to remain usable for icmp ult/etc. 599819f9d6bf91c439967ef623d0c047e7f672683faDan Gohman/// folding. 6004c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainarstatic Constant *stripAndComputeConstantOffsets(const DataLayout &DL, Value *&V, 601baca5334db904819e6c0d26cd5f5203f82c44f6eBenjamin Kramer bool AllowNonInbounds = false) { 602d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramer assert(V->getType()->getScalarType()->isPointerTy()); 603fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth 6044c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar Type *IntPtrTy = DL.getIntPtrType(V->getType())->getScalarType(); 6056b4dde71cfdcb2e1f2105dd8a677c14d8c3bb4b4Matt Arsenault APInt Offset = APInt::getNullValue(IntPtrTy->getIntegerBitWidth()); 606fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth 607fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth // Even though we don't look through PHI nodes, we could be called on an 608fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth // instruction in an unreachable block, which may be on a cycle. 609fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth SmallPtrSet<Value *, 4> Visited; 610fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth Visited.insert(V); 611fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth do { 612fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth if (GEPOperator *GEP = dyn_cast<GEPOperator>(V)) { 613baca5334db904819e6c0d26cd5f5203f82c44f6eBenjamin Kramer if ((!AllowNonInbounds && !GEP->isInBounds()) || 6144c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar !GEP->accumulateConstantOffset(DL, Offset)) 615fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth break; 616fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth V = GEP->getPointerOperand(); 617fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth } else if (Operator::getOpcode(V) == Instruction::BitCast) { 6186b4dde71cfdcb2e1f2105dd8a677c14d8c3bb4b4Matt Arsenault V = cast<Operator>(V)->getOperand(0); 619fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth } else if (GlobalAlias *GA = dyn_cast<GlobalAlias>(V)) { 620de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (GA->isInterposable()) 621fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth break; 622fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth V = GA->getAliasee(); 623fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth } else { 624de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (auto CS = CallSite(V)) 625de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (Value *RV = CS.getReturnedArgOperand()) { 626de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar V = RV; 627de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar continue; 628de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar } 629fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth break; 630fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth } 631d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramer assert(V->getType()->getScalarType()->isPointerTy() && 632d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramer "Unexpected operand type!"); 63337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines } while (Visited.insert(V).second); 634fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth 635d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramer Constant *OffsetIntPtr = ConstantInt::get(IntPtrTy, Offset); 636d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramer if (V->getType()->isVectorTy()) 637d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramer return ConstantVector::getSplat(V->getType()->getVectorNumElements(), 638d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramer OffsetIntPtr); 639d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramer return OffsetIntPtr; 640fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth} 641fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth 642fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth/// \brief Compute the constant difference between two pointer values. 643fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth/// If the difference is not a constant, returns zero. 6444c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainarstatic Constant *computePointerDifference(const DataLayout &DL, Value *LHS, 6454c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar Value *RHS) { 64636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Constant *LHSOffset = stripAndComputeConstantOffsets(DL, LHS); 64736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Constant *RHSOffset = stripAndComputeConstantOffsets(DL, RHS); 648fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth 649fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth // If LHS and RHS are not related via constant offsets to the same base 650fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth // value, there is nothing we can do here. 651fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth if (LHS != RHS) 652dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 653fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth 654fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth // Otherwise, the difference of LHS - RHS can be computed as: 655fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth // LHS - RHS 656fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth // = (LHSOffset + Base) - (RHSOffset + Base) 657fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth // = LHSOffset - RHSOffset 658fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth return ConstantExpr::getSub(LHSOffset, RHSOffset); 659fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth} 660fc72ae613afd7ca2526bb66156bafe8b0054cb3bChandler Carruth 661de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Given operands for a Sub, see if we can fold the result. 662de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// If not, this returns null. 663ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sandsstatic Value *SimplifySubInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, 6640aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 665fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands if (Constant *CLHS = dyn_cast<Constant>(Op0)) 666de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (Constant *CRHS = dyn_cast<Constant>(Op1)) 667de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return ConstantFoldBinaryOpOperands(Instruction::Sub, CLHS, CRHS, Q.DL); 668fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 669fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X - undef -> undef 670fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // undef - X -> undef 671f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op0, m_Undef()) || match(Op1, m_Undef())) 672fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return UndefValue::get(Op0->getType()); 673fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 674fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X - 0 -> X 675fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands if (match(Op1, m_Zero())) 676fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return Op0; 677fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 678fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X - X -> 0 679124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (Op0 == Op1) 680fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return Constant::getNullValue(Op0->getType()); 681fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 682ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // 0 - X -> 0 if the sub is NUW. 683ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (isNUW && match(Op0, m_Zero())) 684ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return Op0; 68537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines 686b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // (X + Y) - Z -> X + (Y - Z) or Y + (X - Z) if everything simplifies. 687b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // For example, (X + Y) - Y -> X; (Y + X) - Y -> X 688c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines Value *X = nullptr, *Y = nullptr, *Z = Op1; 689b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands if (MaxRecurse && match(Op0, m_Add(m_Value(X), m_Value(Y)))) { // (X + Y) - Z 690b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // See if "V === Y - Z" simplifies. 6910aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyBinOp(Instruction::Sub, Y, Z, Q, MaxRecurse-1)) 692b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does! Now see if "X + V" simplifies. 6930aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *W = SimplifyBinOp(Instruction::Add, X, V, Q, MaxRecurse-1)) { 694b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does, we successfully reassociated! 695b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands ++NumReassoc; 696b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands return W; 697b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands } 698b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // See if "V === X - Z" simplifies. 6990aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyBinOp(Instruction::Sub, X, Z, Q, MaxRecurse-1)) 700b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does! Now see if "Y + V" simplifies. 7010aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *W = SimplifyBinOp(Instruction::Add, Y, V, Q, MaxRecurse-1)) { 702b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does, we successfully reassociated! 703b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands ++NumReassoc; 704b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands return W; 705b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands } 706b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands } 70782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 708b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // X - (Y + Z) -> (X - Y) - Z or (X - Z) - Y if everything simplifies. 709b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // For example, X - (X + 1) -> -1 710b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands X = Op0; 711b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands if (MaxRecurse && match(Op1, m_Add(m_Value(Y), m_Value(Z)))) { // X - (Y + Z) 712b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // See if "V === X - Y" simplifies. 7130aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyBinOp(Instruction::Sub, X, Y, Q, MaxRecurse-1)) 714b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does! Now see if "V - Z" simplifies. 7150aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *W = SimplifyBinOp(Instruction::Sub, V, Z, Q, MaxRecurse-1)) { 716b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does, we successfully reassociated! 717b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands ++NumReassoc; 718b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands return W; 719b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands } 720b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // See if "V === X - Z" simplifies. 7210aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyBinOp(Instruction::Sub, X, Z, Q, MaxRecurse-1)) 722b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does! Now see if "V - Y" simplifies. 7230aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *W = SimplifyBinOp(Instruction::Sub, V, Y, Q, MaxRecurse-1)) { 724b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does, we successfully reassociated! 725b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands ++NumReassoc; 726b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands return W; 727b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands } 728b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands } 729b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands 730b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // Z - (X - Y) -> (Z - X) + Y if everything simplifies. 731b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // For example, X - (X - Y) -> Y. 732b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands Z = Op0; 733c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands if (MaxRecurse && match(Op1, m_Sub(m_Value(X), m_Value(Y)))) // Z - (X - Y) 734c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands // See if "V === Z - X" simplifies. 7350aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyBinOp(Instruction::Sub, Z, X, Q, MaxRecurse-1)) 736b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does! Now see if "V + Y" simplifies. 7370aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *W = SimplifyBinOp(Instruction::Add, V, Y, Q, MaxRecurse-1)) { 738c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands // It does, we successfully reassociated! 739c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands ++NumReassoc; 740c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands return W; 741c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands } 742c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands 743bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands // trunc(X) - trunc(Y) -> trunc(X - Y) if everything simplifies. 744bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands if (MaxRecurse && match(Op0, m_Trunc(m_Value(X))) && 745bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands match(Op1, m_Trunc(m_Value(Y)))) 746bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands if (X->getType() == Y->getType()) 747bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands // See if "V === X - Y" simplifies. 748bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands if (Value *V = SimplifyBinOp(Instruction::Sub, X, Y, Q, MaxRecurse-1)) 749bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands // It does! Now see if "trunc V" simplifies. 750bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands if (Value *W = SimplifyTruncInst(V, Op0->getType(), Q, MaxRecurse-1)) 751bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands // It does, return the simplified "trunc V". 752bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands return W; 753bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands 754bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands // Variations on GEP(base, I, ...) - GEP(base, i, ...) -> GEP(null, I-i, ...). 7553e3de565e9c7258fb97773b3a64fc091355cb2deDan Gohman if (match(Op0, m_PtrToInt(m_Value(X))) && 756bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands match(Op1, m_PtrToInt(m_Value(Y)))) 75736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (Constant *Result = computePointerDifference(Q.DL, X, Y)) 758bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands return ConstantExpr::getIntegerCast(Result, Op0->getType(), true); 759bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands 760b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // i1 sub -> xor. 761b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands if (MaxRecurse && Op0->getType()->isIntegerTy(1)) 7620aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyXorInst(Op0, Op1, Q, MaxRecurse-1)) 763b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands return V; 764b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands 765fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // Threading Sub over selects and phi nodes is pointless, so don't bother. 766fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // Threading over the select in "A - select(cond, B, C)" means evaluating 767fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // "A-B" and "A-C" and seeing if they are equal; but they are equal if and 768fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // only if B and C are equal. If B and C are equal then (since we assume 769fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // that operands have already been simplified) "select(cond, B, C)" should 770fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // have been simplified to the common value of B and C already. Analysing 771fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // "A-B" and "A-C" thus gains nothing, but costs compile time. Similarly 772fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // for threading over phi nodes. 773fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 774dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 775fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands} 776fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 777ee9a2e322af96accc9e55ed6373c0057453714b1Duncan SandsValue *llvm::SimplifySubInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, 7784c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar const DataLayout &DL, const TargetLibraryInfo *TLI, 779ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const DominatorTree *DT, AssumptionCache *AC, 78037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const Instruction *CxtI) { 781ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return ::SimplifySubInst(Op0, Op1, isNSW, isNUW, Query(DL, TLI, DT, AC, CxtI), 782ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines RecursionLimit); 783ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands} 784ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands 78509ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman/// Given operands for an FAdd, see if we can fold the result. If not, this 78609ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman/// returns null. 78709ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilsemanstatic Value *SimplifyFAddInst(Value *Op0, Value *Op1, FastMathFlags FMF, 78809ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman const Query &Q, unsigned MaxRecurse) { 78909ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 790de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (Constant *CRHS = dyn_cast<Constant>(Op1)) 791de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return ConstantFoldBinaryOpOperands(Instruction::FAdd, CLHS, CRHS, Q.DL); 79209ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 79309ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman // Canonicalize the constant to the RHS. 79409ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman std::swap(Op0, Op1); 79509ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman } 79609ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 79709ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman // fadd X, -0 ==> X 79809ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if (match(Op1, m_NegZero())) 79909ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman return Op0; 80009ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 80109ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman // fadd X, 0 ==> X, when we know X is not -0 80209ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if (match(Op1, m_Zero()) && 803de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar (FMF.noSignedZeros() || CannotBeNegativeZero(Op0, Q.TLI))) 80409ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman return Op0; 80509ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 80609ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman // fadd [nnan ninf] X, (fsub [nnan ninf] 0, X) ==> 0 80709ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman // where nnan and ninf have to occur at least once somewhere in this 80809ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman // expression 809dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Value *SubOp = nullptr; 81009ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if (match(Op1, m_FSub(m_AnyZero(), m_Specific(Op0)))) 81109ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman SubOp = Op1; 81209ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman else if (match(Op0, m_FSub(m_AnyZero(), m_Specific(Op1)))) 81309ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman SubOp = Op0; 81409ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if (SubOp) { 81509ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman Instruction *FSub = cast<Instruction>(SubOp); 81609ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if ((FMF.noNaNs() || FSub->hasNoNaNs()) && 81709ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman (FMF.noInfs() || FSub->hasNoInfs())) 81809ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman return Constant::getNullValue(Op0->getType()); 81909ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman } 82009ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 821dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 82209ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman} 82309ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 82409ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman/// Given operands for an FSub, see if we can fold the result. If not, this 82509ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman/// returns null. 82609ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilsemanstatic Value *SimplifyFSubInst(Value *Op0, Value *Op1, FastMathFlags FMF, 82709ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman const Query &Q, unsigned MaxRecurse) { 82809ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 829de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (Constant *CRHS = dyn_cast<Constant>(Op1)) 830de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return ConstantFoldBinaryOpOperands(Instruction::FSub, CLHS, CRHS, Q.DL); 83109ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman } 83209ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 83309ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman // fsub X, 0 ==> X 83409ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if (match(Op1, m_Zero())) 83509ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman return Op0; 83609ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 83709ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman // fsub X, -0 ==> X, when we know X is not -0 83809ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if (match(Op1, m_NegZero()) && 839de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar (FMF.noSignedZeros() || CannotBeNegativeZero(Op0, Q.TLI))) 84009ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman return Op0; 84109ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 842de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar // fsub -0.0, (fsub -0.0, X) ==> X 84309ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman Value *X; 844de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (match(Op0, m_NegZero()) && match(Op1, m_FSub(m_NegZero(), m_Value(X)))) 845de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return X; 846de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar 847de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar // fsub 0.0, (fsub 0.0, X) ==> X if signed zeros are ignored. 848de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (FMF.noSignedZeros() && match(Op0, m_AnyZero()) && 849de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar match(Op1, m_FSub(m_AnyZero(), m_Value(X)))) 850de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return X; 85109ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 8526948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar // fsub nnan x, x ==> 0.0 8536948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (FMF.noNaNs() && Op0 == Op1) 85409ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman return Constant::getNullValue(Op0->getType()); 85509ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 856dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 85709ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman} 85809ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 859eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman/// Given the operands for an FMul, see if we can fold the result 860eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilsemanstatic Value *SimplifyFMulInst(Value *Op0, Value *Op1, 861eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman FastMathFlags FMF, 862eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman const Query &Q, 863eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman unsigned MaxRecurse) { 864eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 865de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (Constant *CRHS = dyn_cast<Constant>(Op1)) 866de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return ConstantFoldBinaryOpOperands(Instruction::FMul, CLHS, CRHS, Q.DL); 867eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman 86809ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman // Canonicalize the constant to the RHS. 86909ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman std::swap(Op0, Op1); 870eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman } 871eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman 87209ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman // fmul X, 1.0 ==> X 87309ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if (match(Op1, m_FPOne())) 87409ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman return Op0; 87509ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 87609ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman // fmul nnan nsz X, 0 ==> 0 87709ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman if (FMF.noNaNs() && FMF.noSignedZeros() && match(Op1, m_AnyZero())) 87809ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman return Op1; 87909ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 880dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 881eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman} 882eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman 883de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Given operands for a Mul, see if we can fold the result. 884de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// If not, this returns null. 8850aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyMulInst(Value *Op0, Value *Op1, const Query &Q, 8860aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands unsigned MaxRecurse) { 88782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 888de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (Constant *CRHS = dyn_cast<Constant>(Op1)) 889de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return ConstantFoldBinaryOpOperands(Instruction::Mul, CLHS, CRHS, Q.DL); 89082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 89182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // Canonicalize the constant to the RHS. 89282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands std::swap(Op0, Op1); 89382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands } 89482fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 89582fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // X * undef -> 0 896f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 89782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return Constant::getNullValue(Op0->getType()); 89882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 89982fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // X * 0 -> 0 90082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (match(Op1, m_Zero())) 90182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return Op1; 90282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 90382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // X * 1 -> X 90482fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (match(Op1, m_One())) 90582fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return Op0; 90682fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 9071895e98ef38afbe011575cc25f4889d96e37421bDuncan Sands // (X / Y) * Y -> X if the division is exact. 908dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Value *X = nullptr; 90955c6d57734cd2f141dc2d6912fc22746d5eeae54Benjamin Kramer if (match(Op0, m_Exact(m_IDiv(m_Value(X), m_Specific(Op1)))) || // (X / Y) * Y 91055c6d57734cd2f141dc2d6912fc22746d5eeae54Benjamin Kramer match(Op1, m_Exact(m_IDiv(m_Value(X), m_Specific(Op0))))) // Y * (X / Y) 91155c6d57734cd2f141dc2d6912fc22746d5eeae54Benjamin Kramer return X; 9121895e98ef38afbe011575cc25f4889d96e37421bDuncan Sands 9135413880654585f01ea9880f24f07f27c8da56ba8Nick Lewycky // i1 mul -> and. 91475d289ed6201e82718343d7a36d2a2fa082f6217Duncan Sands if (MaxRecurse && Op0->getType()->isIntegerTy(1)) 9150aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyAndInst(Op0, Op1, Q, MaxRecurse-1)) 91607f30fbd734069b80b90c6aeea0ae645ce3880c0Duncan Sands return V; 91782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 91882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // Try some generic simplifications for associative operations. 9190aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyAssociativeBinOp(Instruction::Mul, Op0, Op1, Q, 92082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands MaxRecurse)) 92182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return V; 92282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 92382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // Mul distributes over Add. Try some generic simplifications based on this. 92482fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (Value *V = ExpandBinOp(Instruction::Mul, Op0, Op1, Instruction::Add, 9250aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse)) 92682fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return V; 92782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 92882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // If the operation is with the result of a select instruction, check whether 92982fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // operating on either branch of the select always yields the same value. 93082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) 9310aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadBinOpOverSelect(Instruction::Mul, Op0, Op1, Q, 93282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands MaxRecurse)) 93382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return V; 93482fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 93582fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // If the operation is with the result of a phi instruction, check whether 93682fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // operating on all incoming values of the phi always yields the same value. 93782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (isa<PHINode>(Op0) || isa<PHINode>(Op1)) 9380aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadBinOpOverPHI(Instruction::Mul, Op0, Op1, Q, 93982fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands MaxRecurse)) 94082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return V; 94182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 942dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 94382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands} 94482fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 94509ee250e728ccdb7afc6354d777f8319c5a0465cMichael IlsemanValue *llvm::SimplifyFAddInst(Value *Op0, Value *Op1, FastMathFlags FMF, 9464c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar const DataLayout &DL, 947ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const TargetLibraryInfo *TLI, 948ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const DominatorTree *DT, AssumptionCache *AC, 949ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const Instruction *CxtI) { 950ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return ::SimplifyFAddInst(Op0, Op1, FMF, Query(DL, TLI, DT, AC, CxtI), 95137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines RecursionLimit); 95209ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman} 95309ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 95409ee250e728ccdb7afc6354d777f8319c5a0465cMichael IlsemanValue *llvm::SimplifyFSubInst(Value *Op0, Value *Op1, FastMathFlags FMF, 9554c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar const DataLayout &DL, 956ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const TargetLibraryInfo *TLI, 957ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const DominatorTree *DT, AssumptionCache *AC, 958ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const Instruction *CxtI) { 959ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return ::SimplifyFSubInst(Op0, Op1, FMF, Query(DL, TLI, DT, AC, CxtI), 96037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines RecursionLimit); 96109ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman} 96209ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman 963ebe69fe11e48d322045d5949c83283927a0d790bStephen HinesValue *llvm::SimplifyFMulInst(Value *Op0, Value *Op1, FastMathFlags FMF, 9644c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar const DataLayout &DL, 965eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman const TargetLibraryInfo *TLI, 966ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const DominatorTree *DT, AssumptionCache *AC, 96737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const Instruction *CxtI) { 968ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return ::SimplifyFMulInst(Op0, Op1, FMF, Query(DL, TLI, DT, AC, CxtI), 96937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines RecursionLimit); 970eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman} 971eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman 9724c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga NainarValue *llvm::SimplifyMulInst(Value *Op0, Value *Op1, const DataLayout &DL, 973618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 974ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const DominatorTree *DT, AssumptionCache *AC, 97537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const Instruction *CxtI) { 976ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return ::SimplifyMulInst(Op0, Op1, Query(DL, TLI, DT, AC, CxtI), 97737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines RecursionLimit); 97882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands} 97982fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 980de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Given operands for an SDiv or UDiv, see if we can fold the result. 981de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// If not, this returns null. 982479b4b9ef06dd84097202ffa6aea07913cdf651cAnders Carlssonstatic Value *SimplifyDiv(Instruction::BinaryOps Opcode, Value *Op0, Value *Op1, 9830aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 984de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (Constant *C0 = dyn_cast<Constant>(Op0)) 985de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (Constant *C1 = dyn_cast<Constant>(Op1)) 986de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return ConstantFoldBinaryOpOperands(Opcode, C0, C1, Q.DL); 987593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 988a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands bool isSigned = Opcode == Instruction::SDiv; 989a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands 990593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // X / undef -> undef 991f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 992593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return Op1; 993593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 994ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // X / 0 -> undef, we don't need to preserve faults! 995ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (match(Op1, m_Zero())) 996ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return UndefValue::get(Op1->getType()); 997ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 998593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // undef / X -> 0 999f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op0, m_Undef())) 1000593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return Constant::getNullValue(Op0->getType()); 1001593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1002593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // 0 / X -> 0, we don't need to preserve faults! 1003593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (match(Op0, m_Zero())) 1004593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return Op0; 1005593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1006593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // X / 1 -> X 1007593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (match(Op1, m_One())) 1008593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return Op0; 1009593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1010593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Op0->getType()->isIntegerTy(1)) 1011593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // It can't be division by zero, hence it must be division by one. 1012593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return Op0; 1013593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1014593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // X / X -> 1 1015593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Op0 == Op1) 1016593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return ConstantInt::get(Op0->getType(), 1); 1017593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1018593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // (X * Y) / Y -> X if the multiplication does not overflow. 1019dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Value *X = nullptr, *Y = nullptr; 1020593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (match(Op0, m_Mul(m_Value(X), m_Value(Y))) && (X == Op1 || Y == Op1)) { 1021593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Y != Op1) std::swap(X, Y); // Ensure expression is (X * Y) / Y, Y = Op1 102232a43cc0fc3cd42702d7859eaa58dd42f561a54dDuncan Sands OverflowingBinaryOperator *Mul = cast<OverflowingBinaryOperator>(Op0); 10234b720718fbda1194f925e0a9d931bc220e8b0e3aDuncan Sands // If the Mul knows it does not overflow, then we are good to go. 10244b720718fbda1194f925e0a9d931bc220e8b0e3aDuncan Sands if ((isSigned && Mul->hasNoSignedWrap()) || 10254b720718fbda1194f925e0a9d931bc220e8b0e3aDuncan Sands (!isSigned && Mul->hasNoUnsignedWrap())) 10264b720718fbda1194f925e0a9d931bc220e8b0e3aDuncan Sands return X; 1027593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // If X has the form X = A / Y then X * Y cannot overflow. 1028593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (BinaryOperator *Div = dyn_cast<BinaryOperator>(X)) 1029593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Div->getOpcode() == Opcode && Div->getOperand(1) == Y) 1030593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return X; 1031593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands } 1032593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1033a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands // (X rem Y) / Y -> 0 1034a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands if ((isSigned && match(Op0, m_SRem(m_Value(), m_Specific(Op1)))) || 1035a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands (!isSigned && match(Op0, m_URem(m_Value(), m_Specific(Op1))))) 1036a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands return Constant::getNullValue(Op0->getType()); 1037a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands 103837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // (X /u C1) /u C2 -> 0 if C1 * C2 overflow 103937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines ConstantInt *C1, *C2; 104037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (!isSigned && match(Op0, m_UDiv(m_Value(X), m_ConstantInt(C1))) && 104137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines match(Op1, m_ConstantInt(C2))) { 104237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines bool Overflow; 104337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines C1->getValue().umul_ov(C2->getValue(), Overflow); 104437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Overflow) 104537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return Constant::getNullValue(Op0->getType()); 104637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines } 104737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines 1048a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands // If the operation is with the result of a select instruction, check whether 1049a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands // operating on either branch of the select always yields the same value. 1050a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) 10510aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadBinOpOverSelect(Opcode, Op0, Op1, Q, MaxRecurse)) 1052a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands return V; 1053a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands 1054a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands // If the operation is with the result of a phi instruction, check whether 1055a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands // operating on all incoming values of the phi always yields the same value. 1056a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands if (isa<PHINode>(Op0) || isa<PHINode>(Op1)) 10570aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadBinOpOverPHI(Opcode, Op0, Op1, Q, MaxRecurse)) 1058a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands return V; 1059a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands 1060dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 1061593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands} 1062593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1063de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Given operands for an SDiv, see if we can fold the result. 1064de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// If not, this returns null. 10650aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifySDivInst(Value *Op0, Value *Op1, const Query &Q, 10660aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands unsigned MaxRecurse) { 10670aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyDiv(Instruction::SDiv, Op0, Op1, Q, MaxRecurse)) 1068593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return V; 1069593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1070dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 1071593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands} 1072593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 10734c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga NainarValue *llvm::SimplifySDivInst(Value *Op0, Value *Op1, const DataLayout &DL, 1074618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1075ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const DominatorTree *DT, AssumptionCache *AC, 107637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const Instruction *CxtI) { 1077ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return ::SimplifySDivInst(Op0, Op1, Query(DL, TLI, DT, AC, CxtI), 107837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines RecursionLimit); 1079593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands} 1080593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1081de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Given operands for a UDiv, see if we can fold the result. 1082de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// If not, this returns null. 10830aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyUDivInst(Value *Op0, Value *Op1, const Query &Q, 10840aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands unsigned MaxRecurse) { 10850aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyDiv(Instruction::UDiv, Op0, Op1, Q, MaxRecurse)) 1086593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return V; 1087593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1088dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 1089593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands} 1090593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 10914c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga NainarValue *llvm::SimplifyUDivInst(Value *Op0, Value *Op1, const DataLayout &DL, 1092618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1093ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const DominatorTree *DT, AssumptionCache *AC, 109437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const Instruction *CxtI) { 1095ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return ::SimplifyUDivInst(Op0, Op1, Query(DL, TLI, DT, AC, CxtI), 109637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines RecursionLimit); 1097593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands} 1098593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 1099ebe69fe11e48d322045d5949c83283927a0d790bStephen Hinesstatic Value *SimplifyFDivInst(Value *Op0, Value *Op1, FastMathFlags FMF, 1100ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const Query &Q, unsigned) { 11011fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel // undef / X -> undef (the undef could be a snan). 1102f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op0, m_Undef())) 11031fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel return Op0; 11041fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel 11051fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel // X / undef -> undef 1106f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 11071fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel return Op1; 11081fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel 1109ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // 0 / X -> 0 1110ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // Requires that NaNs are off (X could be zero) and signed zeroes are 1111ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // ignored (X could be positive or negative, so the output sign is unknown). 1112ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (FMF.noNaNs() && FMF.noSignedZeros() && match(Op0, m_AnyZero())) 1113ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return Op0; 1114ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 1115f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar if (FMF.noNaNs()) { 1116f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar // X / X -> 1.0 is legal when NaNs are ignored. 11176948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (Op0 == Op1) 11186948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar return ConstantFP::get(Op0->getType(), 1.0); 11196948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar 11206948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar // -X / X -> -1.0 and 1121f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar // X / -X -> -1.0 are legal when NaNs are ignored. 11226948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar // We can ignore signed zeros because +-0.0/+-0.0 is NaN and ignored. 11236948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if ((BinaryOperator::isFNeg(Op0, /*IgnoreZeroSign=*/true) && 11246948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar BinaryOperator::getFNegArgument(Op0) == Op1) || 11256948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar (BinaryOperator::isFNeg(Op1, /*IgnoreZeroSign=*/true) && 11266948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar BinaryOperator::getFNegArgument(Op1) == Op0)) 11276948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar return ConstantFP::get(Op0->getType(), -1.0); 11286948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar } 11296948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar 1130dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 11311fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel} 11321fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel 1133ebe69fe11e48d322045d5949c83283927a0d790bStephen HinesValue *llvm::SimplifyFDivInst(Value *Op0, Value *Op1, FastMathFlags FMF, 11344c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar const DataLayout &DL, 1135618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1136ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const DominatorTree *DT, AssumptionCache *AC, 113737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const Instruction *CxtI) { 1138ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return ::SimplifyFDivInst(Op0, Op1, FMF, Query(DL, TLI, DT, AC, CxtI), 113937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines RecursionLimit); 11401fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel} 11411fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel 1142de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Given operands for an SRem or URem, see if we can fold the result. 1143de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// If not, this returns null. 1144f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sandsstatic Value *SimplifyRem(Instruction::BinaryOps Opcode, Value *Op0, Value *Op1, 11450aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 1146de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (Constant *C0 = dyn_cast<Constant>(Op0)) 1147de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (Constant *C1 = dyn_cast<Constant>(Op1)) 1148de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return ConstantFoldBinaryOpOperands(Opcode, C0, C1, Q.DL); 1149f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1150f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // X % undef -> undef 1151f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op1, m_Undef())) 1152f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Op1; 1153f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1154f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // undef % X -> 0 1155f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op0, m_Undef())) 1156f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Constant::getNullValue(Op0->getType()); 1157f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1158f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // 0 % X -> 0, we don't need to preserve faults! 1159f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op0, m_Zero())) 1160f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Op0; 1161f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1162f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // X % 0 -> undef, we don't need to preserve faults! 1163f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op1, m_Zero())) 1164f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return UndefValue::get(Op0->getType()); 1165f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1166f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // X % 1 -> 0 1167f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op1, m_One())) 1168f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Constant::getNullValue(Op0->getType()); 1169f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1170f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (Op0->getType()->isIntegerTy(1)) 1171f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // It can't be remainder by zero, hence it must be remainder by one. 1172f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Constant::getNullValue(Op0->getType()); 1173f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1174f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // X % X -> 0 1175f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (Op0 == Op1) 1176f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Constant::getNullValue(Op0->getType()); 1177f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 117837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // (X % Y) % Y -> X % Y 117937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if ((Opcode == Instruction::SRem && 118037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines match(Op0, m_SRem(m_Value(), m_Specific(Op1)))) || 118137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines (Opcode == Instruction::URem && 118237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines match(Op0, m_URem(m_Value(), m_Specific(Op1))))) 118337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return Op0; 118437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines 1185f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // If the operation is with the result of a select instruction, check whether 1186f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // operating on either branch of the select always yields the same value. 1187f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) 11880aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadBinOpOverSelect(Opcode, Op0, Op1, Q, MaxRecurse)) 1189f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return V; 1190f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1191f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // If the operation is with the result of a phi instruction, check whether 1192f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // operating on all incoming values of the phi always yields the same value. 1193f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (isa<PHINode>(Op0) || isa<PHINode>(Op1)) 11940aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadBinOpOverPHI(Opcode, Op0, Op1, Q, MaxRecurse)) 1195f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return V; 1196f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1197dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 1198f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1199f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1200de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Given operands for an SRem, see if we can fold the result. 1201de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// If not, this returns null. 12020aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifySRemInst(Value *Op0, Value *Op1, const Query &Q, 12030aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands unsigned MaxRecurse) { 12040aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyRem(Instruction::SRem, Op0, Op1, Q, MaxRecurse)) 1205f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return V; 1206f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1207dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 1208f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1209f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 12104c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga NainarValue *llvm::SimplifySRemInst(Value *Op0, Value *Op1, const DataLayout &DL, 1211618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1212ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const DominatorTree *DT, AssumptionCache *AC, 121337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const Instruction *CxtI) { 1214ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return ::SimplifySRemInst(Op0, Op1, Query(DL, TLI, DT, AC, CxtI), 121537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines RecursionLimit); 1216f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1217f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1218de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Given operands for a URem, see if we can fold the result. 1219de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// If not, this returns null. 12200aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyURemInst(Value *Op0, Value *Op1, const Query &Q, 1221618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier unsigned MaxRecurse) { 12220aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyRem(Instruction::URem, Op0, Op1, Q, MaxRecurse)) 1223f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return V; 1224f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1225dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 1226f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1227f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 12284c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga NainarValue *llvm::SimplifyURemInst(Value *Op0, Value *Op1, const DataLayout &DL, 1229618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1230ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const DominatorTree *DT, AssumptionCache *AC, 123137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const Instruction *CxtI) { 1232ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return ::SimplifyURemInst(Op0, Op1, Query(DL, TLI, DT, AC, CxtI), 123337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines RecursionLimit); 1234f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1235f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1236ebe69fe11e48d322045d5949c83283927a0d790bStephen Hinesstatic Value *SimplifyFRemInst(Value *Op0, Value *Op1, FastMathFlags FMF, 1237ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const Query &, unsigned) { 1238f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // undef % X -> undef (the undef could be a snan). 1239f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op0, m_Undef())) 1240f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Op0; 1241f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1242f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // X % undef -> undef 1243f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op1, m_Undef())) 1244f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Op1; 1245f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1246ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // 0 % X -> 0 1247ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // Requires that NaNs are off (X could be zero) and signed zeroes are 1248ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // ignored (X could be positive or negative, so the output sign is unknown). 1249ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (FMF.noNaNs() && FMF.noSignedZeros() && match(Op0, m_AnyZero())) 1250ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return Op0; 1251ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 1252dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 1253f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1254f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1255ebe69fe11e48d322045d5949c83283927a0d790bStephen HinesValue *llvm::SimplifyFRemInst(Value *Op0, Value *Op1, FastMathFlags FMF, 12564c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar const DataLayout &DL, 1257618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1258ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const DominatorTree *DT, AssumptionCache *AC, 125937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const Instruction *CxtI) { 1260ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return ::SimplifyFRemInst(Op0, Op1, FMF, Query(DL, TLI, DT, AC, CxtI), 126137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines RecursionLimit); 126236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines} 126336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 1264de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Returns true if a shift by \c Amount always yields undef. 126536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hinesstatic bool isUndefShift(Value *Amount) { 126636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Constant *C = dyn_cast<Constant>(Amount); 126736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (!C) 126836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return false; 126936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 127036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // X shift by undef -> undef because it may shift by the bitwidth. 127136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (isa<UndefValue>(C)) 127236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return true; 127336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 127436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // Shifting by the bitwidth or more is undefined. 127536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (ConstantInt *CI = dyn_cast<ConstantInt>(C)) 127636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (CI->getValue().getLimitedValue() >= 127736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines CI->getType()->getScalarSizeInBits()) 127836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return true; 127936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 128036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // If all lanes of a vector shift are undefined the whole shift is. 128136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (isa<ConstantVector>(C) || isa<ConstantDataVector>(C)) { 128236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines for (unsigned I = 0, E = C->getType()->getVectorNumElements(); I != E; ++I) 128336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (!isUndefShift(C->getAggregateElement(I))) 128436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return false; 128536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return true; 128636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } 128736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 128836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return false; 1289f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1290f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1291de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Given operands for an Shl, LShr or AShr, see if we can fold the result. 1292de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// If not, this returns null. 1293cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sandsstatic Value *SimplifyShift(unsigned Opcode, Value *Op0, Value *Op1, 12940aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 1295de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (Constant *C0 = dyn_cast<Constant>(Op0)) 1296de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (Constant *C1 = dyn_cast<Constant>(Op1)) 1297de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return ConstantFoldBinaryOpOperands(Opcode, C0, C1, Q.DL); 1298c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1299cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // 0 shift by X -> 0 1300c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands if (match(Op0, m_Zero())) 1301c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return Op0; 1302c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1303cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // X shift by 0 -> X 1304c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands if (match(Op1, m_Zero())) 1305c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return Op0; 1306c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 130736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // Fold undefined shifts. 130836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (isUndefShift(Op1)) 130936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return UndefValue::get(Op0->getType()); 1310c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1311cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // If the operation is with the result of a select instruction, check whether 1312cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // operating on either branch of the select always yields the same value. 1313cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) 13140aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadBinOpOverSelect(Opcode, Op0, Op1, Q, MaxRecurse)) 1315cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return V; 1316cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands 1317cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // If the operation is with the result of a phi instruction, check whether 1318cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // operating on all incoming values of the phi always yields the same value. 1319cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands if (isa<PHINode>(Op0) || isa<PHINode>(Op1)) 13200aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadBinOpOverPHI(Opcode, Op0, Op1, Q, MaxRecurse)) 1321cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return V; 1322cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands 1323de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar // If any bits in the shift amount make that value greater than or equal to 1324de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar // the number of bits in the type, the shift is undefined. 1325de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar unsigned BitWidth = Op1->getType()->getScalarSizeInBits(); 1326de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar APInt KnownZero(BitWidth, 0); 1327de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar APInt KnownOne(BitWidth, 0); 1328de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar computeKnownBits(Op1, KnownZero, KnownOne, Q.DL, 0, Q.AC, Q.CxtI, Q.DT); 1329de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (KnownOne.getLimitedValue() >= BitWidth) 1330de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return UndefValue::get(Op0->getType()); 1331de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar 1332de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar // If all valid bits in the shift amount are known zero, the first operand is 1333de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar // unchanged. 1334de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar unsigned NumValidShiftBits = Log2_32_Ceil(BitWidth); 1335de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar APInt ShiftAmountMask = APInt::getLowBitsSet(BitWidth, NumValidShiftBits); 1336de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if ((KnownZero & ShiftAmountMask) == ShiftAmountMask) 1337de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return Op0; 1338de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar 1339dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 1340cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands} 1341cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands 134237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines/// \brief Given operands for an Shl, LShr or AShr, see if we can 134337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines/// fold the result. If not, this returns null. 134437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hinesstatic Value *SimplifyRightShift(unsigned Opcode, Value *Op0, Value *Op1, 134537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines bool isExact, const Query &Q, 134637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines unsigned MaxRecurse) { 134737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Value *V = SimplifyShift(Opcode, Op0, Op1, Q, MaxRecurse)) 134837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return V; 134937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines 135037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // X >> X -> 0 135137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Op0 == Op1) 135237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return Constant::getNullValue(Op0->getType()); 135337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines 1354ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // undef >> X -> 0 1355ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // undef >> X -> undef (if it's exact) 1356ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (match(Op0, m_Undef())) 1357ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return isExact ? Op0 : Constant::getNullValue(Op0->getType()); 1358ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 135937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // The low bit cannot be shifted out of an exact shift if it is set. 136037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (isExact) { 136137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines unsigned BitWidth = Op0->getType()->getScalarSizeInBits(); 136237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines APInt Op0KnownZero(BitWidth, 0); 136337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines APInt Op0KnownOne(BitWidth, 0); 1364ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines computeKnownBits(Op0, Op0KnownZero, Op0KnownOne, Q.DL, /*Depth=*/0, Q.AC, 1365ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines Q.CxtI, Q.DT); 136637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Op0KnownOne[0]) 136737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return Op0; 136837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines } 136937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines 137037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return nullptr; 137137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines} 137237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines 1373de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Given operands for an Shl, see if we can fold the result. 1374de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// If not, this returns null. 137581a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattnerstatic Value *SimplifyShlInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, 13760aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 13770aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyShift(Instruction::Shl, Op0, Op1, Q, MaxRecurse)) 1378cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return V; 1379cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands 1380cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // undef << X -> 0 1381ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // undef << X -> undef if (if it's NSW/NUW) 1382f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op0, m_Undef())) 1383ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return isNSW || isNUW ? Op0 : Constant::getNullValue(Op0->getType()); 1384cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands 138581a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner // (X >> A) << A -> X 138681a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Value *X; 138755c6d57734cd2f141dc2d6912fc22746d5eeae54Benjamin Kramer if (match(Op0, m_Exact(m_Shr(m_Value(X), m_Specific(Op1))))) 138881a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner return X; 1389dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 1390c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands} 1391c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 139281a0dc911586c77421c2255aa417dc9b350b9e20Chris LattnerValue *llvm::SimplifyShlInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, 13934c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar const DataLayout &DL, const TargetLibraryInfo *TLI, 1394ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const DominatorTree *DT, AssumptionCache *AC, 139537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const Instruction *CxtI) { 1396ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return ::SimplifyShlInst(Op0, Op1, isNSW, isNUW, Query(DL, TLI, DT, AC, CxtI), 13970aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands RecursionLimit); 1398c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands} 1399c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1400de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Given operands for an LShr, see if we can fold the result. 1401de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// If not, this returns null. 140281a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattnerstatic Value *SimplifyLShrInst(Value *Op0, Value *Op1, bool isExact, 14030aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 140437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Value *V = SimplifyRightShift(Instruction::LShr, Op0, Op1, isExact, Q, 140537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines MaxRecurse)) 140637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return V; 14078c5c6f0e090f91b6555cdd9d2eea238fff3befe6David Majnemer 140881a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner // (X << A) >> A -> X 140981a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Value *X; 141037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (match(Op0, m_NUWShl(m_Value(X), m_Specific(Op1)))) 141181a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner return X; 141252fb846578714d14bbde9b28884a6a8729217677Duncan Sands 1413dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 1414c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands} 1415c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 141681a0dc911586c77421c2255aa417dc9b350b9e20Chris LattnerValue *llvm::SimplifyLShrInst(Value *Op0, Value *Op1, bool isExact, 14174c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar const DataLayout &DL, 1418618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1419ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const DominatorTree *DT, AssumptionCache *AC, 142037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const Instruction *CxtI) { 1421ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return ::SimplifyLShrInst(Op0, Op1, isExact, Query(DL, TLI, DT, AC, CxtI), 14220aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands RecursionLimit); 1423c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands} 1424c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1425de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Given operands for an AShr, see if we can fold the result. 1426de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// If not, this returns null. 142781a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattnerstatic Value *SimplifyAShrInst(Value *Op0, Value *Op1, bool isExact, 14280aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 142937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Value *V = SimplifyRightShift(Instruction::AShr, Op0, Op1, isExact, Q, 143037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines MaxRecurse)) 1431cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return V; 1432c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1433c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands // all ones >>a X -> all ones 1434c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands if (match(Op0, m_AllOnes())) 1435c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return Op0; 1436c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 143781a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner // (X << A) >> A -> X 143881a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Value *X; 143937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (match(Op0, m_NSWShl(m_Value(X), m_Specific(Op1)))) 144081a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner return X; 144152fb846578714d14bbde9b28884a6a8729217677Duncan Sands 144237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // Arithmetic shifting an all-sign-bit value is a no-op. 1443ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines unsigned NumSignBits = ComputeNumSignBits(Op0, Q.DL, 0, Q.AC, Q.CxtI, Q.DT); 144437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (NumSignBits == Op0->getType()->getScalarSizeInBits()) 144537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return Op0; 144637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines 1447dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 1448c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands} 1449c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 145081a0dc911586c77421c2255aa417dc9b350b9e20Chris LattnerValue *llvm::SimplifyAShrInst(Value *Op0, Value *Op1, bool isExact, 14514c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar const DataLayout &DL, 1452618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1453ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const DominatorTree *DT, AssumptionCache *AC, 145437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const Instruction *CxtI) { 1455ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return ::SimplifyAShrInst(Op0, Op1, isExact, Query(DL, TLI, DT, AC, CxtI), 14560aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands RecursionLimit); 1457c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands} 1458c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1459ebe69fe11e48d322045d5949c83283927a0d790bStephen Hinesstatic Value *simplifyUnsignedRangeCheck(ICmpInst *ZeroICmp, 1460ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines ICmpInst *UnsignedICmp, bool IsAnd) { 1461ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines Value *X, *Y; 1462ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 1463ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines ICmpInst::Predicate EqPred; 1464ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (!match(ZeroICmp, m_ICmp(EqPred, m_Value(Y), m_Zero())) || 1465ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines !ICmpInst::isEquality(EqPred)) 1466ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return nullptr; 1467ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 1468ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines ICmpInst::Predicate UnsignedPred; 1469ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (match(UnsignedICmp, m_ICmp(UnsignedPred, m_Value(X), m_Specific(Y))) && 1470ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines ICmpInst::isUnsigned(UnsignedPred)) 1471ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines ; 1472ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines else if (match(UnsignedICmp, 1473ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines m_ICmp(UnsignedPred, m_Value(Y), m_Specific(X))) && 1474ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines ICmpInst::isUnsigned(UnsignedPred)) 1475ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines UnsignedPred = ICmpInst::getSwappedPredicate(UnsignedPred); 1476ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines else 1477ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return nullptr; 1478ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 1479ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // X < Y && Y != 0 --> X < Y 1480ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // X < Y || Y != 0 --> Y != 0 1481ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (UnsignedPred == ICmpInst::ICMP_ULT && EqPred == ICmpInst::ICMP_NE) 1482ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return IsAnd ? UnsignedICmp : ZeroICmp; 1483ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 1484ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // X >= Y || Y != 0 --> true 1485ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // X >= Y || Y == 0 --> X >= Y 1486ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (UnsignedPred == ICmpInst::ICMP_UGE && !IsAnd) { 1487ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (EqPred == ICmpInst::ICMP_NE) 1488ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return getTrue(UnsignedICmp->getType()); 1489ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return UnsignedICmp; 1490ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines } 1491ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 1492ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // X < Y && Y == 0 --> false 1493ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (UnsignedPred == ICmpInst::ICMP_ULT && EqPred == ICmpInst::ICMP_EQ && 1494ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines IsAnd) 1495ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return getFalse(UnsignedICmp->getType()); 1496ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 1497ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return nullptr; 1498ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines} 1499ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 150037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hinesstatic Value *SimplifyAndOfICmps(ICmpInst *Op0, ICmpInst *Op1) { 1501de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar Type *ITy = Op0->getType(); 150237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines ICmpInst::Predicate Pred0, Pred1; 150337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines ConstantInt *CI1, *CI2; 150437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines Value *V; 1505ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 1506ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (Value *X = simplifyUnsignedRangeCheck(Op0, Op1, /*IsAnd=*/true)) 1507ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return X; 1508ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 1509de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar // Look for this pattern: (icmp V, C0) & (icmp V, C1)). 1510de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar const APInt *C0, *C1; 1511de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (match(Op0, m_ICmp(Pred0, m_Value(V), m_APInt(C0))) && 1512de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar match(Op1, m_ICmp(Pred1, m_Specific(V), m_APInt(C1)))) { 1513de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar // Make a constant range that's the intersection of the two icmp ranges. 1514de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar // If the intersection is empty, we know that the result is false. 1515de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar auto Range0 = ConstantRange::makeAllowedICmpRegion(Pred0, *C0); 1516de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar auto Range1 = ConstantRange::makeAllowedICmpRegion(Pred1, *C1); 1517de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (Range0.intersectWith(Range1).isEmptySet()) 1518de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return getFalse(ITy); 1519de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar } 1520de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar 152137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (!match(Op0, m_ICmp(Pred0, m_Add(m_Value(V), m_ConstantInt(CI1)), 152237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines m_ConstantInt(CI2)))) 1523de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return nullptr; 152437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines 152537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (!match(Op1, m_ICmp(Pred1, m_Specific(V), m_Specific(CI1)))) 152637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return nullptr; 152737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines 152837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines auto *AddInst = cast<BinaryOperator>(Op0->getOperand(0)); 152937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines bool isNSW = AddInst->hasNoSignedWrap(); 153037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines bool isNUW = AddInst->hasNoUnsignedWrap(); 153137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines 153237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const APInt &CI1V = CI1->getValue(); 153337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const APInt &CI2V = CI2->getValue(); 153437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const APInt Delta = CI2V - CI1V; 153537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (CI1V.isStrictlyPositive()) { 153637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Delta == 2) { 153737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Pred0 == ICmpInst::ICMP_ULT && Pred1 == ICmpInst::ICMP_SGT) 153837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return getFalse(ITy); 153937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Pred0 == ICmpInst::ICMP_SLT && Pred1 == ICmpInst::ICMP_SGT && isNSW) 154037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return getFalse(ITy); 154137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines } 154237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Delta == 1) { 154337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Pred0 == ICmpInst::ICMP_ULE && Pred1 == ICmpInst::ICMP_SGT) 154437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return getFalse(ITy); 154537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Pred0 == ICmpInst::ICMP_SLE && Pred1 == ICmpInst::ICMP_SGT && isNSW) 154637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return getFalse(ITy); 154737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines } 154837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines } 154937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (CI1V.getBoolValue() && isNUW) { 155037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Delta == 2) 155137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Pred0 == ICmpInst::ICMP_ULT && Pred1 == ICmpInst::ICMP_UGT) 155237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return getFalse(ITy); 155337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Delta == 1) 155437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Pred0 == ICmpInst::ICMP_ULE && Pred1 == ICmpInst::ICMP_UGT) 155537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return getFalse(ITy); 155637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines } 155737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines 155837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return nullptr; 155937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines} 156037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines 1561de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Given operands for an And, see if we can fold the result. 1562de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// If not, this returns null. 15630aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyAndInst(Value *Op0, Value *Op1, const Query &Q, 1564618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier unsigned MaxRecurse) { 15658aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 1566de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (Constant *CRHS = dyn_cast<Constant>(Op1)) 1567de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return ConstantFoldBinaryOpOperands(Instruction::And, CLHS, CRHS, Q.DL); 156812a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1569d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // Canonicalize the constant to the RHS. 1570d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner std::swap(Op0, Op1); 1571d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 157212a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1573d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X & undef -> 0 1574f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 1575d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Constant::getNullValue(Op0->getType()); 157612a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1577d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X & X = X 1578124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (Op0 == Op1) 1579d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 158012a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 15812b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // X & 0 = 0 15822b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (match(Op1, m_Zero())) 1583d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op1; 158412a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 15852b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // X & -1 = X 15862b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (match(Op1, m_AllOnes())) 15872b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return Op0; 158812a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1589d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // A & ~A = ~A & A = 0 159081a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner if (match(Op0, m_Not(m_Specific(Op1))) || 159181a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner match(Op1, m_Not(m_Specific(Op0)))) 1592d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Constant::getNullValue(Op0->getType()); 159312a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1594d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // (A | ?) & A = A 1595dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Value *A = nullptr, *B = nullptr; 1596d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (match(Op0, m_Or(m_Value(A), m_Value(B))) && 1597124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands (A == Op1 || B == Op1)) 1598d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op1; 159912a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1600d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // A & (A | ?) = A 1601d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (match(Op1, m_Or(m_Value(A), m_Value(B))) && 1602124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands (A == Op0 || B == Op0)) 1603d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 160412a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1605dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands // A & (-A) = A if A is a power of two or zero. 1606dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands if (match(Op0, m_Neg(m_Specific(Op1))) || 1607dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands match(Op1, m_Neg(m_Specific(Op0)))) { 16084c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar if (isKnownToBeAPowerOfTwo(Op0, Q.DL, /*OrZero*/ true, 0, Q.AC, Q.CxtI, 16094c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar Q.DT)) 1610dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands return Op0; 16114c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar if (isKnownToBeAPowerOfTwo(Op1, Q.DL, /*OrZero*/ true, 0, Q.AC, Q.CxtI, 16124c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar Q.DT)) 1613dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands return Op1; 1614dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands } 1615dd3149d57977d0632cfaf24290dd93416fb2a0efDuncan Sands 161637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (auto *ICILHS = dyn_cast<ICmpInst>(Op0)) { 161737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (auto *ICIRHS = dyn_cast<ICmpInst>(Op1)) { 161837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Value *V = SimplifyAndOfICmps(ICILHS, ICIRHS)) 161937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return V; 162037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Value *V = SimplifyAndOfICmps(ICIRHS, ICILHS)) 162137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return V; 162237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines } 162337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines } 162437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines 1625de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar // The compares may be hidden behind casts. Look through those and try the 1626de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar // same folds as above. 1627de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar auto *Cast0 = dyn_cast<CastInst>(Op0); 1628de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar auto *Cast1 = dyn_cast<CastInst>(Op1); 1629de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (Cast0 && Cast1 && Cast0->getOpcode() == Cast1->getOpcode() && 1630de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar Cast0->getSrcTy() == Cast1->getSrcTy()) { 1631de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar auto *Cmp0 = dyn_cast<ICmpInst>(Cast0->getOperand(0)); 1632de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar auto *Cmp1 = dyn_cast<ICmpInst>(Cast1->getOperand(0)); 1633de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (Cmp0 && Cmp1) { 1634de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar Instruction::CastOps CastOpc = Cast0->getOpcode(); 1635de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar Type *ResultType = Cast0->getType(); 1636de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (auto *V = dyn_cast_or_null<Constant>(SimplifyAndOfICmps(Cmp0, Cmp1))) 1637de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return ConstantExpr::getCast(CastOpc, V, ResultType); 1638de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (auto *V = dyn_cast_or_null<Constant>(SimplifyAndOfICmps(Cmp1, Cmp0))) 1639de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return ConstantExpr::getCast(CastOpc, V, ResultType); 1640de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar } 1641de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar } 1642de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar 1643566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Try some generic simplifications for associative operations. 16440aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyAssociativeBinOp(Instruction::And, Op0, Op1, Q, 16450aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands MaxRecurse)) 1646566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return V; 16476844c8ea5a67e551be7106d6b7b9e1a64eecbe51Benjamin Kramer 16483421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // And distributes over Or. Try some generic simplifications based on this. 16493421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = ExpandBinOp(Instruction::And, Op0, Op1, Instruction::Or, 16500aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse)) 16513421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 16523421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 16533421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // And distributes over Xor. Try some generic simplifications based on this. 16543421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = ExpandBinOp(Instruction::And, Op0, Op1, Instruction::Xor, 16550aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse)) 16563421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 16573421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1658b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // If the operation is with the result of a select instruction, check whether 1659b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // operating on either branch of the select always yields the same value. 16600312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) 16610aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadBinOpOverSelect(Instruction::And, Op0, Op1, Q, 16620aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands MaxRecurse)) 1663a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return V; 1664a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 1665a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the operation is with the result of a phi instruction, check whether 1666a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // operating on all incoming values of the phi always yields the same value. 16670312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<PHINode>(Op0) || isa<PHINode>(Op1)) 16680aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadBinOpOverPHI(Instruction::And, Op0, Op1, Q, 16690312a93693abc2eb682b2b101c889959888fd883Duncan Sands MaxRecurse)) 1670b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return V; 1671b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 1672dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 1673d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner} 16749f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 16754c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga NainarValue *llvm::SimplifyAndInst(Value *Op0, Value *Op1, const DataLayout &DL, 1676618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1677ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const DominatorTree *DT, AssumptionCache *AC, 167837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const Instruction *CxtI) { 1679ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return ::SimplifyAndInst(Op0, Op1, Query(DL, TLI, DT, AC, CxtI), 168037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines RecursionLimit); 168137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines} 168237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines 1683de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Simplify (or (icmp ...) (icmp ...)) to true when we can tell that the union 1684de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// contains all possible values. 168537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hinesstatic Value *SimplifyOrOfICmps(ICmpInst *Op0, ICmpInst *Op1) { 168637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines ICmpInst::Predicate Pred0, Pred1; 168737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines ConstantInt *CI1, *CI2; 168837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines Value *V; 1689ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 1690ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (Value *X = simplifyUnsignedRangeCheck(Op0, Op1, /*IsAnd=*/false)) 1691ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return X; 1692ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 169337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (!match(Op0, m_ICmp(Pred0, m_Add(m_Value(V), m_ConstantInt(CI1)), 169437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines m_ConstantInt(CI2)))) 169537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return nullptr; 169637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines 169737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (!match(Op1, m_ICmp(Pred1, m_Specific(V), m_Specific(CI1)))) 169837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return nullptr; 169937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines 170037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines Type *ITy = Op0->getType(); 170137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines 170237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines auto *AddInst = cast<BinaryOperator>(Op0->getOperand(0)); 170337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines bool isNSW = AddInst->hasNoSignedWrap(); 170437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines bool isNUW = AddInst->hasNoUnsignedWrap(); 170537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines 170637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const APInt &CI1V = CI1->getValue(); 170737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const APInt &CI2V = CI2->getValue(); 170837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const APInt Delta = CI2V - CI1V; 170937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (CI1V.isStrictlyPositive()) { 171037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Delta == 2) { 171137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Pred0 == ICmpInst::ICMP_UGE && Pred1 == ICmpInst::ICMP_SLE) 171237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return getTrue(ITy); 171337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Pred0 == ICmpInst::ICMP_SGE && Pred1 == ICmpInst::ICMP_SLE && isNSW) 171437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return getTrue(ITy); 171537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines } 171637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Delta == 1) { 171737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Pred0 == ICmpInst::ICMP_UGT && Pred1 == ICmpInst::ICMP_SLE) 171837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return getTrue(ITy); 171937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Pred0 == ICmpInst::ICMP_SGT && Pred1 == ICmpInst::ICMP_SLE && isNSW) 172037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return getTrue(ITy); 172137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines } 172237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines } 172337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (CI1V.getBoolValue() && isNUW) { 172437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Delta == 2) 172537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Pred0 == ICmpInst::ICMP_UGE && Pred1 == ICmpInst::ICMP_ULE) 172637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return getTrue(ITy); 172737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Delta == 1) 172837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Pred0 == ICmpInst::ICMP_UGT && Pred1 == ICmpInst::ICMP_ULE) 172937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return getTrue(ITy); 173037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines } 173137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines 173237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return nullptr; 1733a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 1734a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 1735de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Given operands for an Or, see if we can fold the result. 1736de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// If not, this returns null. 17370aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyOrInst(Value *Op0, Value *Op1, const Query &Q, 17380aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands unsigned MaxRecurse) { 1739d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 1740de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (Constant *CRHS = dyn_cast<Constant>(Op1)) 1741de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return ConstantFoldBinaryOpOperands(Instruction::Or, CLHS, CRHS, Q.DL); 174212a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1743d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // Canonicalize the constant to the RHS. 1744d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner std::swap(Op0, Op1); 1745d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 174612a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1747d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X | undef -> -1 1748f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 1749d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Constant::getAllOnesValue(Op0->getType()); 175012a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1751d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X | X = X 1752124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (Op0 == Op1) 1753d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 1754d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 17552b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // X | 0 = X 17562b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (match(Op1, m_Zero())) 1757d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 175812a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 17592b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // X | -1 = -1 17602b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (match(Op1, m_AllOnes())) 17612b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return Op1; 176212a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1763d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // A | ~A = ~A | A = -1 176481a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner if (match(Op0, m_Not(m_Specific(Op1))) || 176581a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner match(Op1, m_Not(m_Specific(Op0)))) 1766d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Constant::getAllOnesValue(Op0->getType()); 176712a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1768d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // (A & ?) | A = A 1769dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Value *A = nullptr, *B = nullptr; 1770d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (match(Op0, m_And(m_Value(A), m_Value(B))) && 1771124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands (A == Op1 || B == Op1)) 1772d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op1; 177312a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1774d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // A | (A & ?) = A 1775d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (match(Op1, m_And(m_Value(A), m_Value(B))) && 1776124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands (A == Op0 || B == Op0)) 1777d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 177812a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 177938f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer // ~(A & ?) | A = -1 178038f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer if (match(Op0, m_Not(m_And(m_Value(A), m_Value(B)))) && 178138f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer (A == Op1 || B == Op1)) 178238f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer return Constant::getAllOnesValue(Op1->getType()); 178338f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer 178438f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer // A | ~(A & ?) = -1 178538f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer if (match(Op1, m_Not(m_And(m_Value(A), m_Value(B)))) && 178638f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer (A == Op0 || B == Op0)) 178738f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer return Constant::getAllOnesValue(Op0->getType()); 178838f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer 178937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (auto *ICILHS = dyn_cast<ICmpInst>(Op0)) { 179037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (auto *ICIRHS = dyn_cast<ICmpInst>(Op1)) { 179137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Value *V = SimplifyOrOfICmps(ICILHS, ICIRHS)) 179237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return V; 179337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Value *V = SimplifyOrOfICmps(ICIRHS, ICILHS)) 179437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return V; 179537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines } 179637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines } 179737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines 1798566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Try some generic simplifications for associative operations. 17990aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyAssociativeBinOp(Instruction::Or, Op0, Op1, Q, 18000aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands MaxRecurse)) 1801566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return V; 18026844c8ea5a67e551be7106d6b7b9e1a64eecbe51Benjamin Kramer 18033421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Or distributes over And. Try some generic simplifications based on this. 18040aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ExpandBinOp(Instruction::Or, Op0, Op1, Instruction::And, Q, 18050aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands MaxRecurse)) 18063421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 18073421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1808b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // If the operation is with the result of a select instruction, check whether 1809b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // operating on either branch of the select always yields the same value. 18100312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) 18110aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadBinOpOverSelect(Instruction::Or, Op0, Op1, Q, 18120312a93693abc2eb682b2b101c889959888fd883Duncan Sands MaxRecurse)) 1813a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return V; 1814a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 1815c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines // (A & C)|(B & D) 1816c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines Value *C = nullptr, *D = nullptr; 1817c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines if (match(Op0, m_And(m_Value(A), m_Value(C))) && 1818c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines match(Op1, m_And(m_Value(B), m_Value(D)))) { 1819c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines ConstantInt *C1 = dyn_cast<ConstantInt>(C); 1820c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines ConstantInt *C2 = dyn_cast<ConstantInt>(D); 1821c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines if (C1 && C2 && (C1->getValue() == ~C2->getValue())) { 1822c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines // (A & C1)|(B & C2) 1823c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines // If we have: ((V + N) & C1) | (V & C2) 1824c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines // .. and C2 = ~C1 and C2 is 0+1+ and (N & C2) == 0 1825c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines // replace with V+N. 1826c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines Value *V1, *V2; 1827c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines if ((C2->getValue() & (C2->getValue() + 1)) == 0 && // C2 == 0+1+ 1828c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines match(A, m_Add(m_Value(V1), m_Value(V2)))) { 1829c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines // Add commutes, try both ways. 1830ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (V1 == B && 1831ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines MaskedValueIsZero(V2, C2->getValue(), Q.DL, 0, Q.AC, Q.CxtI, Q.DT)) 1832c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines return A; 1833ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (V2 == B && 1834ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines MaskedValueIsZero(V1, C2->getValue(), Q.DL, 0, Q.AC, Q.CxtI, Q.DT)) 1835c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines return A; 1836c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines } 1837c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines // Or commutes, try both ways. 1838c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines if ((C1->getValue() & (C1->getValue() + 1)) == 0 && 1839c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines match(B, m_Add(m_Value(V1), m_Value(V2)))) { 1840c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines // Add commutes, try both ways. 1841ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (V1 == A && 1842ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines MaskedValueIsZero(V2, C1->getValue(), Q.DL, 0, Q.AC, Q.CxtI, Q.DT)) 1843c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines return B; 1844ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (V2 == A && 1845ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines MaskedValueIsZero(V1, C1->getValue(), Q.DL, 0, Q.AC, Q.CxtI, Q.DT)) 1846c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines return B; 1847c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines } 1848c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines } 1849c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines } 1850c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines 1851a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the operation is with the result of a phi instruction, check whether 1852a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // operating on all incoming values of the phi always yields the same value. 18530312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<PHINode>(Op0) || isa<PHINode>(Op1)) 18540aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadBinOpOverPHI(Instruction::Or, Op0, Op1, Q, MaxRecurse)) 1855b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return V; 1856b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 1857dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 18589f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner} 18599f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 18604c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga NainarValue *llvm::SimplifyOrInst(Value *Op0, Value *Op1, const DataLayout &DL, 1861618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1862ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const DominatorTree *DT, AssumptionCache *AC, 186337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const Instruction *CxtI) { 1864ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return ::SimplifyOrInst(Op0, Op1, Query(DL, TLI, DT, AC, CxtI), 186537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines RecursionLimit); 1866a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 1867d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 1868de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Given operands for a Xor, see if we can fold the result. 1869de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// If not, this returns null. 18700aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyXorInst(Value *Op0, Value *Op1, const Query &Q, 18710aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands unsigned MaxRecurse) { 18722b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 1873de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (Constant *CRHS = dyn_cast<Constant>(Op1)) 1874de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return ConstantFoldBinaryOpOperands(Instruction::Xor, CLHS, CRHS, Q.DL); 18752b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 18762b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // Canonicalize the constant to the RHS. 18772b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands std::swap(Op0, Op1); 18782b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands } 18792b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 18802b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // A ^ undef -> undef 1881f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 1882f8b1a5ea9602bb65a5cf59d3d34f2851a08cdc3eDuncan Sands return Op1; 18832b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 18842b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // A ^ 0 = A 18852b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (match(Op1, m_Zero())) 18862b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return Op0; 18872b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 1888f23d4adbfaf870d5fa67c6bff0da7891d3a98f9dEli Friedman // A ^ A = 0 1889f23d4adbfaf870d5fa67c6bff0da7891d3a98f9dEli Friedman if (Op0 == Op1) 1890f23d4adbfaf870d5fa67c6bff0da7891d3a98f9dEli Friedman return Constant::getNullValue(Op0->getType()); 1891f23d4adbfaf870d5fa67c6bff0da7891d3a98f9dEli Friedman 18922b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // A ^ ~A = ~A ^ A = -1 189381a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner if (match(Op0, m_Not(m_Specific(Op1))) || 189481a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner match(Op1, m_Not(m_Specific(Op0)))) 18952b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return Constant::getAllOnesValue(Op0->getType()); 18962b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 1897566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Try some generic simplifications for associative operations. 18980aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyAssociativeBinOp(Instruction::Xor, Op0, Op1, Q, 18990aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands MaxRecurse)) 1900566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return V; 19012b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 190287689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // Threading Xor over selects and phi nodes is pointless, so don't bother. 190387689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // Threading over the select in "A ^ select(cond, B, C)" means evaluating 190487689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // "A^B" and "A^C" and seeing if they are equal; but they are equal if and 190587689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // only if B and C are equal. If B and C are equal then (since we assume 190687689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // that operands have already been simplified) "select(cond, B, C)" should 190787689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // have been simplified to the common value of B and C already. Analysing 190887689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // "A^B" and "A^C" thus gains nothing, but costs compile time. Similarly 190987689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // for threading over phi nodes. 19102b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 1911dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 19122b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands} 19132b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 19144c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga NainarValue *llvm::SimplifyXorInst(Value *Op0, Value *Op1, const DataLayout &DL, 1915618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 1916ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const DominatorTree *DT, AssumptionCache *AC, 191737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const Instruction *CxtI) { 1918ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return ::SimplifyXorInst(Op0, Op1, Query(DL, TLI, DT, AC, CxtI), 191937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines RecursionLimit); 19202b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands} 19212b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 1922db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattnerstatic Type *GetCompareTy(Value *Op) { 1923210c5d4880b525e064088b6fec713260128c16ebChris Lattner return CmpInst::makeCmpResultType(Op->getType()); 1924210c5d4880b525e064088b6fec713260128c16ebChris Lattner} 1925210c5d4880b525e064088b6fec713260128c16ebChris Lattner 1926de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Rummage around inside V looking for something equivalent to the comparison 1927de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// "LHS Pred RHS". Return such a value if found, otherwise return null. 1928de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Helper function for analyzing max/min idioms. 1929e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sandsstatic Value *ExtractEquivalentCondition(Value *V, CmpInst::Predicate Pred, 1930e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands Value *LHS, Value *RHS) { 1931e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands SelectInst *SI = dyn_cast<SelectInst>(V); 1932e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (!SI) 1933dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 1934e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands CmpInst *Cmp = dyn_cast<CmpInst>(SI->getCondition()); 1935e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (!Cmp) 1936dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 1937e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands Value *CmpLHS = Cmp->getOperand(0), *CmpRHS = Cmp->getOperand(1); 1938e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Pred == Cmp->getPredicate() && LHS == CmpLHS && RHS == CmpRHS) 1939e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return Cmp; 1940e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Pred == CmpInst::getSwappedPredicate(Cmp->getPredicate()) && 1941e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands LHS == CmpRHS && RHS == CmpLHS) 1942e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return Cmp; 1943dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 1944e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands} 1945e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands 1946901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// A significant optimization not implemented here is assuming that alloca 1947901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// addresses are not equal to incoming argument values. They don't *alias*, 1948901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// as we say, but that doesn't mean they aren't equal, so we take a 1949901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// conservative approach. 1950901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// 1951901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// This is inspired in part by C++11 5.10p1: 1952901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// "Two pointers of the same type compare equal if and only if they are both 1953901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// null, both point to the same function, or both represent the same 1954901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// address." 1955901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// 1956901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// This is pretty permissive. 1957901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// 1958901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// It's also partly due to C11 6.5.9p6: 1959901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// "Two pointers compare equal if and only if both are null pointers, both are 1960901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// pointers to the same object (including a pointer to an object and a 1961901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// subobject at its beginning) or function, both are pointers to one past the 1962901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// last element of the same array object, or one is a pointer to one past the 1963901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// end of one array object and the other is a pointer to the start of a 196492c3742319cc219f8a57aa7d8eea5b17ec93ad06NAKAMURA Takumi// different array object that happens to immediately follow the first array 1965901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// object in the address space.) 1966901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// 1967901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// C11's version is more restrictive, however there's no reason why an argument 1968901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// couldn't be a one-past-the-end value for a stack object in the caller and be 1969901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// equal to the beginning of a stack object in the callee. 1970901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// 1971901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// If the C and C++ standards are ever made sufficiently restrictive in this 1972901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// area, it may be possible to update LLVM's semantics accordingly and reinstate 1973901261d558d0b41ba75d8aa2b38aac72aaa41baeDan Gohman// this optimization. 1974de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainarstatic Constant * 1975de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga NainarcomputePointerICmp(const DataLayout &DL, const TargetLibraryInfo *TLI, 1976de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar const DominatorTree *DT, CmpInst::Predicate Pred, 1977de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar const Instruction *CxtI, Value *LHS, Value *RHS) { 1978fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // First, skip past any trivial no-ops. 1979fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman LHS = LHS->stripPointerCasts(); 1980fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman RHS = RHS->stripPointerCasts(); 1981fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman 1982fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // A non-null pointer is not equal to a null pointer. 1983de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (llvm::isKnownNonNull(LHS) && isa<ConstantPointerNull>(RHS) && 1984fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman (Pred == CmpInst::ICMP_EQ || Pred == CmpInst::ICMP_NE)) 1985fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman return ConstantInt::get(GetCompareTy(LHS), 1986fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman !CmpInst::isTrueWhenEqual(Pred)); 1987fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman 198858725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth // We can only fold certain predicates on pointer comparisons. 198958725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth switch (Pred) { 199058725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth default: 1991dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 199258725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth 199358725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth // Equality comaprisons are easy to fold. 199458725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth case CmpInst::ICMP_EQ: 199558725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth case CmpInst::ICMP_NE: 199658725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth break; 199758725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth 199858725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth // We can only handle unsigned relational comparisons because 'inbounds' on 199958725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth // a GEP only protects against unsigned wrapping. 200058725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth case CmpInst::ICMP_UGT: 200158725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth case CmpInst::ICMP_UGE: 200258725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth case CmpInst::ICMP_ULT: 200358725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth case CmpInst::ICMP_ULE: 200458725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth // However, we have to switch them to their signed variants to handle 200558725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth // negative indices from the base pointer. 200658725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth Pred = ICmpInst::getSignedPredicate(Pred); 200758725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth break; 200858725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth } 200958725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth 2010fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // Strip off any constant offsets so that we can reason about them. 2011fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // It's tempting to use getUnderlyingObject or even just stripInBoundsOffsets 2012fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // here and compare base addresses like AliasAnalysis does, however there are 2013fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // numerous hazards. AliasAnalysis and its utilities rely on special rules 2014fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // governing loads and stores which don't apply to icmps. Also, AliasAnalysis 2015fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // doesn't need to guarantee pointer inequality when it says NoAlias. 201636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Constant *LHSOffset = stripAndComputeConstantOffsets(DL, LHS); 201736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Constant *RHSOffset = stripAndComputeConstantOffsets(DL, RHS); 2018fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman 2019fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // If LHS and RHS are related via constant offsets to the same base 2020fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // value, we can replace it with an icmp which just compares the offsets. 2021fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman if (LHS == RHS) 2022fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman return ConstantExpr::getICmp(Pred, LHSOffset, RHSOffset); 2023fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman 2024fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // Various optimizations for (in)equality comparisons. 2025fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman if (Pred == CmpInst::ICMP_EQ || Pred == CmpInst::ICMP_NE) { 2026fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // Different non-empty allocations that exist at the same time have 2027fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // different addresses (if the program can tell). Global variables always 2028fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // exist, so they always exist during the lifetime of each other and all 2029fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // allocas. Two different allocas usually have different addresses... 2030fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // 2031fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // However, if there's an @llvm.stackrestore dynamically in between two 2032fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // allocas, they may have the same address. It's tempting to reduce the 2033fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // scope of the problem by only looking at *static* allocas here. That would 2034fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // cover the majority of allocas while significantly reducing the likelihood 2035fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // of having an @llvm.stackrestore pop up in the middle. However, it's not 2036fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // actually impossible for an @llvm.stackrestore to pop up in the middle of 2037fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // an entry block. Also, if we have a block that's not attached to a 2038fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // function, we can't tell if it's "static" under the current definition. 2039fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // Theoretically, this problem could be fixed by creating a new kind of 2040fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // instruction kind specifically for static allocas. Such a new instruction 2041fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // could be required to be at the top of the entry block, thus preventing it 2042fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // from being subject to a @llvm.stackrestore. Instcombine could even 2043fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // convert regular allocas into these special allocas. It'd be nifty. 2044fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // However, until then, this problem remains open. 2045fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // 2046fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // So, we'll assume that two non-empty allocas have different addresses 2047fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // for now. 2048fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // 2049fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // With all that, if the offsets are within the bounds of their allocations 2050fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // (and not one-past-the-end! so we can't use inbounds!), and their 2051fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // allocations aren't the same, the pointers are not equal. 2052fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // 2053fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // Note that it's not necessary to check for LHS being a global variable 2054fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // address, due to canonicalization and constant folding. 2055fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman if (isa<AllocaInst>(LHS) && 2056fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman (isa<AllocaInst>(RHS) || isa<GlobalVariable>(RHS))) { 2057d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramer ConstantInt *LHSOffsetCI = dyn_cast<ConstantInt>(LHSOffset); 2058d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramer ConstantInt *RHSOffsetCI = dyn_cast<ConstantInt>(RHSOffset); 2059fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman uint64_t LHSSize, RHSSize; 2060d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramer if (LHSOffsetCI && RHSOffsetCI && 206136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines getObjectSize(LHS, LHSSize, DL, TLI) && 206236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines getObjectSize(RHS, RHSSize, DL, TLI)) { 2063d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramer const APInt &LHSOffsetValue = LHSOffsetCI->getValue(); 2064d9f32c20da9de8798284a8007662c6557560c876Benjamin Kramer const APInt &RHSOffsetValue = RHSOffsetCI->getValue(); 2065fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman if (!LHSOffsetValue.isNegative() && 2066fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman !RHSOffsetValue.isNegative() && 2067fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman LHSOffsetValue.ult(LHSSize) && 2068fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman RHSOffsetValue.ult(RHSSize)) { 2069fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman return ConstantInt::get(GetCompareTy(LHS), 2070fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman !CmpInst::isTrueWhenEqual(Pred)); 2071fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman } 2072fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman } 207358725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth 2074fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // Repeat the above check but this time without depending on DataLayout 2075fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // or being able to compute a precise size. 2076fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman if (!cast<PointerType>(LHS->getType())->isEmptyTy() && 2077fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman !cast<PointerType>(RHS->getType())->isEmptyTy() && 2078fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman LHSOffset->isNullValue() && 2079fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman RHSOffset->isNullValue()) 2080fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman return ConstantInt::get(GetCompareTy(LHS), 2081fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman !CmpInst::isTrueWhenEqual(Pred)); 2082fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman } 2083baca5334db904819e6c0d26cd5f5203f82c44f6eBenjamin Kramer 2084baca5334db904819e6c0d26cd5f5203f82c44f6eBenjamin Kramer // Even if an non-inbounds GEP occurs along the path we can still optimize 2085baca5334db904819e6c0d26cd5f5203f82c44f6eBenjamin Kramer // equality comparisons concerning the result. We avoid walking the whole 2086baca5334db904819e6c0d26cd5f5203f82c44f6eBenjamin Kramer // chain again by starting where the last calls to 2087baca5334db904819e6c0d26cd5f5203f82c44f6eBenjamin Kramer // stripAndComputeConstantOffsets left off and accumulate the offsets. 208836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Constant *LHSNoBound = stripAndComputeConstantOffsets(DL, LHS, true); 208936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Constant *RHSNoBound = stripAndComputeConstantOffsets(DL, RHS, true); 2090baca5334db904819e6c0d26cd5f5203f82c44f6eBenjamin Kramer if (LHS == RHS) 2091baca5334db904819e6c0d26cd5f5203f82c44f6eBenjamin Kramer return ConstantExpr::getICmp(Pred, 2092baca5334db904819e6c0d26cd5f5203f82c44f6eBenjamin Kramer ConstantExpr::getAdd(LHSOffset, LHSNoBound), 2093baca5334db904819e6c0d26cd5f5203f82c44f6eBenjamin Kramer ConstantExpr::getAdd(RHSOffset, RHSNoBound)); 2094ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 2095ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // If one side of the equality comparison must come from a noalias call 2096ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // (meaning a system memory allocation function), and the other side must 2097ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // come from a pointer that cannot overlap with dynamically-allocated 2098ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // memory within the lifetime of the current function (allocas, byval 2099ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // arguments, globals), then determine the comparison result here. 2100ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines SmallVector<Value *, 8> LHSUObjs, RHSUObjs; 2101ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines GetUnderlyingObjects(LHS, LHSUObjs, DL); 2102ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines GetUnderlyingObjects(RHS, RHSUObjs, DL); 2103ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 2104ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // Is the set of underlying objects all noalias calls? 2105ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines auto IsNAC = [](SmallVectorImpl<Value *> &Objects) { 2106f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar return std::all_of(Objects.begin(), Objects.end(), isNoAliasCall); 2107ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines }; 2108ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 2109ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // Is the set of underlying objects all things which must be disjoint from 2110ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // noalias calls. For allocas, we consider only static ones (dynamic 2111ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // allocas might be transformed into calls to malloc not simultaneously 2112ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // live with the compared-to allocation). For globals, we exclude symbols 2113ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // that might be resolve lazily to symbols in another dynamically-loaded 2114ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // library (and, thus, could be malloc'ed by the implementation). 2115ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines auto IsAllocDisjoint = [](SmallVectorImpl<Value *> &Objects) { 2116de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return std::all_of(Objects.begin(), Objects.end(), [](Value *V) { 2117de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (const AllocaInst *AI = dyn_cast<AllocaInst>(V)) 2118de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return AI->getParent() && AI->getFunction() && AI->isStaticAlloca(); 2119de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) 2120de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return (GV->hasLocalLinkage() || GV->hasHiddenVisibility() || 2121de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar GV->hasProtectedVisibility() || GV->hasGlobalUnnamedAddr()) && 2122de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar !GV->isThreadLocal(); 2123de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (const Argument *A = dyn_cast<Argument>(V)) 2124de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return A->hasByValAttr(); 2125de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return false; 2126de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar }); 2127ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines }; 2128ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 2129ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if ((IsNAC(LHSUObjs) && IsAllocDisjoint(RHSUObjs)) || 2130ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines (IsNAC(RHSUObjs) && IsAllocDisjoint(LHSUObjs))) 2131ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return ConstantInt::get(GetCompareTy(LHS), 2132ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines !CmpInst::isTrueWhenEqual(Pred)); 2133de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar 2134de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar // Fold comparisons for non-escaping pointer even if the allocation call 2135de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar // cannot be elided. We cannot fold malloc comparison to null. Also, the 2136de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar // dynamic allocation call could be either of the operands. 2137de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar Value *MI = nullptr; 2138de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (isAllocLikeFn(LHS, TLI) && llvm::isKnownNonNullAt(RHS, CxtI, DT)) 2139de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar MI = LHS; 2140de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar else if (isAllocLikeFn(RHS, TLI) && llvm::isKnownNonNullAt(LHS, CxtI, DT)) 2141de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar MI = RHS; 2142de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar // FIXME: We should also fold the compare when the pointer escapes, but the 2143de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar // compare dominates the pointer escape 2144de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (MI && !PointerMayBeCaptured(MI, true, true)) 2145de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return ConstantInt::get(GetCompareTy(LHS), 2146de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar CmpInst::isFalseWhenEqual(Pred)); 2147fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman } 214858725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth 2149fdd1eafe867734df285bbdb01cf1d21f63716798Dan Gohman // Otherwise, fail. 2150dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 215158725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth} 2152009e2650d69fe93bda1864340c5f000e56c52fb8Chris Lattner 2153de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Given operands for an ICmpInst, see if we can fold the result. 2154de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// If not, this returns null. 2155a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS, 21560aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 21579f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner CmpInst::Predicate Pred = (CmpInst::Predicate)Predicate; 21589dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner assert(CmpInst::isIntPredicate(Pred) && "Not an integer compare!"); 215912a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2160d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(LHS)) { 21618f73deaa8732a556046bf4ac6207be55972e3b74Chris Lattner if (Constant *CRHS = dyn_cast<Constant>(RHS)) 216236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return ConstantFoldCompareInstOperands(Pred, CLHS, CRHS, Q.DL, Q.TLI); 2163d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 2164d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // If we have a constant, make sure it is on the RHS. 2165d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner std::swap(LHS, RHS); 2166d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Pred = CmpInst::getSwappedPredicate(Pred); 2167d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 216812a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2169db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *ITy = GetCompareTy(LHS); // The return type. 2170db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *OpTy = LHS->getType(); // The operand type. 217112a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2172210c5d4880b525e064088b6fec713260128c16ebChris Lattner // icmp X, X -> true/false 2173c8e14b3d37b80abb6adb4b831af0452d9ecbf2b2Chris Lattner // X icmp undef -> true/false. For example, icmp ugt %X, undef -> false 2174c8e14b3d37b80abb6adb4b831af0452d9ecbf2b2Chris Lattner // because X could be 0. 2175124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (LHS == RHS || isa<UndefValue>(RHS)) 2176210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(ITy, CmpInst::isTrueWhenEqual(Pred)); 217712a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 21786dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // Special case logic when the operands have i1 type. 217966d004ef708642bbdc38fd761507f2e9ee3970cdNick Lewycky if (OpTy->getScalarType()->isIntegerTy(1)) { 21806dc91253ab1872e118b08511a09d5c934988354eDuncan Sands switch (Pred) { 21816dc91253ab1872e118b08511a09d5c934988354eDuncan Sands default: break; 21826dc91253ab1872e118b08511a09d5c934988354eDuncan Sands case ICmpInst::ICMP_EQ: 21836dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // X == 1 -> X 21846dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (match(RHS, m_One())) 21856dc91253ab1872e118b08511a09d5c934988354eDuncan Sands return LHS; 21866dc91253ab1872e118b08511a09d5c934988354eDuncan Sands break; 21876dc91253ab1872e118b08511a09d5c934988354eDuncan Sands case ICmpInst::ICMP_NE: 21886dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // X != 0 -> X 21896dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (match(RHS, m_Zero())) 21906dc91253ab1872e118b08511a09d5c934988354eDuncan Sands return LHS; 21916dc91253ab1872e118b08511a09d5c934988354eDuncan Sands break; 21926dc91253ab1872e118b08511a09d5c934988354eDuncan Sands case ICmpInst::ICMP_UGT: 21936dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // X >u 0 -> X 21946dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (match(RHS, m_Zero())) 21956dc91253ab1872e118b08511a09d5c934988354eDuncan Sands return LHS; 21966dc91253ab1872e118b08511a09d5c934988354eDuncan Sands break; 2197de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar case ICmpInst::ICMP_UGE: { 21986dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // X >=u 1 -> X 21996dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (match(RHS, m_One())) 22006dc91253ab1872e118b08511a09d5c934988354eDuncan Sands return LHS; 2201de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (isImpliedCondition(RHS, LHS, Q.DL).getValueOr(false)) 2202f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar return getTrue(ITy); 2203f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar break; 2204de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar } 2205de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar case ICmpInst::ICMP_SGE: { 2206de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar /// For signed comparison, the values for an i1 are 0 and -1 2207f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar /// respectively. This maps into a truth table of: 2208f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar /// LHS | RHS | LHS >=s RHS | LHS implies RHS 2209f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar /// 0 | 0 | 1 (0 >= 0) | 1 2210f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar /// 0 | 1 | 1 (0 >= -1) | 1 2211f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar /// 1 | 0 | 0 (-1 >= 0) | 0 2212f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar /// 1 | 1 | 1 (-1 >= -1) | 1 2213de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (isImpliedCondition(LHS, RHS, Q.DL).getValueOr(false)) 2214f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar return getTrue(ITy); 22156dc91253ab1872e118b08511a09d5c934988354eDuncan Sands break; 2216de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar } 22176dc91253ab1872e118b08511a09d5c934988354eDuncan Sands case ICmpInst::ICMP_SLT: 22186dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // X <s 0 -> X 22196dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (match(RHS, m_Zero())) 22206dc91253ab1872e118b08511a09d5c934988354eDuncan Sands return LHS; 22216dc91253ab1872e118b08511a09d5c934988354eDuncan Sands break; 22226dc91253ab1872e118b08511a09d5c934988354eDuncan Sands case ICmpInst::ICMP_SLE: 22236dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // X <=s -1 -> X 22246dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (match(RHS, m_One())) 22256dc91253ab1872e118b08511a09d5c934988354eDuncan Sands return LHS; 22266dc91253ab1872e118b08511a09d5c934988354eDuncan Sands break; 2227de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar case ICmpInst::ICMP_ULE: { 2228de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (isImpliedCondition(LHS, RHS, Q.DL).getValueOr(false)) 2229f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar return getTrue(ITy); 2230f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar break; 22316dc91253ab1872e118b08511a09d5c934988354eDuncan Sands } 2232de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar } 22336dc91253ab1872e118b08511a09d5c934988354eDuncan Sands } 223412a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2235d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands // If we are comparing with zero then try hard since this is a common case. 2236d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (match(RHS, m_Zero())) { 2237d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands bool LHSKnownNonNegative, LHSKnownNegative; 2238d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands switch (Pred) { 2239858143816d43e58b17bfd11cb1b57afbd7f0f893Craig Topper default: llvm_unreachable("Unknown ICmp predicate!"); 2240d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_ULT: 2241f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 2242d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_UGE: 2243f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 2244d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_EQ: 2245d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_ULE: 2246ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (isKnownNonZero(LHS, Q.DL, 0, Q.AC, Q.CxtI, Q.DT)) 2247f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 2248d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands break; 2249d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_NE: 2250d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_UGT: 2251ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (isKnownNonZero(LHS, Q.DL, 0, Q.AC, Q.CxtI, Q.DT)) 2252f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 2253d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands break; 2254d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_SLT: 2255ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, Q.DL, 0, Q.AC, 2256ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines Q.CxtI, Q.DT); 2257d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNegative) 2258f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 2259d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNonNegative) 2260f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 2261d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands break; 2262d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_SLE: 2263ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, Q.DL, 0, Q.AC, 2264ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines Q.CxtI, Q.DT); 2265d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNegative) 2266f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 2267ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (LHSKnownNonNegative && 2268ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines isKnownNonZero(LHS, Q.DL, 0, Q.AC, Q.CxtI, Q.DT)) 2269f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 2270d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands break; 2271d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_SGE: 2272ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, Q.DL, 0, Q.AC, 2273ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines Q.CxtI, Q.DT); 2274d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNegative) 2275f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 2276d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNonNegative) 2277f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 2278d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands break; 2279d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_SGT: 2280ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, Q.DL, 0, Q.AC, 2281ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines Q.CxtI, Q.DT); 2282d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNegative) 2283f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 2284ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (LHSKnownNonNegative && 2285ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines isKnownNonZero(LHS, Q.DL, 0, Q.AC, Q.CxtI, Q.DT)) 2286f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 2287d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands break; 2288d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands } 2289d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands } 2290d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands 2291d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands // See if we are doing a comparison with a constant integer. 2292210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) { 22933a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // Rule out tautological comparisons (eg., ult 0 or uge 0). 22943a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky ConstantRange RHS_CR = ICmpInst::makeConstantRange(Pred, CI->getValue()); 22953a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (RHS_CR.isEmptySet()) 22963a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky return ConstantInt::getFalse(CI->getContext()); 22973a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (RHS_CR.isFullSet()) 22983a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky return ConstantInt::getTrue(CI->getContext()); 22993a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky 23003a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // Many binary operators with constant RHS have easy to compute constant 23013a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // range. Use them to check whether the comparison is a tautology. 2302dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines unsigned Width = CI->getBitWidth(); 23033a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt Lower = APInt(Width, 0); 23043a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt Upper = APInt(Width, 0); 23053a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky ConstantInt *CI2; 23063a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (match(LHS, m_URem(m_Value(), m_ConstantInt(CI2)))) { 23073a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'urem x, CI2' produces [0, CI2). 23083a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = CI2->getValue(); 23093a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_SRem(m_Value(), m_ConstantInt(CI2)))) { 23103a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'srem x, CI2' produces (-|CI2|, |CI2|). 23113a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = CI2->getValue().abs(); 23123a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Lower = (-Upper) + 1; 2313c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands } else if (match(LHS, m_UDiv(m_ConstantInt(CI2), m_Value()))) { 2314c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands // 'udiv CI2, x' produces [0, CI2]. 23157781ae5be570940178295f6f808215089a3fe411Eli Friedman Upper = CI2->getValue() + 1; 23163a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_UDiv(m_Value(), m_ConstantInt(CI2)))) { 23173a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'udiv x, CI2' produces [0, UINT_MAX / CI2]. 23183a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt NegOne = APInt::getAllOnesValue(Width); 23193a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (!CI2->isZero()) 23203a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = NegOne.udiv(CI2->getValue()) + 1; 2321dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines } else if (match(LHS, m_SDiv(m_ConstantInt(CI2), m_Value()))) { 2322c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines if (CI2->isMinSignedValue()) { 2323c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines // 'sdiv INT_MIN, x' produces [INT_MIN, INT_MIN / -2]. 2324c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines Lower = CI2->getValue(); 2325c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines Upper = Lower.lshr(1) + 1; 2326c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines } else { 2327c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines // 'sdiv CI2, x' produces [-|CI2|, |CI2|]. 2328c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines Upper = CI2->getValue().abs() + 1; 2329c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines Lower = (-Upper) + 1; 2330c6a4f5e819217e1e12c458aed8e7b122e23a3a58Stephen Hines } 23313a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_SDiv(m_Value(), m_ConstantInt(CI2)))) { 23323a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt IntMin = APInt::getSignedMinValue(Width); 23333a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt IntMax = APInt::getSignedMaxValue(Width); 2334de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar const APInt &Val = CI2->getValue(); 233537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Val.isAllOnesValue()) { 233637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // 'sdiv x, -1' produces [INT_MIN + 1, INT_MAX] 233737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // where CI2 != -1 and CI2 != 0 and CI2 != 1 233837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines Lower = IntMin + 1; 233937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines Upper = IntMax + 1; 234037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines } else if (Val.countLeadingZeros() < Width - 1) { 234137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // 'sdiv x, CI2' produces [INT_MIN / CI2, INT_MAX / CI2] 234237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // where CI2 != -1 and CI2 != 0 and CI2 != 1 23433a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Lower = IntMin.sdiv(Val); 234437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines Upper = IntMax.sdiv(Val); 234537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Lower.sgt(Upper)) 234637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines std::swap(Lower, Upper); 234737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines Upper = Upper + 1; 234837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines assert(Upper != Lower && "Upper part of range has wrapped!"); 234937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines } 235037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines } else if (match(LHS, m_NUWShl(m_ConstantInt(CI2), m_Value()))) { 235137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // 'shl nuw CI2, x' produces [CI2, CI2 << CLZ(CI2)] 235237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines Lower = CI2->getValue(); 235337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines Upper = Lower.shl(Lower.countLeadingZeros()) + 1; 235437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines } else if (match(LHS, m_NSWShl(m_ConstantInt(CI2), m_Value()))) { 235537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (CI2->isNegative()) { 235637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // 'shl nsw CI2, x' produces [CI2 << CLO(CI2)-1, CI2] 235737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines unsigned ShiftAmount = CI2->getValue().countLeadingOnes() - 1; 235837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines Lower = CI2->getValue().shl(ShiftAmount); 235937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines Upper = CI2->getValue() + 1; 236037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines } else { 236137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // 'shl nsw CI2, x' produces [CI2, CI2 << CLZ(CI2)-1] 236237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines unsigned ShiftAmount = CI2->getValue().countLeadingZeros() - 1; 236337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines Lower = CI2->getValue(); 236437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines Upper = CI2->getValue().shl(ShiftAmount) + 1; 23653a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } 23663a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_LShr(m_Value(), m_ConstantInt(CI2)))) { 23673a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'lshr x, CI2' produces [0, UINT_MAX >> CI2]. 23683a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt NegOne = APInt::getAllOnesValue(Width); 23693a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (CI2->getValue().ult(Width)) 23703a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = NegOne.lshr(CI2->getValue()) + 1; 2371dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines } else if (match(LHS, m_LShr(m_ConstantInt(CI2), m_Value()))) { 2372dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // 'lshr CI2, x' produces [CI2 >> (Width-1), CI2]. 2373dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines unsigned ShiftAmount = Width - 1; 2374dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!CI2->isZero() && cast<BinaryOperator>(LHS)->isExact()) 2375dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines ShiftAmount = CI2->getValue().countTrailingZeros(); 2376dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Lower = CI2->getValue().lshr(ShiftAmount); 2377dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Upper = CI2->getValue() + 1; 23783a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_AShr(m_Value(), m_ConstantInt(CI2)))) { 23793a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'ashr x, CI2' produces [INT_MIN >> CI2, INT_MAX >> CI2]. 23803a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt IntMin = APInt::getSignedMinValue(Width); 23813a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt IntMax = APInt::getSignedMaxValue(Width); 23823a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (CI2->getValue().ult(Width)) { 23833a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Lower = IntMin.ashr(CI2->getValue()); 23843a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = IntMax.ashr(CI2->getValue()) + 1; 23853a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } 2386dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines } else if (match(LHS, m_AShr(m_ConstantInt(CI2), m_Value()))) { 2387dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines unsigned ShiftAmount = Width - 1; 2388dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!CI2->isZero() && cast<BinaryOperator>(LHS)->isExact()) 2389dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines ShiftAmount = CI2->getValue().countTrailingZeros(); 2390dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (CI2->isNegative()) { 2391dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // 'ashr CI2, x' produces [CI2, CI2 >> (Width-1)] 2392dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Lower = CI2->getValue(); 2393dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Upper = CI2->getValue().ashr(ShiftAmount) + 1; 2394dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines } else { 2395dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // 'ashr CI2, x' produces [CI2 >> (Width-1), CI2] 2396dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Lower = CI2->getValue().ashr(ShiftAmount); 2397dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Upper = CI2->getValue() + 1; 2398dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines } 23993a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_Or(m_Value(), m_ConstantInt(CI2)))) { 24003a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'or x, CI2' produces [CI2, UINT_MAX]. 24013a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Lower = CI2->getValue(); 24023a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_And(m_Value(), m_ConstantInt(CI2)))) { 24033a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'and x, CI2' produces [0, CI2]. 24043a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = CI2->getValue() + 1; 2405f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar } else if (match(LHS, m_NUWAdd(m_Value(), m_ConstantInt(CI2)))) { 2406f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar // 'add nuw x, CI2' produces [CI2, UINT_MAX]. 2407f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar Lower = CI2->getValue(); 24083a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } 2409f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar 2410f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar ConstantRange LHS_CR = Lower != Upper ? ConstantRange(Lower, Upper) 2411f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar : ConstantRange(Width, true); 2412f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar 2413f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar if (auto *I = dyn_cast<Instruction>(LHS)) 2414f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar if (auto *Ranges = I->getMetadata(LLVMContext::MD_range)) 2415f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar LHS_CR = LHS_CR.intersectWith(getConstantRangeFromMetadata(*Ranges)); 2416f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar 2417f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar if (!LHS_CR.isFullSet()) { 24183a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (RHS_CR.contains(LHS_CR)) 24193a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky return ConstantInt::getTrue(RHS->getContext()); 24203a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (RHS_CR.inverse().contains(LHS_CR)) 24213a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky return ConstantInt::getFalse(RHS->getContext()); 2422210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 2423210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 24241ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands 2425f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar // If both operands have range metadata, use the metadata 2426f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar // to simplify the comparison. 2427f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar if (isa<Instruction>(RHS) && isa<Instruction>(LHS)) { 2428f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar auto RHS_Instr = dyn_cast<Instruction>(RHS); 2429f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar auto LHS_Instr = dyn_cast<Instruction>(LHS); 2430f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar 2431f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar if (RHS_Instr->getMetadata(LLVMContext::MD_range) && 2432f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar LHS_Instr->getMetadata(LLVMContext::MD_range)) { 2433f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar auto RHS_CR = getConstantRangeFromMetadata( 2434f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar *RHS_Instr->getMetadata(LLVMContext::MD_range)); 2435f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar auto LHS_CR = getConstantRangeFromMetadata( 2436f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar *LHS_Instr->getMetadata(LLVMContext::MD_range)); 2437f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar 2438f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar auto Satisfied_CR = ConstantRange::makeSatisfyingICmpRegion(Pred, RHS_CR); 2439f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar if (Satisfied_CR.contains(LHS_CR)) 2440f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar return ConstantInt::getTrue(RHS->getContext()); 2441f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar 2442f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar auto InversedSatisfied_CR = ConstantRange::makeSatisfyingICmpRegion( 2443f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar CmpInst::getInversePredicate(Pred), RHS_CR); 2444f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar if (InversedSatisfied_CR.contains(LHS_CR)) 2445f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar return ConstantInt::getFalse(RHS->getContext()); 2446f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar } 2447f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar } 2448f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar 24499d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Compare of cast, for example (zext X) != 0 -> X != 0 24509d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (isa<CastInst>(LHS) && (isa<Constant>(RHS) || isa<CastInst>(RHS))) { 24519d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Instruction *LI = cast<CastInst>(LHS); 24529d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Value *SrcOp = LI->getOperand(0); 2453db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *SrcTy = SrcOp->getType(); 2454db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *DstTy = LI->getType(); 24559d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 24569d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Turn icmp (ptrtoint x), (ptrtoint/constant) into a compare of the input 24579d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // if the integer type is the same size as the pointer type. 24584c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar if (MaxRecurse && isa<PtrToIntInst>(LI) && 24594c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar Q.DL.getTypeSizeInBits(SrcTy) == DstTy->getPrimitiveSizeInBits()) { 24609d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Constant *RHSC = dyn_cast<Constant>(RHS)) { 24619d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Transfer the cast to the constant. 24629d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(Pred, SrcOp, 24639d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantExpr::getIntToPtr(RHSC, SrcTy), 24640aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse-1)) 24659d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 24669d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } else if (PtrToIntInst *RI = dyn_cast<PtrToIntInst>(RHS)) { 24679d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (RI->getOperand(0)->getType() == SrcTy) 24689d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Compare without the cast. 24699d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(Pred, SrcOp, RI->getOperand(0), 24700aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse-1)) 24719d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 24729d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 24739d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 24749d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 24759d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (isa<ZExtInst>(LHS)) { 24769d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Turn icmp (zext X), (zext Y) into a compare of X and Y if they have the 24779d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // same type. 24789d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (ZExtInst *RI = dyn_cast<ZExtInst>(RHS)) { 24799d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (MaxRecurse && SrcTy == RI->getOperand(0)->getType()) 24809d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Compare X and Y. Note that signed predicates become unsigned. 24819d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(ICmpInst::getUnsignedPredicate(Pred), 24820aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands SrcOp, RI->getOperand(0), Q, 24839d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands MaxRecurse-1)) 24849d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 24859d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 24869d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Turn icmp (zext X), Cst into a compare of X and Cst if Cst is extended 24879d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // too. If not, then try to deduce the result of the comparison. 24889d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands else if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) { 24899d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Compute the constant that would happen if we truncated to SrcTy then 24909d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // reextended to DstTy. 24919d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant *Trunc = ConstantExpr::getTrunc(CI, SrcTy); 24929d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant *RExt = ConstantExpr::getCast(CastInst::ZExt, Trunc, DstTy); 24939d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 24949d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // If the re-extended constant didn't change then this is effectively 24959d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // also a case of comparing two zero-extended values. 24969d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (RExt == CI && MaxRecurse) 24979d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(ICmpInst::getUnsignedPredicate(Pred), 24980aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands SrcOp, Trunc, Q, MaxRecurse-1)) 24999d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 25009d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 25019d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Otherwise the upper bits of LHS are zero while RHS has a non-zero bit 25029d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // there. Use this to work out the result of the comparison. 25039d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (RExt != CI) { 25049d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands switch (Pred) { 2505858143816d43e58b17bfd11cb1b57afbd7f0f893Craig Topper default: llvm_unreachable("Unknown ICmp predicate!"); 25069d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // LHS <u RHS. 25079d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_EQ: 25089d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_UGT: 25099d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_UGE: 25109d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return ConstantInt::getFalse(CI->getContext()); 25119d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 25129d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_NE: 25139d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_ULT: 25149d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_ULE: 25159d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return ConstantInt::getTrue(CI->getContext()); 25169d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 25179d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // LHS is non-negative. If RHS is negative then LHS >s LHS. If RHS 25189d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // is non-negative then LHS <s RHS. 25199d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SGT: 25209d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SGE: 25219d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return CI->getValue().isNegative() ? 25229d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getTrue(CI->getContext()) : 25239d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getFalse(CI->getContext()); 25249d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 25259d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SLT: 25269d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SLE: 25279d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return CI->getValue().isNegative() ? 25289d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getFalse(CI->getContext()) : 25299d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getTrue(CI->getContext()); 25309d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 25319d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 25329d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 25339d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 25349d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 25359d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (isa<SExtInst>(LHS)) { 25369d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Turn icmp (sext X), (sext Y) into a compare of X and Y if they have the 25379d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // same type. 25389d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (SExtInst *RI = dyn_cast<SExtInst>(RHS)) { 25399d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (MaxRecurse && SrcTy == RI->getOperand(0)->getType()) 25409d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Compare X and Y. Note that the predicate does not change. 25419d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(Pred, SrcOp, RI->getOperand(0), 25420aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse-1)) 25439d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 25449d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 25459d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Turn icmp (sext X), Cst into a compare of X and Cst if Cst is extended 25469d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // too. If not, then try to deduce the result of the comparison. 25479d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands else if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) { 25489d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Compute the constant that would happen if we truncated to SrcTy then 25499d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // reextended to DstTy. 25509d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant *Trunc = ConstantExpr::getTrunc(CI, SrcTy); 25519d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant *RExt = ConstantExpr::getCast(CastInst::SExt, Trunc, DstTy); 25529d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 25539d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // If the re-extended constant didn't change then this is effectively 25549d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // also a case of comparing two sign-extended values. 25559d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (RExt == CI && MaxRecurse) 25560aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyICmpInst(Pred, SrcOp, Trunc, Q, MaxRecurse-1)) 25579d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 25589d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 25599d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Otherwise the upper bits of LHS are all equal, while RHS has varying 25609d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // bits there. Use this to work out the result of the comparison. 25619d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (RExt != CI) { 25629d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands switch (Pred) { 2563858143816d43e58b17bfd11cb1b57afbd7f0f893Craig Topper default: llvm_unreachable("Unknown ICmp predicate!"); 25649d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_EQ: 25659d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return ConstantInt::getFalse(CI->getContext()); 25669d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_NE: 25679d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return ConstantInt::getTrue(CI->getContext()); 25689d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 25699d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // If RHS is non-negative then LHS <s RHS. If RHS is negative then 25709d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // LHS >s RHS. 25719d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SGT: 25729d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SGE: 25739d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return CI->getValue().isNegative() ? 25749d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getTrue(CI->getContext()) : 25759d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getFalse(CI->getContext()); 25769d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SLT: 25779d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SLE: 25789d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return CI->getValue().isNegative() ? 25799d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getFalse(CI->getContext()) : 25809d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getTrue(CI->getContext()); 25819d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 25829d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // If LHS is non-negative then LHS <u RHS. If LHS is negative then 25839d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // LHS >u RHS. 25849d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_UGT: 25859d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_UGE: 258694c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // Comparison is true iff the LHS <s 0. 25879d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (MaxRecurse) 25889d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(ICmpInst::ICMP_SLT, SrcOp, 25899d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant::getNullValue(SrcTy), 25900aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse-1)) 25919d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 25929d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands break; 25939d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_ULT: 25949d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_ULE: 259594c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // Comparison is true iff the LHS >=s 0. 25969d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (MaxRecurse) 25979d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(ICmpInst::ICMP_SGE, SrcOp, 25989d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant::getNullValue(SrcTy), 25990aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse-1)) 26009d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 26019d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands break; 26029d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 26039d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 26049d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 26059d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 26069d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 26079d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 2608f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar // icmp eq|ne X, Y -> false|true if X != Y 2609f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar if ((Pred == ICmpInst::ICMP_EQ || Pred == ICmpInst::ICMP_NE) && 2610f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar isKnownNonEqual(LHS, RHS, Q.DL, Q.AC, Q.CxtI, Q.DT)) { 2611f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar LLVMContext &Ctx = LHS->getType()->getContext(); 2612f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar return Pred == ICmpInst::ICMP_NE ? 2613f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar ConstantInt::getTrue(Ctx) : ConstantInt::getFalse(Ctx); 2614f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar } 2615de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar 261652fb846578714d14bbde9b28884a6a8729217677Duncan Sands // Special logic for binary operators. 261752fb846578714d14bbde9b28884a6a8729217677Duncan Sands BinaryOperator *LBO = dyn_cast<BinaryOperator>(LHS); 261852fb846578714d14bbde9b28884a6a8729217677Duncan Sands BinaryOperator *RBO = dyn_cast<BinaryOperator>(RHS); 261952fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (MaxRecurse && (LBO || RBO)) { 262052fb846578714d14bbde9b28884a6a8729217677Duncan Sands // Analyze the case when either LHS or RHS is an add instruction. 2621dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Value *A = nullptr, *B = nullptr, *C = nullptr, *D = nullptr; 262252fb846578714d14bbde9b28884a6a8729217677Duncan Sands // LHS = A + B (or A and B are null); RHS = C + D (or C and D are null). 262352fb846578714d14bbde9b28884a6a8729217677Duncan Sands bool NoLHSWrapProblem = false, NoRHSWrapProblem = false; 262452fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (LBO && LBO->getOpcode() == Instruction::Add) { 262552fb846578714d14bbde9b28884a6a8729217677Duncan Sands A = LBO->getOperand(0); B = LBO->getOperand(1); 262652fb846578714d14bbde9b28884a6a8729217677Duncan Sands NoLHSWrapProblem = ICmpInst::isEquality(Pred) || 262752fb846578714d14bbde9b28884a6a8729217677Duncan Sands (CmpInst::isUnsigned(Pred) && LBO->hasNoUnsignedWrap()) || 262852fb846578714d14bbde9b28884a6a8729217677Duncan Sands (CmpInst::isSigned(Pred) && LBO->hasNoSignedWrap()); 262952fb846578714d14bbde9b28884a6a8729217677Duncan Sands } 263052fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (RBO && RBO->getOpcode() == Instruction::Add) { 263152fb846578714d14bbde9b28884a6a8729217677Duncan Sands C = RBO->getOperand(0); D = RBO->getOperand(1); 263252fb846578714d14bbde9b28884a6a8729217677Duncan Sands NoRHSWrapProblem = ICmpInst::isEquality(Pred) || 263352fb846578714d14bbde9b28884a6a8729217677Duncan Sands (CmpInst::isUnsigned(Pred) && RBO->hasNoUnsignedWrap()) || 263452fb846578714d14bbde9b28884a6a8729217677Duncan Sands (CmpInst::isSigned(Pred) && RBO->hasNoSignedWrap()); 263552fb846578714d14bbde9b28884a6a8729217677Duncan Sands } 263652fb846578714d14bbde9b28884a6a8729217677Duncan Sands 263752fb846578714d14bbde9b28884a6a8729217677Duncan Sands // icmp (X+Y), X -> icmp Y, 0 for equalities or if there is no overflow. 263852fb846578714d14bbde9b28884a6a8729217677Duncan Sands if ((A == RHS || B == RHS) && NoLHSWrapProblem) 263952fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (Value *V = SimplifyICmpInst(Pred, A == RHS ? B : A, 264052fb846578714d14bbde9b28884a6a8729217677Duncan Sands Constant::getNullValue(RHS->getType()), 26410aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse-1)) 264252fb846578714d14bbde9b28884a6a8729217677Duncan Sands return V; 264352fb846578714d14bbde9b28884a6a8729217677Duncan Sands 264452fb846578714d14bbde9b28884a6a8729217677Duncan Sands // icmp X, (X+Y) -> icmp 0, Y for equalities or if there is no overflow. 264552fb846578714d14bbde9b28884a6a8729217677Duncan Sands if ((C == LHS || D == LHS) && NoRHSWrapProblem) 264652fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (Value *V = SimplifyICmpInst(Pred, 264752fb846578714d14bbde9b28884a6a8729217677Duncan Sands Constant::getNullValue(LHS->getType()), 26480aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands C == LHS ? D : C, Q, MaxRecurse-1)) 264952fb846578714d14bbde9b28884a6a8729217677Duncan Sands return V; 265052fb846578714d14bbde9b28884a6a8729217677Duncan Sands 265152fb846578714d14bbde9b28884a6a8729217677Duncan Sands // icmp (X+Y), (X+Z) -> icmp Y,Z for equalities or if there is no overflow. 265252fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (A && C && (A == C || A == D || B == C || B == D) && 265352fb846578714d14bbde9b28884a6a8729217677Duncan Sands NoLHSWrapProblem && NoRHSWrapProblem) { 265452fb846578714d14bbde9b28884a6a8729217677Duncan Sands // Determine Y and Z in the form icmp (X+Y), (X+Z). 2655aceb03eb58778ae4a2811d2c2bbd23e0e0cf49b5Duncan Sands Value *Y, *Z; 2656aceb03eb58778ae4a2811d2c2bbd23e0e0cf49b5Duncan Sands if (A == C) { 26574f0dfbb454ea8110459e2d1ee5f92e74cb3e8a5cDuncan Sands // C + B == C + D -> B == D 2658aceb03eb58778ae4a2811d2c2bbd23e0e0cf49b5Duncan Sands Y = B; 2659aceb03eb58778ae4a2811d2c2bbd23e0e0cf49b5Duncan Sands Z = D; 2660aceb03eb58778ae4a2811d2c2bbd23e0e0cf49b5Duncan Sands } else if (A == D) { 26614f0dfbb454ea8110459e2d1ee5f92e74cb3e8a5cDuncan Sands // D + B == C + D -> B == C 2662aceb03eb58778ae4a2811d2c2bbd23e0e0cf49b5Duncan Sands Y = B; 2663aceb03eb58778ae4a2811d2c2bbd23e0e0cf49b5Duncan Sands Z = C; 2664aceb03eb58778ae4a2811d2c2bbd23e0e0cf49b5Duncan Sands } else if (B == C) { 26654f0dfbb454ea8110459e2d1ee5f92e74cb3e8a5cDuncan Sands // A + C == C + D -> A == D 2666aceb03eb58778ae4a2811d2c2bbd23e0e0cf49b5Duncan Sands Y = A; 2667aceb03eb58778ae4a2811d2c2bbd23e0e0cf49b5Duncan Sands Z = D; 26684f0dfbb454ea8110459e2d1ee5f92e74cb3e8a5cDuncan Sands } else { 26694f0dfbb454ea8110459e2d1ee5f92e74cb3e8a5cDuncan Sands assert(B == D); 26704f0dfbb454ea8110459e2d1ee5f92e74cb3e8a5cDuncan Sands // A + D == C + D -> A == C 2671aceb03eb58778ae4a2811d2c2bbd23e0e0cf49b5Duncan Sands Y = A; 2672aceb03eb58778ae4a2811d2c2bbd23e0e0cf49b5Duncan Sands Z = C; 2673aceb03eb58778ae4a2811d2c2bbd23e0e0cf49b5Duncan Sands } 26740aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyICmpInst(Pred, Y, Z, Q, MaxRecurse-1)) 267552fb846578714d14bbde9b28884a6a8729217677Duncan Sands return V; 267652fb846578714d14bbde9b28884a6a8729217677Duncan Sands } 267752fb846578714d14bbde9b28884a6a8729217677Duncan Sands } 267852fb846578714d14bbde9b28884a6a8729217677Duncan Sands 2679de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar { 2680de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar Value *Y = nullptr; 2681de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar // icmp pred (or X, Y), X 2682de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (LBO && match(LBO, m_c_Or(m_Value(Y), m_Specific(RHS)))) { 2683de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (Pred == ICmpInst::ICMP_ULT) 2684de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return getFalse(ITy); 2685de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (Pred == ICmpInst::ICMP_UGE) 2686de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return getTrue(ITy); 2687de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar 2688de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (Pred == ICmpInst::ICMP_SLT || Pred == ICmpInst::ICMP_SGE) { 2689de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar bool RHSKnownNonNegative, RHSKnownNegative; 2690de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar bool YKnownNonNegative, YKnownNegative; 2691de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar ComputeSignBit(RHS, RHSKnownNonNegative, RHSKnownNegative, Q.DL, 0, 2692de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar Q.AC, Q.CxtI, Q.DT); 2693de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar ComputeSignBit(Y, YKnownNonNegative, YKnownNegative, Q.DL, 0, Q.AC, 2694de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar Q.CxtI, Q.DT); 2695de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (RHSKnownNonNegative && YKnownNegative) 2696de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return Pred == ICmpInst::ICMP_SLT ? getTrue(ITy) : getFalse(ITy); 2697de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (RHSKnownNegative || YKnownNonNegative) 2698de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return Pred == ICmpInst::ICMP_SLT ? getFalse(ITy) : getTrue(ITy); 2699de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar } 2700de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar } 2701de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar // icmp pred X, (or X, Y) 2702de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (RBO && match(RBO, m_c_Or(m_Value(Y), m_Specific(LHS)))) { 2703de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (Pred == ICmpInst::ICMP_ULE) 2704de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return getTrue(ITy); 2705de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (Pred == ICmpInst::ICMP_UGT) 2706de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return getFalse(ITy); 2707de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar 2708de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (Pred == ICmpInst::ICMP_SGT || Pred == ICmpInst::ICMP_SLE) { 2709de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar bool LHSKnownNonNegative, LHSKnownNegative; 2710de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar bool YKnownNonNegative, YKnownNegative; 2711de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, Q.DL, 0, 2712de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar Q.AC, Q.CxtI, Q.DT); 2713de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar ComputeSignBit(Y, YKnownNonNegative, YKnownNegative, Q.DL, 0, Q.AC, 2714de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar Q.CxtI, Q.DT); 2715de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (LHSKnownNonNegative && YKnownNegative) 2716de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return Pred == ICmpInst::ICMP_SGT ? getTrue(ITy) : getFalse(ITy); 2717de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (LHSKnownNegative || YKnownNonNegative) 2718de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return Pred == ICmpInst::ICMP_SGT ? getFalse(ITy) : getTrue(ITy); 2719de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar } 2720de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar } 2721ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines } 2722ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 2723ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // icmp pred (and X, Y), X 2724ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (LBO && match(LBO, m_CombineOr(m_And(m_Value(), m_Specific(RHS)), 2725ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines m_And(m_Specific(RHS), m_Value())))) { 2726ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (Pred == ICmpInst::ICMP_UGT) 2727ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return getFalse(ITy); 2728ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (Pred == ICmpInst::ICMP_ULE) 2729ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return getTrue(ITy); 2730ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines } 2731ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // icmp pred X, (and X, Y) 2732ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (RBO && match(RBO, m_CombineOr(m_And(m_Value(), m_Specific(LHS)), 2733ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines m_And(m_Specific(LHS), m_Value())))) { 2734ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (Pred == ICmpInst::ICMP_UGE) 2735ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return getTrue(ITy); 2736ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (Pred == ICmpInst::ICMP_ULT) 2737ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return getFalse(ITy); 2738ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines } 2739ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 2740dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines // 0 - (zext X) pred C 2741dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!CmpInst::isUnsigned(Pred) && match(LHS, m_Neg(m_ZExt(m_Value())))) { 2742dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (ConstantInt *RHSC = dyn_cast<ConstantInt>(RHS)) { 2743dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (RHSC->getValue().isStrictlyPositive()) { 2744dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (Pred == ICmpInst::ICMP_SLT) 2745dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return ConstantInt::getTrue(RHSC->getContext()); 2746dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (Pred == ICmpInst::ICMP_SGE) 2747dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return ConstantInt::getFalse(RHSC->getContext()); 2748dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (Pred == ICmpInst::ICMP_EQ) 2749dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return ConstantInt::getFalse(RHSC->getContext()); 2750dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (Pred == ICmpInst::ICMP_NE) 2751dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return ConstantInt::getTrue(RHSC->getContext()); 2752dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines } 2753dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (RHSC->getValue().isNonNegative()) { 2754dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (Pred == ICmpInst::ICMP_SLE) 2755dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return ConstantInt::getTrue(RHSC->getContext()); 2756dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (Pred == ICmpInst::ICMP_SGT) 2757dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return ConstantInt::getFalse(RHSC->getContext()); 2758dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines } 2759dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines } 2760dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines } 2761dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 27628a23270ce60fdd5dafa1c8dfbf9f46c8efe244b7Nick Lewycky // icmp pred (urem X, Y), Y 276384dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky if (LBO && match(LBO, m_URem(m_Value(), m_Specific(RHS)))) { 2764786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky bool KnownNonNegative, KnownNegative; 276588cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky switch (Pred) { 276688cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky default: 276788cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky break; 2768786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky case ICmpInst::ICMP_SGT: 2769786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky case ICmpInst::ICMP_SGE: 2770ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines ComputeSignBit(RHS, KnownNonNegative, KnownNegative, Q.DL, 0, Q.AC, 2771ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines Q.CxtI, Q.DT); 2772786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky if (!KnownNonNegative) 2773786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky break; 2774786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky // fall-through 277588cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky case ICmpInst::ICMP_EQ: 277688cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky case ICmpInst::ICMP_UGT: 277788cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky case ICmpInst::ICMP_UGE: 2778f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 2779786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky case ICmpInst::ICMP_SLT: 2780786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky case ICmpInst::ICMP_SLE: 2781ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines ComputeSignBit(RHS, KnownNonNegative, KnownNegative, Q.DL, 0, Q.AC, 2782ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines Q.CxtI, Q.DT); 2783786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky if (!KnownNonNegative) 2784786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky break; 2785786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky // fall-through 278688cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky case ICmpInst::ICMP_NE: 278788cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky case ICmpInst::ICMP_ULT: 278888cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky case ICmpInst::ICMP_ULE: 2789f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 279088cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky } 279188cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky } 27928a23270ce60fdd5dafa1c8dfbf9f46c8efe244b7Nick Lewycky 27938a23270ce60fdd5dafa1c8dfbf9f46c8efe244b7Nick Lewycky // icmp pred X, (urem Y, X) 279484dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky if (RBO && match(RBO, m_URem(m_Value(), m_Specific(LHS)))) { 279584dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky bool KnownNonNegative, KnownNegative; 279684dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky switch (Pred) { 279784dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky default: 279884dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky break; 279984dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_SGT: 280084dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_SGE: 2801ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines ComputeSignBit(LHS, KnownNonNegative, KnownNegative, Q.DL, 0, Q.AC, 2802ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines Q.CxtI, Q.DT); 280384dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky if (!KnownNonNegative) 280484dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky break; 280584dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky // fall-through 2806a0e2f38b25ce7c51c22ed40d8a315fe1dd98926dNick Lewycky case ICmpInst::ICMP_NE: 280784dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_UGT: 280884dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_UGE: 2809f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 281084dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_SLT: 281184dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_SLE: 2812ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines ComputeSignBit(LHS, KnownNonNegative, KnownNegative, Q.DL, 0, Q.AC, 2813ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines Q.CxtI, Q.DT); 281484dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky if (!KnownNonNegative) 281584dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky break; 281684dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky // fall-through 2817a0e2f38b25ce7c51c22ed40d8a315fe1dd98926dNick Lewycky case ICmpInst::ICMP_EQ: 281884dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_ULT: 281984dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_ULE: 2820f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 282184dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky } 282284dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky } 282388cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky 2824de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar // x >> y <=u x 2825c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands // x udiv y <=u x. 2826de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (LBO && (match(LBO, m_LShr(m_Specific(RHS), m_Value())) || 2827de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar match(LBO, m_UDiv(m_Specific(RHS), m_Value())))) { 2828de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar // icmp pred (X op Y), X 2829c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands if (Pred == ICmpInst::ICMP_UGT) 2830c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands return getFalse(ITy); 2831c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands if (Pred == ICmpInst::ICMP_ULE) 2832c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands return getTrue(ITy); 2833c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands } 2834c65c747bc4ee7d3ca8463d33708bbb2aed38a809Duncan Sands 283537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // handle: 283637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // CI2 << X == CI 283737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // CI2 << X != CI 283837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // 283937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // where CI2 is a power of 2 and CI isn't 284037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (auto *CI = dyn_cast<ConstantInt>(RHS)) { 284137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const APInt *CI2Val, *CIVal = &CI->getValue(); 284237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (LBO && match(LBO, m_Shl(m_APInt(CI2Val), m_Value())) && 284337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines CI2Val->isPowerOf2()) { 284437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (!CIVal->isPowerOf2()) { 284537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // CI2 << X can equal zero in some circumstances, 284637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // this simplification is unsafe if CI is zero. 284737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // 284837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // We know it is safe if: 284937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // - The shift is nsw, we can't shift out the one bit. 285037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // - The shift is nuw, we can't shift out the one bit. 285137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // - CI2 is one 285237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // - CI isn't zero 285337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (LBO->hasNoSignedWrap() || LBO->hasNoUnsignedWrap() || 285437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines *CI2Val == 1 || !CI->isZero()) { 285537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Pred == ICmpInst::ICMP_EQ) 285637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return ConstantInt::getFalse(RHS->getContext()); 285737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Pred == ICmpInst::ICMP_NE) 285837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return ConstantInt::getTrue(RHS->getContext()); 285937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines } 286037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines } 286137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (CIVal->isSignBit() && *CI2Val == 1) { 286237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Pred == ICmpInst::ICMP_UGT) 286337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return ConstantInt::getFalse(RHS->getContext()); 286437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Pred == ICmpInst::ICMP_ULE) 286537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return ConstantInt::getTrue(RHS->getContext()); 286637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines } 286737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines } 286837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines } 286937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines 287058bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (MaxRecurse && LBO && RBO && LBO->getOpcode() == RBO->getOpcode() && 287158bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky LBO->getOperand(1) == RBO->getOperand(1)) { 287258bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky switch (LBO->getOpcode()) { 287358bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky default: break; 287458bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::UDiv: 287558bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::LShr: 287658bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (ICmpInst::isSigned(Pred)) 287758bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 287858bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky // fall-through 287958bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::SDiv: 288058bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::AShr: 2881b6e7cd655c6ee119dbeacc321ee92387f983edb0Eli Friedman if (!LBO->isExact() || !RBO->isExact()) 288258bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 288358bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (Value *V = SimplifyICmpInst(Pred, LBO->getOperand(0), 28840aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands RBO->getOperand(0), Q, MaxRecurse-1)) 288558bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky return V; 288658bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 288758bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::Shl: { 2888c9d904ee2ca36ab6238ed93c7ad2ea67b5fd0a23Duncan Sands bool NUW = LBO->hasNoUnsignedWrap() && RBO->hasNoUnsignedWrap(); 288958bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky bool NSW = LBO->hasNoSignedWrap() && RBO->hasNoSignedWrap(); 289058bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (!NUW && !NSW) 289158bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 289258bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (!NSW && ICmpInst::isSigned(Pred)) 289358bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 289458bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (Value *V = SimplifyICmpInst(Pred, LBO->getOperand(0), 28950aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands RBO->getOperand(0), Q, MaxRecurse-1)) 289658bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky return V; 289758bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 289858bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky } 289958bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky } 290058bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky } 290158bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky 2902ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Simplify comparisons involving max/min. 2903ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands Value *A, *B; 2904ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands CmpInst::Predicate P = CmpInst::BAD_ICMP_PREDICATE; 290594c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru CmpInst::Predicate EqP; // Chosen so that "A == max/min(A,B)" iff "A EqP B". 2906ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands 29078140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Signed variants on "max(a,b)>=a -> true". 2908ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (match(LHS, m_SMax(m_Value(A), m_Value(B))) && (A == RHS || B == RHS)) { 2909ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != RHS) std::swap(A, B); // smax(A, B) pred A. 291094c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru EqP = CmpInst::ICMP_SGE; // "A == smax(A, B)" iff "A sge B". 2911ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as smax(A, B) pred A. 2912ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = Pred; 2913ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } else if (match(RHS, m_SMax(m_Value(A), m_Value(B))) && 2914ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands (A == LHS || B == LHS)) { 2915ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != LHS) std::swap(A, B); // A pred smax(A, B). 291694c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru EqP = CmpInst::ICMP_SGE; // "A == smax(A, B)" iff "A sge B". 2917ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as smax(A, B) swapped-pred A. 2918ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = CmpInst::getSwappedPredicate(Pred); 2919ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } else if (match(LHS, m_SMin(m_Value(A), m_Value(B))) && 2920ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands (A == RHS || B == RHS)) { 2921ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != RHS) std::swap(A, B); // smin(A, B) pred A. 292294c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru EqP = CmpInst::ICMP_SLE; // "A == smin(A, B)" iff "A sle B". 2923ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as smax(-A, -B) swapped-pred -A. 2924ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Note that we do not need to actually form -A or -B thanks to EqP. 2925ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = CmpInst::getSwappedPredicate(Pred); 2926ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } else if (match(RHS, m_SMin(m_Value(A), m_Value(B))) && 2927ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands (A == LHS || B == LHS)) { 2928ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != LHS) std::swap(A, B); // A pred smin(A, B). 292994c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru EqP = CmpInst::ICMP_SLE; // "A == smin(A, B)" iff "A sle B". 2930ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as smax(-A, -B) pred -A. 2931ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Note that we do not need to actually form -A or -B thanks to EqP. 2932ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = Pred; 2933ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } 2934ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (P != CmpInst::BAD_ICMP_PREDICATE) { 2935ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Cases correspond to "max(A, B) p A". 2936ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands switch (P) { 2937ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands default: 2938ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands break; 2939ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_EQ: 2940ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_SLE: 2941e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Equivalent to "A EqP B". This may be the same as the condition tested 2942e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // in the max/min; if so, we can just return that. 2943e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(LHS, EqP, A, B)) 2944e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2945e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(RHS, EqP, A, B)) 2946e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2947e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Otherwise, see if "A EqP B" simplifies. 2948ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (MaxRecurse) 29490aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyICmpInst(EqP, A, B, Q, MaxRecurse-1)) 2950ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands return V; 2951ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands break; 2952ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_NE: 2953e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands case CmpInst::ICMP_SGT: { 2954e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands CmpInst::Predicate InvEqP = CmpInst::getInversePredicate(EqP); 2955e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Equivalent to "A InvEqP B". This may be the same as the condition 2956e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // tested in the max/min; if so, we can just return that. 2957e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(LHS, InvEqP, A, B)) 2958e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2959e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(RHS, InvEqP, A, B)) 2960e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2961e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Otherwise, see if "A InvEqP B" simplifies. 2962ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (MaxRecurse) 29630aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyICmpInst(InvEqP, A, B, Q, MaxRecurse-1)) 2964ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands return V; 2965ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands break; 2966e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands } 2967ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_SGE: 2968ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Always true. 2969f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 2970ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_SLT: 2971ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Always false. 2972f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 2973ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } 2974ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } 2975ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands 29768140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Unsigned variants on "max(a,b)>=a -> true". 2977ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = CmpInst::BAD_ICMP_PREDICATE; 2978ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (match(LHS, m_UMax(m_Value(A), m_Value(B))) && (A == RHS || B == RHS)) { 2979ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != RHS) std::swap(A, B); // umax(A, B) pred A. 298094c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru EqP = CmpInst::ICMP_UGE; // "A == umax(A, B)" iff "A uge B". 2981ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as umax(A, B) pred A. 2982ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = Pred; 2983ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } else if (match(RHS, m_UMax(m_Value(A), m_Value(B))) && 2984ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands (A == LHS || B == LHS)) { 2985ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != LHS) std::swap(A, B); // A pred umax(A, B). 298694c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru EqP = CmpInst::ICMP_UGE; // "A == umax(A, B)" iff "A uge B". 2987ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as umax(A, B) swapped-pred A. 2988ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = CmpInst::getSwappedPredicate(Pred); 2989ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } else if (match(LHS, m_UMin(m_Value(A), m_Value(B))) && 2990ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands (A == RHS || B == RHS)) { 2991ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != RHS) std::swap(A, B); // umin(A, B) pred A. 299294c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru EqP = CmpInst::ICMP_ULE; // "A == umin(A, B)" iff "A ule B". 2993ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as umax(-A, -B) swapped-pred -A. 2994ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Note that we do not need to actually form -A or -B thanks to EqP. 2995ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = CmpInst::getSwappedPredicate(Pred); 2996ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } else if (match(RHS, m_UMin(m_Value(A), m_Value(B))) && 2997ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands (A == LHS || B == LHS)) { 2998ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != LHS) std::swap(A, B); // A pred umin(A, B). 299994c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru EqP = CmpInst::ICMP_ULE; // "A == umin(A, B)" iff "A ule B". 3000ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as umax(-A, -B) pred -A. 3001ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Note that we do not need to actually form -A or -B thanks to EqP. 3002ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = Pred; 3003ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } 3004ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (P != CmpInst::BAD_ICMP_PREDICATE) { 3005ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Cases correspond to "max(A, B) p A". 3006ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands switch (P) { 3007ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands default: 3008ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands break; 3009ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_EQ: 3010ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_ULE: 3011e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Equivalent to "A EqP B". This may be the same as the condition tested 3012e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // in the max/min; if so, we can just return that. 3013e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(LHS, EqP, A, B)) 3014e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 3015e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(RHS, EqP, A, B)) 3016e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 3017e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Otherwise, see if "A EqP B" simplifies. 3018ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (MaxRecurse) 30190aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyICmpInst(EqP, A, B, Q, MaxRecurse-1)) 3020ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands return V; 3021ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands break; 3022ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_NE: 3023e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands case CmpInst::ICMP_UGT: { 3024e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands CmpInst::Predicate InvEqP = CmpInst::getInversePredicate(EqP); 3025e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Equivalent to "A InvEqP B". This may be the same as the condition 3026e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // tested in the max/min; if so, we can just return that. 3027e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(LHS, InvEqP, A, B)) 3028e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 3029e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(RHS, InvEqP, A, B)) 3030e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 3031e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Otherwise, see if "A InvEqP B" simplifies. 3032ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (MaxRecurse) 30330aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyICmpInst(InvEqP, A, B, Q, MaxRecurse-1)) 3034ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands return V; 3035ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands break; 3036e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands } 3037ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_UGE: 3038ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Always true. 3039f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 3040ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_ULT: 3041ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Always false. 3042f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 3043ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } 3044ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } 3045ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands 30468140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Variants on "max(x,y) >= min(x,z)". 30478140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands Value *C, *D; 30488140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (match(LHS, m_SMax(m_Value(A), m_Value(B))) && 30498140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands match(RHS, m_SMin(m_Value(C), m_Value(D))) && 30508140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands (A == C || A == D || B == C || B == D)) { 30518140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // max(x, ?) pred min(x, ?). 30528140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_SGE) 30538140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always true. 3054f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 30558140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_SLT) 30568140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always false. 3057f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 30588140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands } else if (match(LHS, m_SMin(m_Value(A), m_Value(B))) && 30598140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands match(RHS, m_SMax(m_Value(C), m_Value(D))) && 30608140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands (A == C || A == D || B == C || B == D)) { 30618140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // min(x, ?) pred max(x, ?). 30628140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_SLE) 30638140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always true. 3064f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 30658140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_SGT) 30668140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always false. 3067f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 30688140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands } else if (match(LHS, m_UMax(m_Value(A), m_Value(B))) && 30698140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands match(RHS, m_UMin(m_Value(C), m_Value(D))) && 30708140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands (A == C || A == D || B == C || B == D)) { 30718140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // max(x, ?) pred min(x, ?). 30728140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_UGE) 30738140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always true. 3074f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 30758140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_ULT) 30768140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always false. 3077f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 30788140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands } else if (match(LHS, m_UMin(m_Value(A), m_Value(B))) && 30798140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands match(RHS, m_UMax(m_Value(C), m_Value(D))) && 30808140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands (A == C || A == D || B == C || B == D)) { 30818140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // min(x, ?) pred max(x, ?). 30828140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_ULE) 30838140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always true. 3084f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 30858140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_UGT) 30868140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always false. 3087f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 30888140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands } 30898140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands 309058725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth // Simplify comparisons of related pointers using a powerful, recursive 309158725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth // GEP-walk when we have target data available.. 30923e3de565e9c7258fb97773b3a64fc091355cb2deDan Gohman if (LHS->getType()->isPointerTy()) 3093de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (auto *C = computePointerICmp(Q.DL, Q.TLI, Q.DT, Pred, Q.CxtI, LHS, RHS)) 309458725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth return C; 309558725a66c02865686c70132e8b9bd231eb66da63Chandler Carruth 3096f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky if (GetElementPtrInst *GLHS = dyn_cast<GetElementPtrInst>(LHS)) { 3097f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky if (GEPOperator *GRHS = dyn_cast<GEPOperator>(RHS)) { 3098f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky if (GLHS->getPointerOperand() == GRHS->getPointerOperand() && 3099f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky GLHS->hasAllConstantIndices() && GRHS->hasAllConstantIndices() && 3100f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky (ICmpInst::isEquality(Pred) || 3101f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky (GLHS->isInBounds() && GRHS->isInBounds() && 3102f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky Pred == ICmpInst::getSignedPredicate(Pred)))) { 3103f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky // The bases are equal and the indices are constant. Build a constant 3104f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky // expression GEP with the same indices and a null base pointer to see 3105f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky // what constant folding can make out of it. 3106f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky Constant *Null = Constant::getNullValue(GLHS->getPointerOperandType()); 3107f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky SmallVector<Value *, 4> IndicesLHS(GLHS->idx_begin(), GLHS->idx_end()); 31080c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar Constant *NewLHS = ConstantExpr::getGetElementPtr( 31090c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar GLHS->getSourceElementType(), Null, IndicesLHS); 3110f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky 3111f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky SmallVector<Value *, 4> IndicesRHS(GRHS->idx_begin(), GRHS->idx_end()); 31120c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar Constant *NewRHS = ConstantExpr::getGetElementPtr( 31130c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar GLHS->getSourceElementType(), Null, IndicesRHS); 3114f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky return ConstantExpr::getICmp(Pred, NewLHS, NewRHS); 3115f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky } 3116f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky } 3117f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky } 3118f7087ea5088d58e81f08a3eeb39ba46fa18d0fd4Nick Lewycky 311937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // If a bit is known to be zero for A and known to be one for B, 312037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // then A and B cannot be equal. 312137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (ICmpInst::isEquality(Pred)) { 312237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) { 312337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines uint32_t BitWidth = CI->getBitWidth(); 312437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines APInt LHSKnownZero(BitWidth, 0); 312537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines APInt LHSKnownOne(BitWidth, 0); 3126ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines computeKnownBits(LHS, LHSKnownZero, LHSKnownOne, Q.DL, /*Depth=*/0, Q.AC, 312737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines Q.CxtI, Q.DT); 312837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const APInt &RHSVal = CI->getValue(); 312937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (((LHSKnownZero & RHSVal) != 0) || ((LHSKnownOne & ~RHSVal) != 0)) 313037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return Pred == ICmpInst::ICMP_EQ 313137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines ? ConstantInt::getFalse(CI->getContext()) 313237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines : ConstantInt::getTrue(CI->getContext()); 313337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines } 313437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines } 313537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines 31361ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands // If the comparison is with the result of a select instruction, check whether 31371ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands // comparing with either branch of the select always yields the same value. 31380312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<SelectInst>(LHS) || isa<SelectInst>(RHS)) 31390aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadCmpOverSelect(Pred, LHS, RHS, Q, MaxRecurse)) 3140a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return V; 3141a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 3142a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the comparison is with the result of a phi instruction, check whether 3143a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // doing the compare with each incoming phi value yields a common result. 31440312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<PHINode>(LHS) || isa<PHINode>(RHS)) 31450aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadCmpOverPHI(Pred, LHS, RHS, Q, MaxRecurse)) 31463bbb0cc42b67b4bf2c488285666999963bab0f7eDuncan Sands return V; 31471ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands 3148dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 31499dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner} 31509dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 3151a74a58c83be492b7d5b7383656f049909394cff4Duncan SandsValue *llvm::SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS, 31524c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar const DataLayout &DL, 3153618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 3154ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const DominatorTree *DT, AssumptionCache *AC, 3155de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar const Instruction *CxtI) { 3156ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return ::SimplifyICmpInst(Predicate, LHS, RHS, Query(DL, TLI, DT, AC, CxtI), 31570aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands RecursionLimit); 3158a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 3159a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 3160de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Given operands for an FCmpInst, see if we can fold the result. 3161de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// If not, this returns null. 3162a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *SimplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS, 3163f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar FastMathFlags FMF, const Query &Q, 3164f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar unsigned MaxRecurse) { 31659dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner CmpInst::Predicate Pred = (CmpInst::Predicate)Predicate; 31669dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner assert(CmpInst::isFPPredicate(Pred) && "Not an FP compare!"); 31679dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 3168d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(LHS)) { 31699dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner if (Constant *CRHS = dyn_cast<Constant>(RHS)) 317036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return ConstantFoldCompareInstOperands(Pred, CLHS, CRHS, Q.DL, Q.TLI); 317112a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 3172d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // If we have a constant, make sure it is on the RHS. 3173d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner std::swap(LHS, RHS); 3174d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Pred = CmpInst::getSwappedPredicate(Pred); 3175d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 317612a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 3177210c5d4880b525e064088b6fec713260128c16ebChris Lattner // Fold trivial predicates. 3178210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (Pred == FCmpInst::FCMP_FALSE) 3179210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(GetCompareTy(LHS), 0); 3180210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (Pred == FCmpInst::FCMP_TRUE) 3181210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(GetCompareTy(LHS), 1); 3182210c5d4880b525e064088b6fec713260128c16ebChris Lattner 3183f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar // UNO/ORD predicates can be trivially folded if NaNs are ignored. 3184f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar if (FMF.noNaNs()) { 3185f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar if (Pred == FCmpInst::FCMP_UNO) 3186f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar return ConstantInt::get(GetCompareTy(LHS), 0); 3187f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar if (Pred == FCmpInst::FCMP_ORD) 3188f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar return ConstantInt::get(GetCompareTy(LHS), 1); 3189f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar } 3190f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar 31914c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar // fcmp pred x, undef and fcmp pred undef, x 31924c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar // fold to true if unordered, false if ordered 31934c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar if (isa<UndefValue>(LHS) || isa<UndefValue>(RHS)) { 31944c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar // Choosing NaN for the undef will always make unordered comparison succeed 31954c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar // and ordered comparison fail. 31964c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar return ConstantInt::get(GetCompareTy(LHS), CmpInst::isUnordered(Pred)); 31974c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar } 3198210c5d4880b525e064088b6fec713260128c16ebChris Lattner 3199210c5d4880b525e064088b6fec713260128c16ebChris Lattner // fcmp x,x -> true/false. Not all compares are foldable. 3200124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (LHS == RHS) { 3201210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (CmpInst::isTrueWhenEqual(Pred)) 3202210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(GetCompareTy(LHS), 1); 3203210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (CmpInst::isFalseWhenEqual(Pred)) 3204210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(GetCompareTy(LHS), 0); 3205210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 320612a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 3207210c5d4880b525e064088b6fec713260128c16ebChris Lattner // Handle fcmp with constant RHS 3208de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar const ConstantFP *CFP = nullptr; 3209de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (const auto *RHSC = dyn_cast<Constant>(RHS)) { 3210de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (RHS->getType()->isVectorTy()) 3211de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar CFP = dyn_cast_or_null<ConstantFP>(RHSC->getSplatValue()); 3212de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar else 3213de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar CFP = dyn_cast<ConstantFP>(RHSC); 3214de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar } 3215de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (CFP) { 3216210c5d4880b525e064088b6fec713260128c16ebChris Lattner // If the constant is a nan, see if we can fold the comparison based on it. 3217ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (CFP->getValueAPF().isNaN()) { 3218ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (FCmpInst::isOrdered(Pred)) // True "if ordered and foo" 3219ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return ConstantInt::getFalse(CFP->getContext()); 3220ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines assert(FCmpInst::isUnordered(Pred) && 3221ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines "Comparison must be either ordered or unordered!"); 3222ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // True if unordered. 3223de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return ConstantInt::get(GetCompareTy(LHS), 1); 3224ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines } 3225ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // Check whether the constant is an infinity. 3226ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (CFP->getValueAPF().isInfinity()) { 3227ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (CFP->getValueAPF().isNegative()) { 3228ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines switch (Pred) { 3229ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines case FCmpInst::FCMP_OLT: 3230ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // No value is ordered and less than negative infinity. 3231de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return ConstantInt::get(GetCompareTy(LHS), 0); 3232ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines case FCmpInst::FCMP_UGE: 3233ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // All values are unordered with or at least negative infinity. 3234de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return ConstantInt::get(GetCompareTy(LHS), 1); 3235ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines default: 3236ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines break; 3237ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines } 3238ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines } else { 3239ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines switch (Pred) { 3240ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines case FCmpInst::FCMP_OGT: 3241ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // No value is ordered and greater than infinity. 3242de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return ConstantInt::get(GetCompareTy(LHS), 0); 3243ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines case FCmpInst::FCMP_ULE: 3244ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // All values are unordered with and at most infinity. 3245de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return ConstantInt::get(GetCompareTy(LHS), 1); 3246ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines default: 3247ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines break; 32486b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } 32496b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } 3250210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 3251ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (CFP->getValueAPF().isZero()) { 3252ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines switch (Pred) { 3253ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines case FCmpInst::FCMP_UGE: 3254de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (CannotBeOrderedLessThanZero(LHS, Q.TLI)) 3255de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return ConstantInt::get(GetCompareTy(LHS), 1); 3256ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines break; 3257ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines case FCmpInst::FCMP_OLT: 3258ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // X < 0 3259de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (CannotBeOrderedLessThanZero(LHS, Q.TLI)) 3260de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return ConstantInt::get(GetCompareTy(LHS), 0); 3261ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines break; 3262ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines default: 3263ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines break; 3264ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines } 3265ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines } 3266210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 326712a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 326892826def593df7a422c7b07f09342febce81ddd3Duncan Sands // If the comparison is with the result of a select instruction, check whether 326992826def593df7a422c7b07f09342febce81ddd3Duncan Sands // comparing with either branch of the select always yields the same value. 32700312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<SelectInst>(LHS) || isa<SelectInst>(RHS)) 32710aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadCmpOverSelect(Pred, LHS, RHS, Q, MaxRecurse)) 3272a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return V; 3273a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 3274a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the comparison is with the result of a phi instruction, check whether 3275a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // doing the compare with each incoming phi value yields a common result. 32760312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<PHINode>(LHS) || isa<PHINode>(RHS)) 32770aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadCmpOverPHI(Pred, LHS, RHS, Q, MaxRecurse)) 32783bbb0cc42b67b4bf2c488285666999963bab0f7eDuncan Sands return V; 327992826def593df7a422c7b07f09342febce81ddd3Duncan Sands 3280dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 32819f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner} 32829f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 3283a74a58c83be492b7d5b7383656f049909394cff4Duncan SandsValue *llvm::SimplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS, 3284f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar FastMathFlags FMF, const DataLayout &DL, 3285618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 3286ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const DominatorTree *DT, AssumptionCache *AC, 328737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const Instruction *CxtI) { 3288f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar return ::SimplifyFCmpInst(Predicate, LHS, RHS, FMF, 3289f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar Query(DL, TLI, DT, AC, CxtI), RecursionLimit); 3290a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 3291a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 3292de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// See if V simplifies when its operand Op is replaced with RepOp. 32936948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainarstatic const Value *SimplifyWithOpReplaced(Value *V, Value *Op, Value *RepOp, 32946948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar const Query &Q, 32956948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar unsigned MaxRecurse) { 32966948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar // Trivial replacement. 32976948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (V == Op) 32986948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar return RepOp; 32996948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar 33006948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar auto *I = dyn_cast<Instruction>(V); 33016948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (!I) 33026948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar return nullptr; 33036948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar 33046948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar // If this is a binary operator, try to simplify it with the replaced op. 33056948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (auto *B = dyn_cast<BinaryOperator>(I)) { 33066948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar // Consider: 33076948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar // %cmp = icmp eq i32 %x, 2147483647 33086948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar // %add = add nsw i32 %x, 1 33096948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar // %sel = select i1 %cmp, i32 -2147483648, i32 %add 33106948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar // 33116948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar // We can't replace %sel with %add unless we strip away the flags. 33126948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (isa<OverflowingBinaryOperator>(B)) 33136948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (B->hasNoSignedWrap() || B->hasNoUnsignedWrap()) 33146948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar return nullptr; 33156948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (isa<PossiblyExactOperator>(B)) 33166948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (B->isExact()) 33176948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar return nullptr; 33186948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar 33196948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (MaxRecurse) { 33206948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (B->getOperand(0) == Op) 33216948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar return SimplifyBinOp(B->getOpcode(), RepOp, B->getOperand(1), Q, 33226948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar MaxRecurse - 1); 33236948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (B->getOperand(1) == Op) 33246948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar return SimplifyBinOp(B->getOpcode(), B->getOperand(0), RepOp, Q, 33256948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar MaxRecurse - 1); 33266948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar } 33276948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar } 33286948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar 33296948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar // Same for CmpInsts. 33306948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (CmpInst *C = dyn_cast<CmpInst>(I)) { 33316948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (MaxRecurse) { 33326948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (C->getOperand(0) == Op) 33336948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar return SimplifyCmpInst(C->getPredicate(), RepOp, C->getOperand(1), Q, 33346948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar MaxRecurse - 1); 33356948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (C->getOperand(1) == Op) 33366948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar return SimplifyCmpInst(C->getPredicate(), C->getOperand(0), RepOp, Q, 33376948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar MaxRecurse - 1); 33386948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar } 33396948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar } 33406948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar 33416948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar // TODO: We could hand off more cases to instsimplify here. 33426948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar 33436948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar // If all operands are constant after substituting Op for RepOp then we can 33446948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar // constant fold the instruction. 33456948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (Constant *CRepOp = dyn_cast<Constant>(RepOp)) { 33466948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar // Build a list of all constant operands. 33476948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar SmallVector<Constant *, 8> ConstOps; 33486948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i) { 33496948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (I->getOperand(i) == Op) 33506948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar ConstOps.push_back(CRepOp); 33516948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar else if (Constant *COp = dyn_cast<Constant>(I->getOperand(i))) 33526948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar ConstOps.push_back(COp); 33536948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar else 33546948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar break; 33556948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar } 33566948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar 33576948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar // All operands were constants, fold it. 33586948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (ConstOps.size() == I->getNumOperands()) { 33596948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (CmpInst *C = dyn_cast<CmpInst>(I)) 33606948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar return ConstantFoldCompareInstOperands(C->getPredicate(), ConstOps[0], 33616948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar ConstOps[1], Q.DL, Q.TLI); 33626948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar 33636948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (LoadInst *LI = dyn_cast<LoadInst>(I)) 33646948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (!LI->isVolatile()) 3365de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return ConstantFoldLoadFromConstPtr(ConstOps[0], LI->getType(), Q.DL); 33666948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar 3367de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return ConstantFoldInstOperands(I, ConstOps, Q.DL, Q.TLI); 33686948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar } 33696948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar } 33706948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar 33716948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar return nullptr; 33726948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar} 33736948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar 3374de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Given operands for a SelectInst, see if we can fold the result. 3375de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// If not, this returns null. 33760aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifySelectInst(Value *CondVal, Value *TrueVal, 33770aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Value *FalseVal, const Query &Q, 33780aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands unsigned MaxRecurse) { 3379047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner // select true, X, Y -> X 3380047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner // select false, X, Y -> Y 338136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (Constant *CB = dyn_cast<Constant>(CondVal)) { 338236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (CB->isAllOnesValue()) 338336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return TrueVal; 338436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (CB->isNullValue()) 338536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return FalseVal; 338636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } 338712a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 3388047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner // select C, X, X -> X 3389124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (TrueVal == FalseVal) 3390047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return TrueVal; 339112a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 3392047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner if (isa<UndefValue>(CondVal)) { // select undef, X, Y -> X or Y 3393047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner if (isa<Constant>(TrueVal)) 3394047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return TrueVal; 3395047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return FalseVal; 3396047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner } 339768c0dbc14fb7599987fb3e27be4e12c1ac36535eDan Gohman if (isa<UndefValue>(TrueVal)) // select C, undef, X -> X 339868c0dbc14fb7599987fb3e27be4e12c1ac36535eDan Gohman return FalseVal; 339968c0dbc14fb7599987fb3e27be4e12c1ac36535eDan Gohman if (isa<UndefValue>(FalseVal)) // select C, X, undef -> X 340068c0dbc14fb7599987fb3e27be4e12c1ac36535eDan Gohman return TrueVal; 340112a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 34026948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (const auto *ICI = dyn_cast<ICmpInst>(CondVal)) { 34036948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar unsigned BitWidth = Q.DL.getTypeSizeInBits(TrueVal->getType()); 3404ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines ICmpInst::Predicate Pred = ICI->getPredicate(); 34056948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar Value *CmpLHS = ICI->getOperand(0); 34066948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar Value *CmpRHS = ICI->getOperand(1); 3407ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines APInt MinSignedValue = APInt::getSignBit(BitWidth); 3408ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines Value *X; 3409ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const APInt *Y; 3410ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines bool TrueWhenUnset; 3411ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines bool IsBitTest = false; 3412ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (ICmpInst::isEquality(Pred) && 34136948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar match(CmpLHS, m_And(m_Value(X), m_APInt(Y))) && 34146948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar match(CmpRHS, m_Zero())) { 3415ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines IsBitTest = true; 3416ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines TrueWhenUnset = Pred == ICmpInst::ICMP_EQ; 34176948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar } else if (Pred == ICmpInst::ICMP_SLT && match(CmpRHS, m_Zero())) { 34186948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar X = CmpLHS; 3419ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines Y = &MinSignedValue; 3420ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines IsBitTest = true; 3421ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines TrueWhenUnset = false; 34226948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar } else if (Pred == ICmpInst::ICMP_SGT && match(CmpRHS, m_AllOnes())) { 34236948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar X = CmpLHS; 3424ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines Y = &MinSignedValue; 3425ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines IsBitTest = true; 3426ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines TrueWhenUnset = true; 3427ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines } 3428ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (IsBitTest) { 3429ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const APInt *C; 3430ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // (X & Y) == 0 ? X & ~Y : X --> X 3431ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // (X & Y) != 0 ? X & ~Y : X --> X & ~Y 3432ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (FalseVal == X && match(TrueVal, m_And(m_Specific(X), m_APInt(C))) && 3433ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines *Y == ~*C) 3434ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return TrueWhenUnset ? FalseVal : TrueVal; 3435ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // (X & Y) == 0 ? X : X & ~Y --> X & ~Y 3436ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // (X & Y) != 0 ? X : X & ~Y --> X 3437ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (TrueVal == X && match(FalseVal, m_And(m_Specific(X), m_APInt(C))) && 3438ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines *Y == ~*C) 3439ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return TrueWhenUnset ? FalseVal : TrueVal; 3440ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 3441ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (Y->isPowerOf2()) { 3442ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // (X & Y) == 0 ? X | Y : X --> X | Y 3443ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // (X & Y) != 0 ? X | Y : X --> X 3444ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (FalseVal == X && match(TrueVal, m_Or(m_Specific(X), m_APInt(C))) && 3445ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines *Y == *C) 3446ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return TrueWhenUnset ? TrueVal : FalseVal; 3447ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // (X & Y) == 0 ? X : X | Y --> X 3448ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines // (X & Y) != 0 ? X : X | Y --> X | Y 3449ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines if (TrueVal == X && match(FalseVal, m_Or(m_Specific(X), m_APInt(C))) && 3450ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines *Y == *C) 3451ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return TrueWhenUnset ? TrueVal : FalseVal; 3452ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines } 3453ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines } 34546948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (ICI->hasOneUse()) { 34556948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar const APInt *C; 34566948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (match(CmpRHS, m_APInt(C))) { 34576948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar // X < MIN ? T : F --> F 34586948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (Pred == ICmpInst::ICMP_SLT && C->isMinSignedValue()) 34596948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar return FalseVal; 34606948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar // X < MIN ? T : F --> F 34616948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (Pred == ICmpInst::ICMP_ULT && C->isMinValue()) 34626948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar return FalseVal; 34636948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar // X > MAX ? T : F --> F 34646948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (Pred == ICmpInst::ICMP_SGT && C->isMaxSignedValue()) 34656948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar return FalseVal; 34666948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar // X > MAX ? T : F --> F 34676948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (Pred == ICmpInst::ICMP_UGT && C->isMaxValue()) 34686948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar return FalseVal; 34696948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar } 34706948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar } 34716948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar 34726948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar // If we have an equality comparison then we know the value in one of the 34736948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar // arms of the select. See if substituting this value into the arm and 34746948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar // simplifying the result yields the same value as the other arm. 34756948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (Pred == ICmpInst::ICMP_EQ) { 34766948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (SimplifyWithOpReplaced(FalseVal, CmpLHS, CmpRHS, Q, MaxRecurse) == 34776948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar TrueVal || 34786948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar SimplifyWithOpReplaced(FalseVal, CmpRHS, CmpLHS, Q, MaxRecurse) == 34796948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar TrueVal) 34806948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar return FalseVal; 34816948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (SimplifyWithOpReplaced(TrueVal, CmpLHS, CmpRHS, Q, MaxRecurse) == 34826948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar FalseVal || 34836948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar SimplifyWithOpReplaced(TrueVal, CmpRHS, CmpLHS, Q, MaxRecurse) == 34846948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar FalseVal) 34856948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar return FalseVal; 34866948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar } else if (Pred == ICmpInst::ICMP_NE) { 34876948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (SimplifyWithOpReplaced(TrueVal, CmpLHS, CmpRHS, Q, MaxRecurse) == 34886948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar FalseVal || 34896948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar SimplifyWithOpReplaced(TrueVal, CmpRHS, CmpLHS, Q, MaxRecurse) == 34906948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar FalseVal) 34916948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar return TrueVal; 34926948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (SimplifyWithOpReplaced(FalseVal, CmpLHS, CmpRHS, Q, MaxRecurse) == 34936948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar TrueVal || 34946948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar SimplifyWithOpReplaced(FalseVal, CmpRHS, CmpLHS, Q, MaxRecurse) == 34956948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar TrueVal) 34966948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar return TrueVal; 34976948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar } 3498ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines } 3499ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 3500dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 3501047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner} 3502047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner 35030aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan SandsValue *llvm::SimplifySelectInst(Value *Cond, Value *TrueVal, Value *FalseVal, 35044c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar const DataLayout &DL, 35050aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const TargetLibraryInfo *TLI, 3506ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const DominatorTree *DT, AssumptionCache *AC, 350737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const Instruction *CxtI) { 350837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return ::SimplifySelectInst(Cond, TrueVal, FalseVal, 3509ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines Query(DL, TLI, DT, AC, CxtI), RecursionLimit); 35100aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands} 35110aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands 3512de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Given operands for an GetElementPtrInst, see if we can fold the result. 3513de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// If not, this returns null. 35140c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainarstatic Value *SimplifyGEPInst(Type *SrcTy, ArrayRef<Value *> Ops, 35150c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar const Query &Q, unsigned) { 351685bbff6c94695f07cc1a9765b4d384ed18d2fd7cDuncan Sands // The type of the GEP pointer operand. 35170c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar unsigned AS = 35180c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar cast<PointerType>(Ops[0]->getType()->getScalarType())->getAddressSpace(); 351985bbff6c94695f07cc1a9765b4d384ed18d2fd7cDuncan Sands 3520c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner // getelementptr P -> P. 3521b9b54ebfed02f0654897d37e8a4448d3f8087558Jay Foad if (Ops.size() == 1) 3522c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner return Ops[0]; 3523c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner 352437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // Compute the (pointer) type returned by the GEP instruction. 35250c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar Type *LastType = GetElementPtrInst::getIndexedType(SrcTy, Ops.slice(1)); 352637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines Type *GEPTy = PointerType::get(LastType, AS); 352737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (VectorType *VT = dyn_cast<VectorType>(Ops[0]->getType())) 352837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines GEPTy = VectorType::get(GEPTy, VT->getNumElements()); 352937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines 353037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (isa<UndefValue>(Ops[0])) 353185bbff6c94695f07cc1a9765b4d384ed18d2fd7cDuncan Sands return UndefValue::get(GEPTy); 3532c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner 3533b9b54ebfed02f0654897d37e8a4448d3f8087558Jay Foad if (Ops.size() == 2) { 3534e60d79faf7ef7bc4847f9e5d067af00b98dced7bDuncan Sands // getelementptr P, 0 -> P. 353536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (match(Ops[1], m_Zero())) 353636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return Ops[0]; 353737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines 35380c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar Type *Ty = SrcTy; 35394c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar if (Ty->isSized()) { 354037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines Value *P; 354137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines uint64_t C; 35424c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar uint64_t TyAllocSize = Q.DL.getTypeAllocSize(Ty); 354337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // getelementptr P, N -> P if P points to a type of zero size. 354437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (TyAllocSize == 0) 3545e60d79faf7ef7bc4847f9e5d067af00b98dced7bDuncan Sands return Ops[0]; 354637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines 354737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // The following transforms are only safe if the ptrtoint cast 354837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // doesn't truncate the pointers. 354937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Ops[1]->getType()->getScalarSizeInBits() == 35504c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar Q.DL.getPointerSizeInBits(AS)) { 355137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines auto PtrToIntOrZero = [GEPTy](Value *P) -> Value * { 355237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (match(P, m_Zero())) 355337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return Constant::getNullValue(GEPTy); 355437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines Value *Temp; 355537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (match(P, m_PtrToInt(m_Value(Temp)))) 355637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Temp->getType() == GEPTy) 355737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return Temp; 355837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return nullptr; 355937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines }; 356037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines 356137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // getelementptr V, (sub P, V) -> P if P points to a type of size 1. 356237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (TyAllocSize == 1 && 356337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines match(Ops[1], m_Sub(m_Value(P), m_PtrToInt(m_Specific(Ops[0]))))) 356437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Value *R = PtrToIntOrZero(P)) 356537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return R; 356637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines 356737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // getelementptr V, (ashr (sub P, V), C) -> Q 356837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // if P points to a type of size 1 << C. 356937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (match(Ops[1], 357037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines m_AShr(m_Sub(m_Value(P), m_PtrToInt(m_Specific(Ops[0]))), 357137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines m_ConstantInt(C))) && 357237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines TyAllocSize == 1ULL << C) 357337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Value *R = PtrToIntOrZero(P)) 357437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return R; 357537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines 357637ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // getelementptr V, (sdiv (sub P, V), C) -> Q 357737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines // if P points to a type of size C. 357837ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (match(Ops[1], 357937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines m_SDiv(m_Sub(m_Value(P), m_PtrToInt(m_Specific(Ops[0]))), 358037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines m_SpecificInt(TyAllocSize)))) 358137ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines if (Value *R = PtrToIntOrZero(P)) 358237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return R; 358337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines } 3584e60d79faf7ef7bc4847f9e5d067af00b98dced7bDuncan Sands } 3585e60d79faf7ef7bc4847f9e5d067af00b98dced7bDuncan Sands } 358612a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 3587c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner // Check to see if this is constant foldable. 3588b9b54ebfed02f0654897d37e8a4448d3f8087558Jay Foad for (unsigned i = 0, e = Ops.size(); i != e; ++i) 3589c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner if (!isa<Constant>(Ops[i])) 3590dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 359112a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 35920c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar return ConstantExpr::getGetElementPtr(SrcTy, cast<Constant>(Ops[0]), 35930c7f116bb6950ef819323d855415b2f2b0aad987Pirama Arumuga Nainar Ops.slice(1)); 3594c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner} 3595c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner 3596de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga NainarValue *llvm::SimplifyGEPInst(Type *SrcTy, ArrayRef<Value *> Ops, 3597de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar const DataLayout &DL, 35980aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const TargetLibraryInfo *TLI, 3599ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const DominatorTree *DT, AssumptionCache *AC, 360037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const Instruction *CxtI) { 3601de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return ::SimplifyGEPInst(SrcTy, Ops, 3602de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar Query(DL, TLI, DT, AC, CxtI), RecursionLimit); 36030aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands} 36040aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands 3605de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Given operands for an InsertValueInst, see if we can fold the result. 3606de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// If not, this returns null. 36070aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyInsertValueInst(Value *Agg, Value *Val, 36080aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands ArrayRef<unsigned> Idxs, const Query &Q, 36090aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands unsigned) { 3610dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands if (Constant *CAgg = dyn_cast<Constant>(Agg)) 3611dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands if (Constant *CVal = dyn_cast<Constant>(Val)) 3612dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands return ConstantFoldInsertValueInstruction(CAgg, CVal, Idxs); 3613dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands 3614dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands // insertvalue x, undef, n -> x 3615dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands if (match(Val, m_Undef())) 3616dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands return Agg; 3617dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands 3618dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands // insertvalue x, (extractvalue y, n), n 3619dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands if (ExtractValueInst *EV = dyn_cast<ExtractValueInst>(Val)) 3620ae707bd5594e52a8b385760f99ff58aa8fede948Benjamin Kramer if (EV->getAggregateOperand()->getType() == Agg->getType() && 3621ae707bd5594e52a8b385760f99ff58aa8fede948Benjamin Kramer EV->getIndices() == Idxs) { 3622dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands // insertvalue undef, (extractvalue y, n), n -> y 3623dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands if (match(Agg, m_Undef())) 3624dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands return EV->getAggregateOperand(); 3625dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands 3626dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands // insertvalue y, (extractvalue y, n), n -> y 3627dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands if (Agg == EV->getAggregateOperand()) 3628dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands return Agg; 3629dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands } 3630dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands 3631dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 3632dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands} 3633dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands 3634ebe69fe11e48d322045d5949c83283927a0d790bStephen HinesValue *llvm::SimplifyInsertValueInst( 36354c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar Value *Agg, Value *Val, ArrayRef<unsigned> Idxs, const DataLayout &DL, 3636ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const TargetLibraryInfo *TLI, const DominatorTree *DT, AssumptionCache *AC, 3637ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const Instruction *CxtI) { 3638ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return ::SimplifyInsertValueInst(Agg, Val, Idxs, Query(DL, TLI, DT, AC, CxtI), 36390aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands RecursionLimit); 36400aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands} 36410aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands 3642de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Given operands for an ExtractValueInst, see if we can fold the result. 3643de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// If not, this returns null. 3644f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainarstatic Value *SimplifyExtractValueInst(Value *Agg, ArrayRef<unsigned> Idxs, 3645f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar const Query &, unsigned) { 3646f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar if (auto *CAgg = dyn_cast<Constant>(Agg)) 3647f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar return ConstantFoldExtractValueInstruction(CAgg, Idxs); 3648f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar 3649f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar // extractvalue x, (insertvalue y, elt, n), n -> elt 3650f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar unsigned NumIdxs = Idxs.size(); 3651f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar for (auto *IVI = dyn_cast<InsertValueInst>(Agg); IVI != nullptr; 3652f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar IVI = dyn_cast<InsertValueInst>(IVI->getAggregateOperand())) { 3653f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar ArrayRef<unsigned> InsertValueIdxs = IVI->getIndices(); 3654f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar unsigned NumInsertValueIdxs = InsertValueIdxs.size(); 3655f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar unsigned NumCommonIdxs = std::min(NumInsertValueIdxs, NumIdxs); 3656f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar if (InsertValueIdxs.slice(0, NumCommonIdxs) == 3657f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar Idxs.slice(0, NumCommonIdxs)) { 3658f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar if (NumIdxs == NumInsertValueIdxs) 3659f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar return IVI->getInsertedValueOperand(); 3660f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar break; 3661f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar } 3662f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar } 3663f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar 3664f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar return nullptr; 3665f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar} 3666f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar 3667f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga NainarValue *llvm::SimplifyExtractValueInst(Value *Agg, ArrayRef<unsigned> Idxs, 3668f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar const DataLayout &DL, 3669f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar const TargetLibraryInfo *TLI, 3670f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar const DominatorTree *DT, 3671f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar AssumptionCache *AC, 3672f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar const Instruction *CxtI) { 3673f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar return ::SimplifyExtractValueInst(Agg, Idxs, Query(DL, TLI, DT, AC, CxtI), 3674f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar RecursionLimit); 3675f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar} 3676f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar 3677de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Given operands for an ExtractElementInst, see if we can fold the result. 3678de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// If not, this returns null. 3679f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainarstatic Value *SimplifyExtractElementInst(Value *Vec, Value *Idx, const Query &, 3680f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar unsigned) { 3681f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar if (auto *CVec = dyn_cast<Constant>(Vec)) { 3682f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar if (auto *CIdx = dyn_cast<Constant>(Idx)) 3683f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar return ConstantFoldExtractElementInstruction(CVec, CIdx); 3684f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar 3685f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar // The index is not relevant if our vector is a splat. 3686f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar if (auto *Splat = CVec->getSplatValue()) 3687f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar return Splat; 3688f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar 3689f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar if (isa<UndefValue>(Vec)) 3690f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar return UndefValue::get(Vec->getType()->getVectorElementType()); 3691f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar } 3692f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar 3693f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar // If extracting a specified index from the vector, see if we can recursively 3694f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar // find a previously computed scalar that was inserted into the vector. 3695f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar if (auto *IdxC = dyn_cast<ConstantInt>(Idx)) 3696f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar if (Value *Elt = findScalarElement(Vec, IdxC->getZExtValue())) 3697f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar return Elt; 3698f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar 3699f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar return nullptr; 3700f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar} 3701f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar 3702f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga NainarValue *llvm::SimplifyExtractElementInst( 3703f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar Value *Vec, Value *Idx, const DataLayout &DL, const TargetLibraryInfo *TLI, 3704f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar const DominatorTree *DT, AssumptionCache *AC, const Instruction *CxtI) { 3705f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar return ::SimplifyExtractElementInst(Vec, Idx, Query(DL, TLI, DT, AC, CxtI), 3706f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar RecursionLimit); 3707f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar} 3708f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar 3709de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// See if we can fold the given phi. If not, returns null. 37100aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sandsstatic Value *SimplifyPHINode(PHINode *PN, const Query &Q) { 3711ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // If all of the PHI's incoming values are the same then replace the PHI node 3712ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // with the common value. 3713dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Value *CommonValue = nullptr; 3714ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands bool HasUndefInput = false; 37156948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar for (Value *Incoming : PN->incoming_values()) { 3716ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // If the incoming value is the phi node itself, it can safely be skipped. 3717ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands if (Incoming == PN) continue; 3718ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands if (isa<UndefValue>(Incoming)) { 3719ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // Remember that we saw an undef value, but otherwise ignore them. 3720ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands HasUndefInput = true; 3721ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands continue; 3722ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands } 3723ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands if (CommonValue && Incoming != CommonValue) 3724dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; // Not the same, bail out. 3725ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands CommonValue = Incoming; 3726ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands } 3727ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands 3728ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // If CommonValue is null then all of the incoming values were either undef or 3729ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // equal to the phi node itself. 3730ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands if (!CommonValue) 3731ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands return UndefValue::get(PN->getType()); 3732ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands 3733ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // If we have a PHI node like phi(X, undef, X), where X is defined by some 3734ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // instruction, we cannot return X as the result of the PHI node unless it 3735ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // dominates the PHI block. 3736ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands if (HasUndefInput) 3737dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return ValueDominatesPHI(CommonValue, PN, Q.DT) ? CommonValue : nullptr; 3738ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands 3739ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands return CommonValue; 3740ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands} 3741ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands 3742bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sandsstatic Value *SimplifyTruncInst(Value *Op, Type *Ty, const Query &Q, unsigned) { 3743bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands if (Constant *C = dyn_cast<Constant>(Op)) 3744de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return ConstantFoldCastOperand(Instruction::Trunc, C, Ty, Q.DL); 3745bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands 3746dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 3747bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands} 3748bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands 37494c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga NainarValue *llvm::SimplifyTruncInst(Value *Op, Type *Ty, const DataLayout &DL, 3750bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands const TargetLibraryInfo *TLI, 3751ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const DominatorTree *DT, AssumptionCache *AC, 375237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const Instruction *CxtI) { 3753ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return ::SimplifyTruncInst(Op, Ty, Query(DL, TLI, DT, AC, CxtI), 375437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines RecursionLimit); 3755bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands} 3756bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands 3757d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner//=== Helper functions for higher up the class hierarchy. 37589dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 3759de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Given operands for a BinaryOperator, see if we can fold the result. 3760de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// If not, this returns null. 3761a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *SimplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS, 37620aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 3763d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner switch (Opcode) { 376481a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner case Instruction::Add: 3765ffeb98ad3becfbb8e26270ef8751e37e4b6b0cd1Duncan Sands return SimplifyAddInst(LHS, RHS, /*isNSW*/false, /*isNUW*/false, 37660aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse); 3767d0a0d221da55f5e2d97909991d77e7ab91e75426Michael Ilseman case Instruction::FAdd: 3768d0a0d221da55f5e2d97909991d77e7ab91e75426Michael Ilseman return SimplifyFAddInst(LHS, RHS, FastMathFlags(), Q, MaxRecurse); 3769d0a0d221da55f5e2d97909991d77e7ab91e75426Michael Ilseman 377081a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner case Instruction::Sub: 3771ffeb98ad3becfbb8e26270ef8751e37e4b6b0cd1Duncan Sands return SimplifySubInst(LHS, RHS, /*isNSW*/false, /*isNUW*/false, 37720aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse); 3773d0a0d221da55f5e2d97909991d77e7ab91e75426Michael Ilseman case Instruction::FSub: 3774d0a0d221da55f5e2d97909991d77e7ab91e75426Michael Ilseman return SimplifyFSubInst(LHS, RHS, FastMathFlags(), Q, MaxRecurse); 3775d0a0d221da55f5e2d97909991d77e7ab91e75426Michael Ilseman 37760aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands case Instruction::Mul: return SimplifyMulInst (LHS, RHS, Q, MaxRecurse); 3777d0a0d221da55f5e2d97909991d77e7ab91e75426Michael Ilseman case Instruction::FMul: 3778d0a0d221da55f5e2d97909991d77e7ab91e75426Michael Ilseman return SimplifyFMulInst (LHS, RHS, FastMathFlags(), Q, MaxRecurse); 37790aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands case Instruction::SDiv: return SimplifySDivInst(LHS, RHS, Q, MaxRecurse); 37800aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands case Instruction::UDiv: return SimplifyUDivInst(LHS, RHS, Q, MaxRecurse); 3781ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines case Instruction::FDiv: 3782ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return SimplifyFDivInst(LHS, RHS, FastMathFlags(), Q, MaxRecurse); 37830aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands case Instruction::SRem: return SimplifySRemInst(LHS, RHS, Q, MaxRecurse); 37840aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands case Instruction::URem: return SimplifyURemInst(LHS, RHS, Q, MaxRecurse); 3785ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines case Instruction::FRem: 3786ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return SimplifyFRemInst(LHS, RHS, FastMathFlags(), Q, MaxRecurse); 378781a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner case Instruction::Shl: 3788ffeb98ad3becfbb8e26270ef8751e37e4b6b0cd1Duncan Sands return SimplifyShlInst(LHS, RHS, /*isNSW*/false, /*isNUW*/false, 37890aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands Q, MaxRecurse); 379081a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner case Instruction::LShr: 37910aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands return SimplifyLShrInst(LHS, RHS, /*isExact*/false, Q, MaxRecurse); 379281a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner case Instruction::AShr: 37930aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands return SimplifyAShrInst(LHS, RHS, /*isExact*/false, Q, MaxRecurse); 37940aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands case Instruction::And: return SimplifyAndInst(LHS, RHS, Q, MaxRecurse); 37950aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands case Instruction::Or: return SimplifyOrInst (LHS, RHS, Q, MaxRecurse); 37960aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands case Instruction::Xor: return SimplifyXorInst(LHS, RHS, Q, MaxRecurse); 3797d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner default: 3798d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(LHS)) 3799de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (Constant *CRHS = dyn_cast<Constant>(RHS)) 3800de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return ConstantFoldBinaryOpOperands(Opcode, CLHS, CRHS, Q.DL); 3801b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 3802566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // If the operation is associative, try some generic simplifications. 3803566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Instruction::isAssociative(Opcode)) 38040aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = SimplifyAssociativeBinOp(Opcode, LHS, RHS, Q, MaxRecurse)) 3805566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return V; 3806566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 38070aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands // If the operation is with the result of a select instruction check whether 3808b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // operating on either branch of the select always yields the same value. 38090312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<SelectInst>(LHS) || isa<SelectInst>(RHS)) 38100aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadBinOpOverSelect(Opcode, LHS, RHS, Q, MaxRecurse)) 3811a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return V; 3812a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 3813a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the operation is with the result of a phi instruction, check whether 3814a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // operating on all incoming values of the phi always yields the same value. 38150312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<PHINode>(LHS) || isa<PHINode>(RHS)) 38160aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands if (Value *V = ThreadBinOpOverPHI(Opcode, LHS, RHS, Q, MaxRecurse)) 3817b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return V; 3818b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 3819dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 3820d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 3821d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner} 38229dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 3823de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Given operands for a BinaryOperator, see if we can fold the result. 3824de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// If not, this returns null. 3825ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines/// In contrast to SimplifyBinOp, try to use FastMathFlag when folding the 3826ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines/// result. In case we don't need FastMathFlags, simply fall to SimplifyBinOp. 3827ebe69fe11e48d322045d5949c83283927a0d790bStephen Hinesstatic Value *SimplifyFPBinOp(unsigned Opcode, Value *LHS, Value *RHS, 3828ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const FastMathFlags &FMF, const Query &Q, 3829ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines unsigned MaxRecurse) { 3830ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines switch (Opcode) { 3831ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines case Instruction::FAdd: 3832ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return SimplifyFAddInst(LHS, RHS, FMF, Q, MaxRecurse); 3833ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines case Instruction::FSub: 3834ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return SimplifyFSubInst(LHS, RHS, FMF, Q, MaxRecurse); 3835ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines case Instruction::FMul: 3836ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return SimplifyFMulInst(LHS, RHS, FMF, Q, MaxRecurse); 3837ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines default: 3838ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return SimplifyBinOp(Opcode, LHS, RHS, Q, MaxRecurse); 3839ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines } 3840ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines} 3841ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 384212a86f5b3199e72e6d967781acc76340f5920e46Duncan SandsValue *llvm::SimplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS, 38434c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar const DataLayout &DL, const TargetLibraryInfo *TLI, 3844ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const DominatorTree *DT, AssumptionCache *AC, 384537ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const Instruction *CxtI) { 3846ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return ::SimplifyBinOp(Opcode, LHS, RHS, Query(DL, TLI, DT, AC, CxtI), 384737ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines RecursionLimit); 3848a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 3849a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 3850ebe69fe11e48d322045d5949c83283927a0d790bStephen HinesValue *llvm::SimplifyFPBinOp(unsigned Opcode, Value *LHS, Value *RHS, 38514c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar const FastMathFlags &FMF, const DataLayout &DL, 3852ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const TargetLibraryInfo *TLI, 3853ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const DominatorTree *DT, AssumptionCache *AC, 3854ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const Instruction *CxtI) { 3855ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return ::SimplifyFPBinOp(Opcode, LHS, RHS, FMF, Query(DL, TLI, DT, AC, CxtI), 3856ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines RecursionLimit); 3857ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines} 3858ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines 3859de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// Given operands for a CmpInst, see if we can fold the result. 3860a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *SimplifyCmpInst(unsigned Predicate, Value *LHS, Value *RHS, 38610aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands const Query &Q, unsigned MaxRecurse) { 38629dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner if (CmpInst::isIntPredicate((CmpInst::Predicate)Predicate)) 38630aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands return SimplifyICmpInst(Predicate, LHS, RHS, Q, MaxRecurse); 3864f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar return SimplifyFCmpInst(Predicate, LHS, RHS, FastMathFlags(), Q, MaxRecurse); 38659dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner} 38669dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 3867a74a58c83be492b7d5b7383656f049909394cff4Duncan SandsValue *llvm::SimplifyCmpInst(unsigned Predicate, Value *LHS, Value *RHS, 38684c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar const DataLayout &DL, const TargetLibraryInfo *TLI, 3869ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const DominatorTree *DT, AssumptionCache *AC, 387037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const Instruction *CxtI) { 3871ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return ::SimplifyCmpInst(Predicate, LHS, RHS, Query(DL, TLI, DT, AC, CxtI), 38720aa85eb231dc76bcabcd35f6dc9a50536f607df3Duncan Sands RecursionLimit); 3873a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 3874e34537856a544c83513e390ac9552a8bc3823346Chris Lattner 3875f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilsemanstatic bool IsIdempotent(Intrinsic::ID ID) { 3876f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman switch (ID) { 3877f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman default: return false; 3878f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman 3879f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman // Unary idempotent: f(f(x)) = f(x) 3880f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman case Intrinsic::fabs: 3881f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman case Intrinsic::floor: 3882f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman case Intrinsic::ceil: 3883f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman case Intrinsic::trunc: 3884f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman case Intrinsic::rint: 3885f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman case Intrinsic::nearbyint: 388641418d17cced656f91038b2482bc9d173b4974b0Hal Finkel case Intrinsic::round: 3887f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman return true; 3888f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman } 3889f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman} 3890f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman 3891de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainarstatic Value *SimplifyRelativeLoad(Constant *Ptr, Constant *Offset, 3892de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar const DataLayout &DL) { 3893de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar GlobalValue *PtrSym; 3894de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar APInt PtrOffset; 3895de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (!IsConstantOffsetFromGlobal(Ptr, PtrSym, PtrOffset, DL)) 3896de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return nullptr; 3897de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar 3898de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar Type *Int8PtrTy = Type::getInt8PtrTy(Ptr->getContext()); 3899de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar Type *Int32Ty = Type::getInt32Ty(Ptr->getContext()); 3900de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar Type *Int32PtrTy = Int32Ty->getPointerTo(); 3901de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar Type *Int64Ty = Type::getInt64Ty(Ptr->getContext()); 3902de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar 3903de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar auto *OffsetConstInt = dyn_cast<ConstantInt>(Offset); 3904de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (!OffsetConstInt || OffsetConstInt->getType()->getBitWidth() > 64) 3905de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return nullptr; 3906de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar 3907de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar uint64_t OffsetInt = OffsetConstInt->getSExtValue(); 3908de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (OffsetInt % 4 != 0) 3909de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return nullptr; 3910de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar 3911de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar Constant *C = ConstantExpr::getGetElementPtr( 3912de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar Int32Ty, ConstantExpr::getBitCast(Ptr, Int32PtrTy), 3913de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar ConstantInt::get(Int64Ty, OffsetInt / 4)); 3914de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar Constant *Loaded = ConstantFoldLoadFromConstPtr(C, Int32Ty, DL); 3915de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (!Loaded) 3916de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return nullptr; 3917de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar 3918de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar auto *LoadedCE = dyn_cast<ConstantExpr>(Loaded); 3919de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (!LoadedCE) 3920de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return nullptr; 3921de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar 3922de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (LoadedCE->getOpcode() == Instruction::Trunc) { 3923de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar LoadedCE = dyn_cast<ConstantExpr>(LoadedCE->getOperand(0)); 3924de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (!LoadedCE) 3925de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return nullptr; 3926de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar } 3927de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar 3928de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (LoadedCE->getOpcode() != Instruction::Sub) 3929de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return nullptr; 3930de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar 3931de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar auto *LoadedLHS = dyn_cast<ConstantExpr>(LoadedCE->getOperand(0)); 3932de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (!LoadedLHS || LoadedLHS->getOpcode() != Instruction::PtrToInt) 3933de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return nullptr; 3934de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar auto *LoadedLHSPtr = LoadedLHS->getOperand(0); 3935de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar 3936de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar Constant *LoadedRHS = LoadedCE->getOperand(1); 3937de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar GlobalValue *LoadedRHSSym; 3938de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar APInt LoadedRHSOffset; 3939de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (!IsConstantOffsetFromGlobal(LoadedRHS, LoadedRHSSym, LoadedRHSOffset, 3940de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar DL) || 3941de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar PtrSym != LoadedRHSSym || PtrOffset != LoadedRHSOffset) 3942de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return nullptr; 3943de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar 3944de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return ConstantExpr::getBitCast(LoadedLHSPtr, Int8PtrTy); 3945de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar} 3946de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar 3947de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainarstatic bool maskIsAllZeroOrUndef(Value *Mask) { 3948de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar auto *ConstMask = dyn_cast<Constant>(Mask); 3949de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (!ConstMask) 3950de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return false; 3951de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (ConstMask->isNullValue() || isa<UndefValue>(ConstMask)) 3952de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return true; 3953de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar for (unsigned I = 0, E = ConstMask->getType()->getVectorNumElements(); I != E; 3954de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar ++I) { 3955de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (auto *MaskElt = ConstMask->getAggregateElement(I)) 3956de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (MaskElt->isNullValue() || isa<UndefValue>(MaskElt)) 3957de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar continue; 3958de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return false; 3959de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar } 3960de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return true; 3961de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar} 3962de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar 3963f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilsemantemplate <typename IterTy> 39646948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainarstatic Value *SimplifyIntrinsic(Function *F, IterTy ArgBegin, IterTy ArgEnd, 3965f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman const Query &Q, unsigned MaxRecurse) { 39666948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar Intrinsic::ID IID = F->getIntrinsicID(); 39676948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar unsigned NumOperands = std::distance(ArgBegin, ArgEnd); 39686948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar Type *ReturnType = F->getReturnType(); 39696948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar 39706948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar // Binary Ops 39716948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (NumOperands == 2) { 39726948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar Value *LHS = *ArgBegin; 39736948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar Value *RHS = *(ArgBegin + 1); 39746948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (IID == Intrinsic::usub_with_overflow || 39756948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar IID == Intrinsic::ssub_with_overflow) { 39766948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar // X - X -> { 0, false } 39776948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (LHS == RHS) 39786948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar return Constant::getNullValue(ReturnType); 39796948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar 39806948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar // X - undef -> undef 39816948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar // undef - X -> undef 39826948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (isa<UndefValue>(LHS) || isa<UndefValue>(RHS)) 39836948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar return UndefValue::get(ReturnType); 39846948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar } 39856948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar 39866948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (IID == Intrinsic::uadd_with_overflow || 39876948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar IID == Intrinsic::sadd_with_overflow) { 39886948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar // X + undef -> undef 39896948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (isa<UndefValue>(RHS)) 39906948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar return UndefValue::get(ReturnType); 39916948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar } 39926948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar 39936948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (IID == Intrinsic::umul_with_overflow || 39946948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar IID == Intrinsic::smul_with_overflow) { 39956948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar // X * 0 -> { 0, false } 39966948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (match(RHS, m_Zero())) 39976948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar return Constant::getNullValue(ReturnType); 39986948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar 39996948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar // X * undef -> { 0, false } 40006948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (match(RHS, m_Undef())) 40016948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar return Constant::getNullValue(ReturnType); 40026948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar } 4003de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar 4004de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (IID == Intrinsic::load_relative && isa<Constant>(LHS) && 4005de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar isa<Constant>(RHS)) 4006de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return SimplifyRelativeLoad(cast<Constant>(LHS), cast<Constant>(RHS), 4007de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar Q.DL); 4008de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar } 4009de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar 4010de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar // Simplify calls to llvm.masked.load.* 4011de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (IID == Intrinsic::masked_load) { 4012de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar Value *MaskArg = ArgBegin[2]; 4013de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar Value *PassthruArg = ArgBegin[3]; 4014de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar // If the mask is all zeros or undef, the "passthru" argument is the result. 4015de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (maskIsAllZeroOrUndef(MaskArg)) 4016de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar return PassthruArg; 40176948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar } 40186948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar 4019f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman // Perform idempotent optimizations 4020f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman if (!IsIdempotent(IID)) 4021dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 4022f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman 4023f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman // Unary Ops 40246948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (NumOperands == 1) 4025f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(*ArgBegin)) 4026f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman if (II->getIntrinsicID() == IID) 4027f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman return II; 4028f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman 4029dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 4030f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman} 4031f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman 4032c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruthtemplate <typename IterTy> 4033e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruthstatic Value *SimplifyCall(Value *V, IterTy ArgBegin, IterTy ArgEnd, 4034c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth const Query &Q, unsigned MaxRecurse) { 4035e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth Type *Ty = V->getType(); 4036c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth if (PointerType *PTy = dyn_cast<PointerType>(Ty)) 4037c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth Ty = PTy->getElementType(); 4038c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth FunctionType *FTy = cast<FunctionType>(Ty); 4039c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth 404071d050315704c23b235594d3fad5268c12d825e3Dan Gohman // call undef -> undef 4041de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar // call null -> undef 4042de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar if (isa<UndefValue>(V) || isa<ConstantPointerNull>(V)) 4043c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth return UndefValue::get(FTy->getReturnType()); 404471d050315704c23b235594d3fad5268c12d825e3Dan Gohman 4045e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth Function *F = dyn_cast<Function>(V); 4046e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth if (!F) 4047dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 4048e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth 40496948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (F->isIntrinsic()) 40506948897e478cbd66626159776a8017b3c18579b9Pirama Arumuga Nainar if (Value *Ret = SimplifyIntrinsic(F, ArgBegin, ArgEnd, Q, MaxRecurse)) 4051f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman return Ret; 4052f89de816ae5cf2d0dad7869882dd626532b934efMichael Ilseman 4053e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth if (!canConstantFoldCallTo(F)) 4054dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 4055e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth 4056e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth SmallVector<Constant *, 4> ConstantArgs; 4057e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth ConstantArgs.reserve(ArgEnd - ArgBegin); 4058e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth for (IterTy I = ArgBegin, E = ArgEnd; I != E; ++I) { 4059e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth Constant *C = dyn_cast<Constant>(*I); 4060e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth if (!C) 4061dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 4062e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth ConstantArgs.push_back(C); 4063e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth } 4064e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth 4065e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler Carruth return ConstantFoldCall(F, ConstantArgs, Q.TLI); 406671d050315704c23b235594d3fad5268c12d825e3Dan Gohman} 406771d050315704c23b235594d3fad5268c12d825e3Dan Gohman 4068e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler CarruthValue *llvm::SimplifyCall(Value *V, User::op_iterator ArgBegin, 40694c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar User::op_iterator ArgEnd, const DataLayout &DL, 4070ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const TargetLibraryInfo *TLI, const DominatorTree *DT, 4071ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines AssumptionCache *AC, const Instruction *CxtI) { 4072ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines return ::SimplifyCall(V, ArgBegin, ArgEnd, Query(DL, TLI, DT, AC, CxtI), 4073c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth RecursionLimit); 4074c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth} 4075c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth 4076e949aa1c91132094a9073c82a8aef729fa8c9ecaChandler CarruthValue *llvm::SimplifyCall(Value *V, ArrayRef<Value *> Args, 40774c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar const DataLayout &DL, const TargetLibraryInfo *TLI, 4078ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const DominatorTree *DT, AssumptionCache *AC, 407937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const Instruction *CxtI) { 408037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines return ::SimplifyCall(V, Args.begin(), Args.end(), 4081ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines Query(DL, TLI, DT, AC, CxtI), RecursionLimit); 4082c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth} 4083c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth 4084de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// See if we can compute a simplified version of this instruction. 4085de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// If not, this returns null. 40864c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga NainarValue *llvm::SimplifyInstruction(Instruction *I, const DataLayout &DL, 4087618c1dbd293d15ee19f61b1156ab8086ad28311aChad Rosier const TargetLibraryInfo *TLI, 4088ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines const DominatorTree *DT, AssumptionCache *AC) { 4089d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands Value *Result; 4090d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands 4091e34537856a544c83513e390ac9552a8bc3823346Chris Lattner switch (I->getOpcode()) { 4092e34537856a544c83513e390ac9552a8bc3823346Chris Lattner default: 409336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Result = ConstantFoldInstruction(I, DL, TLI); 4094d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 409509ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman case Instruction::FAdd: 409609ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman Result = SimplifyFAddInst(I->getOperand(0), I->getOperand(1), 4097ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines I->getFastMathFlags(), DL, TLI, DT, AC, I); 409809ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman break; 40998aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner case Instruction::Add: 4100d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands Result = SimplifyAddInst(I->getOperand(0), I->getOperand(1), 4101d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands cast<BinaryOperator>(I)->hasNoSignedWrap(), 4102ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines cast<BinaryOperator>(I)->hasNoUnsignedWrap(), DL, 4103ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines TLI, DT, AC, I); 4104d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 410509ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman case Instruction::FSub: 410609ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman Result = SimplifyFSubInst(I->getOperand(0), I->getOperand(1), 4107ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines I->getFastMathFlags(), DL, TLI, DT, AC, I); 410809ee250e728ccdb7afc6354d777f8319c5a0465cMichael Ilseman break; 4109fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands case Instruction::Sub: 4110fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands Result = SimplifySubInst(I->getOperand(0), I->getOperand(1), 4111fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands cast<BinaryOperator>(I)->hasNoSignedWrap(), 4112ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines cast<BinaryOperator>(I)->hasNoUnsignedWrap(), DL, 4113ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines TLI, DT, AC, I); 4114fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands break; 4115eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman case Instruction::FMul: 4116eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman Result = SimplifyFMulInst(I->getOperand(0), I->getOperand(1), 4117ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines I->getFastMathFlags(), DL, TLI, DT, AC, I); 4118eb61c920f12cacee38815bf10821d2f294b66f3aMichael Ilseman break; 411982fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands case Instruction::Mul: 4120ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines Result = 4121ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines SimplifyMulInst(I->getOperand(0), I->getOperand(1), DL, TLI, DT, AC, I); 412282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands break; 4123593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands case Instruction::SDiv: 4124ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines Result = SimplifySDivInst(I->getOperand(0), I->getOperand(1), DL, TLI, DT, 4125ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines AC, I); 4126593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands break; 4127593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands case Instruction::UDiv: 4128ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines Result = SimplifyUDivInst(I->getOperand(0), I->getOperand(1), DL, TLI, DT, 4129ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines AC, I); 4130593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands break; 41311fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel case Instruction::FDiv: 413237ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines Result = SimplifyFDivInst(I->getOperand(0), I->getOperand(1), 4133ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines I->getFastMathFlags(), DL, TLI, DT, AC, I); 41341fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel break; 4135f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands case Instruction::SRem: 4136ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines Result = SimplifySRemInst(I->getOperand(0), I->getOperand(1), DL, TLI, DT, 4137ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines AC, I); 4138f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands break; 4139f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands case Instruction::URem: 4140ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines Result = SimplifyURemInst(I->getOperand(0), I->getOperand(1), DL, TLI, DT, 4141ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines AC, I); 4142f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands break; 4143f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands case Instruction::FRem: 414437ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines Result = SimplifyFRemInst(I->getOperand(0), I->getOperand(1), 4145ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines I->getFastMathFlags(), DL, TLI, DT, AC, I); 4146f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands break; 4147c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands case Instruction::Shl: 414881a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Result = SimplifyShlInst(I->getOperand(0), I->getOperand(1), 414981a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner cast<BinaryOperator>(I)->hasNoSignedWrap(), 4150ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines cast<BinaryOperator>(I)->hasNoUnsignedWrap(), DL, 4151ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines TLI, DT, AC, I); 4152c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands break; 4153c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands case Instruction::LShr: 415481a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Result = SimplifyLShrInst(I->getOperand(0), I->getOperand(1), 4155ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines cast<BinaryOperator>(I)->isExact(), DL, TLI, DT, 4156ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines AC, I); 4157c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands break; 4158c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands case Instruction::AShr: 415981a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Result = SimplifyAShrInst(I->getOperand(0), I->getOperand(1), 4160ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines cast<BinaryOperator>(I)->isExact(), DL, TLI, DT, 4161ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines AC, I); 4162c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands break; 4163e34537856a544c83513e390ac9552a8bc3823346Chris Lattner case Instruction::And: 4164ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines Result = 4165ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines SimplifyAndInst(I->getOperand(0), I->getOperand(1), DL, TLI, DT, AC, I); 4166d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 4167e34537856a544c83513e390ac9552a8bc3823346Chris Lattner case Instruction::Or: 4168ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines Result = 4169ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines SimplifyOrInst(I->getOperand(0), I->getOperand(1), DL, TLI, DT, AC, I); 4170d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 41712b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands case Instruction::Xor: 4172ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines Result = 4173ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines SimplifyXorInst(I->getOperand(0), I->getOperand(1), DL, TLI, DT, AC, I); 41742b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands break; 4175e34537856a544c83513e390ac9552a8bc3823346Chris Lattner case Instruction::ICmp: 4176ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines Result = 4177ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines SimplifyICmpInst(cast<ICmpInst>(I)->getPredicate(), I->getOperand(0), 4178ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines I->getOperand(1), DL, TLI, DT, AC, I); 4179d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 4180e34537856a544c83513e390ac9552a8bc3823346Chris Lattner case Instruction::FCmp: 4181f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar Result = SimplifyFCmpInst(cast<FCmpInst>(I)->getPredicate(), 4182f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar I->getOperand(0), I->getOperand(1), 4183f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar I->getFastMathFlags(), DL, TLI, DT, AC, I); 4184d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 4185047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner case Instruction::Select: 4186d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands Result = SimplifySelectInst(I->getOperand(0), I->getOperand(1), 4187ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines I->getOperand(2), DL, TLI, DT, AC, I); 4188d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 4189c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner case Instruction::GetElementPtr: { 4190c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner SmallVector<Value*, 8> Ops(I->op_begin(), I->op_end()); 4191de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar Result = SimplifyGEPInst(cast<GetElementPtrInst>(I)->getSourceElementType(), 4192de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar Ops, DL, TLI, DT, AC, I); 4193d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 4194c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner } 4195dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands case Instruction::InsertValue: { 4196dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands InsertValueInst *IV = cast<InsertValueInst>(I); 4197dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands Result = SimplifyInsertValueInst(IV->getAggregateOperand(), 4198dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands IV->getInsertedValueOperand(), 4199ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines IV->getIndices(), DL, TLI, DT, AC, I); 4200dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands break; 4201dabc2806726a286b00313419fac8461ebe0f774cDuncan Sands } 4202f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar case Instruction::ExtractValue: { 4203f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar auto *EVI = cast<ExtractValueInst>(I); 4204f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar Result = SimplifyExtractValueInst(EVI->getAggregateOperand(), 4205f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar EVI->getIndices(), DL, TLI, DT, AC, I); 4206f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar break; 4207f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar } 4208f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar case Instruction::ExtractElement: { 4209f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar auto *EEI = cast<ExtractElementInst>(I); 4210f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar Result = SimplifyExtractElementInst( 4211f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar EEI->getVectorOperand(), EEI->getIndexOperand(), DL, TLI, DT, AC, I); 4212f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar break; 4213f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar } 4214cd6636c737a82949ad13db2d0d918af6424fb78bDuncan Sands case Instruction::PHI: 4215ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines Result = SimplifyPHINode(cast<PHINode>(I), Query(DL, TLI, DT, AC, I)); 4216d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 4217c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth case Instruction::Call: { 4218c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth CallSite CS(cast<CallInst>(I)); 4219ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines Result = SimplifyCall(CS.getCalledValue(), CS.arg_begin(), CS.arg_end(), DL, 4220ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines TLI, DT, AC, I); 422171d050315704c23b235594d3fad5268c12d825e3Dan Gohman break; 4222c98bd9f1a79adffe73acd337b6f7f9afa6bae078Chandler Carruth } 4223bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands case Instruction::Trunc: 4224ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines Result = 4225ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines SimplifyTruncInst(I->getOperand(0), I->getType(), DL, TLI, DT, AC, I); 4226bd0fe5642544d4ec3aee1ede7af60c006bae5cbfDuncan Sands break; 4227e34537856a544c83513e390ac9552a8bc3823346Chris Lattner } 4228d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands 4229f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar // In general, it is possible for computeKnownBits to determine all bits in a 4230f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar // value even when the operands are not all constants. 4231f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar if (!Result && I->getType()->isIntegerTy()) { 4232f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar unsigned BitWidth = I->getType()->getScalarSizeInBits(); 4233f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar APInt KnownZero(BitWidth, 0); 4234f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar APInt KnownOne(BitWidth, 0); 4235f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar computeKnownBits(I, KnownZero, KnownOne, DL, /*Depth*/0, AC, I, DT); 4236f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar if ((KnownZero | KnownOne).isAllOnesValue()) 4237f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar Result = ConstantInt::get(I->getContext(), KnownOne); 4238f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar } 4239f3ef5332fa3f4d5ec72c178a2b19dac363a19383Pirama Arumuga Nainar 4240d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands /// If called on unreachable code, the above logic may report that the 4241d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands /// instruction simplified to itself. Make life easier for users by 4242f8b1a5ea9602bb65a5cf59d3d34f2851a08cdc3eDuncan Sands /// detecting that case here, returning a safe value instead. 4243f8b1a5ea9602bb65a5cf59d3d34f2851a08cdc3eDuncan Sands return Result == I ? UndefValue::get(I->getType()) : Result; 4244e34537856a544c83513e390ac9552a8bc3823346Chris Lattner} 4245e34537856a544c83513e390ac9552a8bc3823346Chris Lattner 4246de2d8694e25a814696358e95141f4b1aa4d8847ePirama Arumuga Nainar/// \brief Implementation of recursive simplification through an instruction's 42476b980541df5846ad335c377c8803b517968daee2Chandler Carruth/// uses. 424840d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// 42496b980541df5846ad335c377c8803b517968daee2Chandler Carruth/// This is the common implementation of the recursive simplification routines. 42506b980541df5846ad335c377c8803b517968daee2Chandler Carruth/// If we have a pre-simplified value in 'SimpleV', that is forcibly used to 42516b980541df5846ad335c377c8803b517968daee2Chandler Carruth/// replace the instruction 'I'. Otherwise, we simply add 'I' to the list of 42526b980541df5846ad335c377c8803b517968daee2Chandler Carruth/// instructions to process and attempt to simplify it using 42536b980541df5846ad335c377c8803b517968daee2Chandler Carruth/// InstructionSimplify. 42546b980541df5846ad335c377c8803b517968daee2Chandler Carruth/// 42556b980541df5846ad335c377c8803b517968daee2Chandler Carruth/// This routine returns 'true' only when *it* simplifies something. The passed 42566b980541df5846ad335c377c8803b517968daee2Chandler Carruth/// in simplified value does not count toward this. 42576b980541df5846ad335c377c8803b517968daee2Chandler Carruthstatic bool replaceAndRecursivelySimplifyImpl(Instruction *I, Value *SimpleV, 42586b980541df5846ad335c377c8803b517968daee2Chandler Carruth const TargetLibraryInfo *TLI, 425937ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const DominatorTree *DT, 4260ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines AssumptionCache *AC) { 42616b980541df5846ad335c377c8803b517968daee2Chandler Carruth bool Simplified = false; 42626231d5be410e2d7967352b29ad01522fda15680dChandler Carruth SmallSetVector<Instruction *, 8> Worklist; 42634c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar const DataLayout &DL = I->getModule()->getDataLayout(); 42646b980541df5846ad335c377c8803b517968daee2Chandler Carruth 42656b980541df5846ad335c377c8803b517968daee2Chandler Carruth // If we have an explicit value to collapse to, do that round of the 42666b980541df5846ad335c377c8803b517968daee2Chandler Carruth // simplification loop by hand initially. 42676b980541df5846ad335c377c8803b517968daee2Chandler Carruth if (SimpleV) { 426836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines for (User *U : I->users()) 426936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (U != I) 427036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Worklist.insert(cast<Instruction>(U)); 42716b980541df5846ad335c377c8803b517968daee2Chandler Carruth 42726b980541df5846ad335c377c8803b517968daee2Chandler Carruth // Replace the instruction with its simplified value. 42736b980541df5846ad335c377c8803b517968daee2Chandler Carruth I->replaceAllUsesWith(SimpleV); 42746b980541df5846ad335c377c8803b517968daee2Chandler Carruth 42756b980541df5846ad335c377c8803b517968daee2Chandler Carruth // Gracefully handle edge cases where the instruction is not wired into any 42766b980541df5846ad335c377c8803b517968daee2Chandler Carruth // parent block. 42776b980541df5846ad335c377c8803b517968daee2Chandler Carruth if (I->getParent()) 42786b980541df5846ad335c377c8803b517968daee2Chandler Carruth I->eraseFromParent(); 42796b980541df5846ad335c377c8803b517968daee2Chandler Carruth } else { 42806231d5be410e2d7967352b29ad01522fda15680dChandler Carruth Worklist.insert(I); 42816b980541df5846ad335c377c8803b517968daee2Chandler Carruth } 428212a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 42836231d5be410e2d7967352b29ad01522fda15680dChandler Carruth // Note that we must test the size on each iteration, the worklist can grow. 42846231d5be410e2d7967352b29ad01522fda15680dChandler Carruth for (unsigned Idx = 0; Idx != Worklist.size(); ++Idx) { 42856231d5be410e2d7967352b29ad01522fda15680dChandler Carruth I = Worklist[Idx]; 428612a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 42876b980541df5846ad335c377c8803b517968daee2Chandler Carruth // See if this instruction simplifies. 4288ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines SimpleV = SimplifyInstruction(I, DL, TLI, DT, AC); 42896b980541df5846ad335c377c8803b517968daee2Chandler Carruth if (!SimpleV) 42906b980541df5846ad335c377c8803b517968daee2Chandler Carruth continue; 42916b980541df5846ad335c377c8803b517968daee2Chandler Carruth 42926b980541df5846ad335c377c8803b517968daee2Chandler Carruth Simplified = true; 42936b980541df5846ad335c377c8803b517968daee2Chandler Carruth 42946b980541df5846ad335c377c8803b517968daee2Chandler Carruth // Stash away all the uses of the old instruction so we can check them for 42956b980541df5846ad335c377c8803b517968daee2Chandler Carruth // recursive simplifications after a RAUW. This is cheaper than checking all 42966b980541df5846ad335c377c8803b517968daee2Chandler Carruth // uses of To on the recursive step in most cases. 429736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines for (User *U : I->users()) 429836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Worklist.insert(cast<Instruction>(U)); 429912a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 43006b980541df5846ad335c377c8803b517968daee2Chandler Carruth // Replace the instruction with its simplified value. 43016b980541df5846ad335c377c8803b517968daee2Chandler Carruth I->replaceAllUsesWith(SimpleV); 43026b980541df5846ad335c377c8803b517968daee2Chandler Carruth 43036b980541df5846ad335c377c8803b517968daee2Chandler Carruth // Gracefully handle edge cases where the instruction is not wired into any 43046b980541df5846ad335c377c8803b517968daee2Chandler Carruth // parent block. 43056b980541df5846ad335c377c8803b517968daee2Chandler Carruth if (I->getParent()) 43066b980541df5846ad335c377c8803b517968daee2Chandler Carruth I->eraseFromParent(); 430740d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner } 43086b980541df5846ad335c377c8803b517968daee2Chandler Carruth return Simplified; 43096b980541df5846ad335c377c8803b517968daee2Chandler Carruth} 431012a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 43114c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainarbool llvm::recursivelySimplifyInstruction(Instruction *I, 43126b980541df5846ad335c377c8803b517968daee2Chandler Carruth const TargetLibraryInfo *TLI, 431337ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const DominatorTree *DT, 4314ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines AssumptionCache *AC) { 43154c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar return replaceAndRecursivelySimplifyImpl(I, nullptr, TLI, DT, AC); 43166b980541df5846ad335c377c8803b517968daee2Chandler Carruth} 431712a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 43186b980541df5846ad335c377c8803b517968daee2Chandler Carruthbool llvm::replaceAndRecursivelySimplify(Instruction *I, Value *SimpleV, 43196b980541df5846ad335c377c8803b517968daee2Chandler Carruth const TargetLibraryInfo *TLI, 432037ed9c199ca639565f6ce88105f9e39e898d82d0Stephen Hines const DominatorTree *DT, 4321ebe69fe11e48d322045d5949c83283927a0d790bStephen Hines AssumptionCache *AC) { 43226b980541df5846ad335c377c8803b517968daee2Chandler Carruth assert(I != SimpleV && "replaceAndRecursivelySimplify(X,X) is not valid!"); 43236b980541df5846ad335c377c8803b517968daee2Chandler Carruth assert(SimpleV && "Must provide a simplified value."); 43244c5e43da7792f75567b693105cc53e3f1992ad98Pirama Arumuga Nainar return replaceAndRecursivelySimplifyImpl(I, SimpleV, TLI, DT, AC); 432540d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner} 4326