InstructionSimplify.cpp revision f23d4adbfaf870d5fa67c6bff0da7891d3a98f9d
19f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner//===- InstructionSimplify.cpp - Fold instruction operands ----------------===// 29f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner// 39f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner// The LLVM Compiler Infrastructure 49f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner// 59f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner// This file is distributed under the University of Illinois Open Source 69f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner// License. See LICENSE.TXT for details. 79f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner// 89f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner//===----------------------------------------------------------------------===// 99f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner// 109f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner// This file implements routines for folding instructions into simpler forms 114cd2ad15b43f21d641330b4b09961af08646445eDuncan Sands// that do not require creating new instructions. This does constant folding 124cd2ad15b43f21d641330b4b09961af08646445eDuncan Sands// ("add i32 1, 1" -> "2") but can also handle non-constant operands, either 134cd2ad15b43f21d641330b4b09961af08646445eDuncan Sands// returning a constant ("and i32 %x, 0" -> "0") or an already existing value 14ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands// ("and i32 %x, %x" -> "%x"). All operands are assumed to have already been 15ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands// simplified: This is usually true and assuming it simplifies the logic (if 16ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands// they have not been simplified then results are correct but maybe suboptimal). 179f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner// 189f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner//===----------------------------------------------------------------------===// 199f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 20a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands#define DEBUG_TYPE "instsimplify" 21562b84b3aea359d1f918184e355da82bf05eb290Jay Foad#include "llvm/Operator.h" 22a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands#include "llvm/ADT/Statistic.h" 239f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner#include "llvm/Analysis/InstructionSimplify.h" 249f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner#include "llvm/Analysis/ConstantFolding.h" 251845009290e4d804ad377927bd8a08cca3036adcDuncan Sands#include "llvm/Analysis/Dominators.h" 26d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands#include "llvm/Analysis/ValueTracking.h" 273a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky#include "llvm/Support/ConstantRange.h" 28d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner#include "llvm/Support/PatternMatch.h" 291845009290e4d804ad377927bd8a08cca3036adcDuncan Sands#include "llvm/Support/ValueHandle.h" 30e60d79faf7ef7bc4847f9e5d067af00b98dced7bDuncan Sands#include "llvm/Target/TargetData.h" 319f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattnerusing namespace llvm; 32d06094f0682f2ede03caff4892b1a57469896d48Chris Lattnerusing namespace llvm::PatternMatch; 339f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 3481a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattnerenum { RecursionLimit = 3 }; 35a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 36a3c44a5280042dbc0cde995675c225ede4528c6eDuncan SandsSTATISTIC(NumExpand, "Number of expansions"); 37a3c44a5280042dbc0cde995675c225ede4528c6eDuncan SandsSTATISTIC(NumFactor , "Number of factorizations"); 38a3c44a5280042dbc0cde995675c225ede4528c6eDuncan SandsSTATISTIC(NumReassoc, "Number of reassociations"); 39a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands 4082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sandsstatic Value *SimplifyAndInst(Value *, Value *, const TargetData *, 4182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands const DominatorTree *, unsigned); 42a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *SimplifyBinOp(unsigned, Value *, Value *, const TargetData *, 431845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const DominatorTree *, unsigned); 44a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *SimplifyCmpInst(unsigned, Value *, Value *, const TargetData *, 451845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const DominatorTree *, unsigned); 4682fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sandsstatic Value *SimplifyOrInst(Value *, Value *, const TargetData *, 4782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands const DominatorTree *, unsigned); 4882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sandsstatic Value *SimplifyXorInst(Value *, Value *, const TargetData *, 4982fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands const DominatorTree *, unsigned); 501845009290e4d804ad377927bd8a08cca3036adcDuncan Sands 51f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands/// getFalse - For a boolean type, or a vector of boolean type, return false, or 52f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands/// a vector with every element false, as appropriate for the type. 53f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sandsstatic Constant *getFalse(Type *Ty) { 54f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands assert((Ty->isIntegerTy(1) || 55f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands (Ty->isVectorTy() && 56f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands cast<VectorType>(Ty)->getElementType()->isIntegerTy(1))) && 57f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands "Expected i1 type or a vector of i1!"); 58f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return Constant::getNullValue(Ty); 59f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands} 60f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands 61f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands/// getTrue - For a boolean type, or a vector of boolean type, return true, or 62f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands/// a vector with every element true, as appropriate for the type. 63f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sandsstatic Constant *getTrue(Type *Ty) { 64f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands assert((Ty->isIntegerTy(1) || 65f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands (Ty->isVectorTy() && 66f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands cast<VectorType>(Ty)->getElementType()->isIntegerTy(1))) && 67f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands "Expected i1 type or a vector of i1!"); 68f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return Constant::getAllOnesValue(Ty); 69f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands} 70f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands 711845009290e4d804ad377927bd8a08cca3036adcDuncan Sands/// ValueDominatesPHI - Does the given value dominate the specified phi node? 721845009290e4d804ad377927bd8a08cca3036adcDuncan Sandsstatic bool ValueDominatesPHI(Value *V, PHINode *P, const DominatorTree *DT) { 731845009290e4d804ad377927bd8a08cca3036adcDuncan Sands Instruction *I = dyn_cast<Instruction>(V); 741845009290e4d804ad377927bd8a08cca3036adcDuncan Sands if (!I) 751845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // Arguments and constants dominate all instructions. 761845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return true; 771845009290e4d804ad377927bd8a08cca3036adcDuncan Sands 781845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // If we have a DominatorTree then do a precise test. 791845009290e4d804ad377927bd8a08cca3036adcDuncan Sands if (DT) 801845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return DT->dominates(I, P); 811845009290e4d804ad377927bd8a08cca3036adcDuncan Sands 821845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // Otherwise, if the instruction is in the entry block, and is not an invoke, 831845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // then it obviously dominates all phi nodes. 841845009290e4d804ad377927bd8a08cca3036adcDuncan Sands if (I->getParent() == &I->getParent()->getParent()->getEntryBlock() && 851845009290e4d804ad377927bd8a08cca3036adcDuncan Sands !isa<InvokeInst>(I)) 861845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return true; 871845009290e4d804ad377927bd8a08cca3036adcDuncan Sands 881845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return false; 891845009290e4d804ad377927bd8a08cca3036adcDuncan Sands} 90a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 913421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// ExpandBinOp - Simplify "A op (B op' C)" by distributing op over op', turning 923421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// it into "(A op B) op' (A op C)". Here "op" is given by Opcode and "op'" is 933421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// given by OpcodeToExpand, while "A" corresponds to LHS and "B op' C" to RHS. 943421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// Also performs the transform "(A op' B) op C" -> "(A op C) op' (B op C)". 953421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// Returns the simplified value, or null if no simplification was performed. 963421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sandsstatic Value *ExpandBinOp(unsigned Opcode, Value *LHS, Value *RHS, 97e21083aa3a79506f896d95d7147c3c4627a77ef0Benjamin Kramer unsigned OpcToExpand, const TargetData *TD, 983421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands const DominatorTree *DT, unsigned MaxRecurse) { 99e21083aa3a79506f896d95d7147c3c4627a77ef0Benjamin Kramer Instruction::BinaryOps OpcodeToExpand = (Instruction::BinaryOps)OpcToExpand; 1003421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 1013421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (!MaxRecurse--) 1023421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return 0; 1033421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1043421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Check whether the expression has the form "(A op' B) op C". 1053421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (BinaryOperator *Op0 = dyn_cast<BinaryOperator>(LHS)) 1063421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Op0->getOpcode() == OpcodeToExpand) { 1073421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // It does! Try turning it into "(A op C) op' (B op C)". 1083421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands Value *A = Op0->getOperand(0), *B = Op0->getOperand(1), *C = RHS; 1093421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Do "A op C" and "B op C" both simplify? 1103421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *L = SimplifyBinOp(Opcode, A, C, TD, DT, MaxRecurse)) 1113421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *R = SimplifyBinOp(Opcode, B, C, TD, DT, MaxRecurse)) { 1123421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // They do! Return "L op' R" if it simplifies or is already available. 1133421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // If "L op' R" equals "A op' B" then "L op' R" is just the LHS. 114124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if ((L == A && R == B) || (Instruction::isCommutative(OpcodeToExpand) 115124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands && L == B && R == A)) { 116a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumExpand; 1173421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return LHS; 118a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 1193421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Otherwise return "L op' R" if it simplifies. 120a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands if (Value *V = SimplifyBinOp(OpcodeToExpand, L, R, TD, DT, 121a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands MaxRecurse)) { 122a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumExpand; 1233421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 124a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 1253421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 1263421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 1273421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1283421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Check whether the expression has the form "A op (B op' C)". 1293421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (BinaryOperator *Op1 = dyn_cast<BinaryOperator>(RHS)) 1303421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Op1->getOpcode() == OpcodeToExpand) { 1313421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // It does! Try turning it into "(A op B) op' (A op C)". 1323421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands Value *A = LHS, *B = Op1->getOperand(0), *C = Op1->getOperand(1); 1333421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Do "A op B" and "A op C" both simplify? 1343421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *L = SimplifyBinOp(Opcode, A, B, TD, DT, MaxRecurse)) 1353421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *R = SimplifyBinOp(Opcode, A, C, TD, DT, MaxRecurse)) { 1363421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // They do! Return "L op' R" if it simplifies or is already available. 1373421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // If "L op' R" equals "B op' C" then "L op' R" is just the RHS. 138124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if ((L == B && R == C) || (Instruction::isCommutative(OpcodeToExpand) 139124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands && L == C && R == B)) { 140a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumExpand; 1413421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return RHS; 142a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 1433421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Otherwise return "L op' R" if it simplifies. 144a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands if (Value *V = SimplifyBinOp(OpcodeToExpand, L, R, TD, DT, 145a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands MaxRecurse)) { 146a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumExpand; 1473421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 148a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 1493421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 1503421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 1513421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1523421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return 0; 1533421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands} 1543421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1553421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// FactorizeBinOp - Simplify "LHS Opcode RHS" by factorizing out a common term 1563421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// using the operation OpCodeToExtract. For example, when Opcode is Add and 1573421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// OpCodeToExtract is Mul then this tries to turn "(A*B)+(A*C)" into "A*(B+C)". 1583421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// Returns the simplified value, or null if no simplification was performed. 1593421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sandsstatic Value *FactorizeBinOp(unsigned Opcode, Value *LHS, Value *RHS, 160e21083aa3a79506f896d95d7147c3c4627a77ef0Benjamin Kramer unsigned OpcToExtract, const TargetData *TD, 1613421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands const DominatorTree *DT, unsigned MaxRecurse) { 162e21083aa3a79506f896d95d7147c3c4627a77ef0Benjamin Kramer Instruction::BinaryOps OpcodeToExtract = (Instruction::BinaryOps)OpcToExtract; 1633421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 1643421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (!MaxRecurse--) 1653421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return 0; 1663421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1673421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands BinaryOperator *Op0 = dyn_cast<BinaryOperator>(LHS); 1683421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands BinaryOperator *Op1 = dyn_cast<BinaryOperator>(RHS); 1693421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1703421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (!Op0 || Op0->getOpcode() != OpcodeToExtract || 1713421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands !Op1 || Op1->getOpcode() != OpcodeToExtract) 1723421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return 0; 1733421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1743421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // The expression has the form "(A op' B) op (C op' D)". 17582fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands Value *A = Op0->getOperand(0), *B = Op0->getOperand(1); 17682fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands Value *C = Op1->getOperand(0), *D = Op1->getOperand(1); 1773421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1783421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Use left distributivity, i.e. "X op' (Y op Z) = (X op' Y) op (X op' Z)". 1793421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Does the instruction have the form "(A op' B) op (A op' D)" or, in the 1803421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // commutative case, "(A op' B) op (C op' A)"? 181124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (A == C || (Instruction::isCommutative(OpcodeToExtract) && A == D)) { 182124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands Value *DD = A == C ? D : C; 1833421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Form "A op' (B op DD)" if it simplifies completely. 1843421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Does "B op DD" simplify? 1853421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = SimplifyBinOp(Opcode, B, DD, TD, DT, MaxRecurse)) { 1863421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // It does! Return "A op' V" if it simplifies or is already available. 1871cd05bb605e3c3eee9197d3f10b628c60d0cc07aDuncan Sands // If V equals B then "A op' V" is just the LHS. If V equals DD then 1881cd05bb605e3c3eee9197d3f10b628c60d0cc07aDuncan Sands // "A op' V" is just the RHS. 189124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (V == B || V == DD) { 190a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumFactor; 191124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands return V == B ? LHS : RHS; 192a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 1933421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Otherwise return "A op' V" if it simplifies. 194a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands if (Value *W = SimplifyBinOp(OpcodeToExtract, A, V, TD, DT, MaxRecurse)) { 195a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumFactor; 1963421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return W; 197a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 1983421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 1993421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 2003421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 2013421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Use right distributivity, i.e. "(X op Y) op' Z = (X op' Z) op (Y op' Z)". 2023421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Does the instruction have the form "(A op' B) op (C op' B)" or, in the 2033421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // commutative case, "(A op' B) op (B op' D)"? 204124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (B == D || (Instruction::isCommutative(OpcodeToExtract) && B == C)) { 205124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands Value *CC = B == D ? C : D; 2063421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Form "(A op CC) op' B" if it simplifies completely.. 2073421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Does "A op CC" simplify? 2083421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = SimplifyBinOp(Opcode, A, CC, TD, DT, MaxRecurse)) { 2093421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // It does! Return "V op' B" if it simplifies or is already available. 2101cd05bb605e3c3eee9197d3f10b628c60d0cc07aDuncan Sands // If V equals A then "V op' B" is just the LHS. If V equals CC then 2111cd05bb605e3c3eee9197d3f10b628c60d0cc07aDuncan Sands // "V op' B" is just the RHS. 212124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (V == A || V == CC) { 213a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumFactor; 214124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands return V == A ? LHS : RHS; 215a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 2163421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Otherwise return "V op' B" if it simplifies. 217a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands if (Value *W = SimplifyBinOp(OpcodeToExtract, V, B, TD, DT, MaxRecurse)) { 218a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumFactor; 2193421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return W; 220a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 2213421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 2223421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands } 2233421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 2243421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return 0; 2253421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands} 2263421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 2273421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// SimplifyAssociativeBinOp - Generic simplifications for associative binary 2283421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands/// operations. Returns the simpler value, or null if none was found. 229e21083aa3a79506f896d95d7147c3c4627a77ef0Benjamin Kramerstatic Value *SimplifyAssociativeBinOp(unsigned Opc, Value *LHS, Value *RHS, 230566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands const TargetData *TD, 231566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands const DominatorTree *DT, 232566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands unsigned MaxRecurse) { 233e21083aa3a79506f896d95d7147c3c4627a77ef0Benjamin Kramer Instruction::BinaryOps Opcode = (Instruction::BinaryOps)Opc; 234566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands assert(Instruction::isAssociative(Opcode) && "Not an associative operation!"); 235566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 236566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 237566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (!MaxRecurse--) 238566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return 0; 239566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 240566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands BinaryOperator *Op0 = dyn_cast<BinaryOperator>(LHS); 241566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands BinaryOperator *Op1 = dyn_cast<BinaryOperator>(RHS); 242566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 243566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Transform: "(A op B) op C" ==> "A op (B op C)" if it simplifies completely. 244566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Op0 && Op0->getOpcode() == Opcode) { 245566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *A = Op0->getOperand(0); 246566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *B = Op0->getOperand(1); 247566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *C = RHS; 248566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 249566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Does "B op C" simplify? 250566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Value *V = SimplifyBinOp(Opcode, B, C, TD, DT, MaxRecurse)) { 251566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // It does! Return "A op V" if it simplifies or is already available. 252566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // If V equals B then "A op V" is just the LHS. 253124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (V == B) return LHS; 254566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Otherwise return "A op V" if it simplifies. 255a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands if (Value *W = SimplifyBinOp(Opcode, A, V, TD, DT, MaxRecurse)) { 256a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumReassoc; 257566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return W; 258a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 259566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 260566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 261566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 262566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Transform: "A op (B op C)" ==> "(A op B) op C" if it simplifies completely. 263566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Op1 && Op1->getOpcode() == Opcode) { 264566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *A = LHS; 265566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *B = Op1->getOperand(0); 266566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *C = Op1->getOperand(1); 267566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 268566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Does "A op B" simplify? 269566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Value *V = SimplifyBinOp(Opcode, A, B, TD, DT, MaxRecurse)) { 270566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // It does! Return "V op C" if it simplifies or is already available. 271566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // If V equals B then "V op C" is just the RHS. 272124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (V == B) return RHS; 273566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Otherwise return "V op C" if it simplifies. 274a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands if (Value *W = SimplifyBinOp(Opcode, V, C, TD, DT, MaxRecurse)) { 275a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumReassoc; 276566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return W; 277a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 278566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 279566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 280566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 281566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // The remaining transforms require commutativity as well as associativity. 282566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (!Instruction::isCommutative(Opcode)) 283566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return 0; 284566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 285566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Transform: "(A op B) op C" ==> "(C op A) op B" if it simplifies completely. 286566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Op0 && Op0->getOpcode() == Opcode) { 287566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *A = Op0->getOperand(0); 288566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *B = Op0->getOperand(1); 289566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *C = RHS; 290566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 291566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Does "C op A" simplify? 292566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Value *V = SimplifyBinOp(Opcode, C, A, TD, DT, MaxRecurse)) { 293566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // It does! Return "V op B" if it simplifies or is already available. 294566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // If V equals A then "V op B" is just the LHS. 295124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (V == A) return LHS; 296566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Otherwise return "V op B" if it simplifies. 297a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands if (Value *W = SimplifyBinOp(Opcode, V, B, TD, DT, MaxRecurse)) { 298a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumReassoc; 299566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return W; 300a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 301566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 302566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 303566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 304566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Transform: "A op (B op C)" ==> "B op (C op A)" if it simplifies completely. 305566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Op1 && Op1->getOpcode() == Opcode) { 306566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *A = LHS; 307566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *B = Op1->getOperand(0); 308566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands Value *C = Op1->getOperand(1); 309566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 310566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Does "C op A" simplify? 311566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Value *V = SimplifyBinOp(Opcode, C, A, TD, DT, MaxRecurse)) { 312566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // It does! Return "B op V" if it simplifies or is already available. 313566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // If V equals C then "B op V" is just the RHS. 314124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (V == C) return RHS; 315566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Otherwise return "B op V" if it simplifies. 316a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands if (Value *W = SimplifyBinOp(Opcode, B, V, TD, DT, MaxRecurse)) { 317a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands ++NumReassoc; 318566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return W; 319a3c44a5280042dbc0cde995675c225ede4528c6eDuncan Sands } 320566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 321566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands } 322566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 323566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return 0; 324566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands} 325566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 326b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// ThreadBinOpOverSelect - In the case of a binary operation with a select 327b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// instruction as an operand, try to simplify the binop by seeing whether 328b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// evaluating it on both branches of the select results in the same value. 329b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// Returns the common value if so, otherwise returns null. 330b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sandsstatic Value *ThreadBinOpOverSelect(unsigned Opcode, Value *LHS, Value *RHS, 3311845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const TargetData *TD, 3321845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const DominatorTree *DT, 3331845009290e4d804ad377927bd8a08cca3036adcDuncan Sands unsigned MaxRecurse) { 3340312a93693abc2eb682b2b101c889959888fd883Duncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 3350312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (!MaxRecurse--) 3360312a93693abc2eb682b2b101c889959888fd883Duncan Sands return 0; 3370312a93693abc2eb682b2b101c889959888fd883Duncan Sands 338b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands SelectInst *SI; 339b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (isa<SelectInst>(LHS)) { 340b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands SI = cast<SelectInst>(LHS); 341b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } else { 342b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands assert(isa<SelectInst>(RHS) && "No select instruction operand!"); 343b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands SI = cast<SelectInst>(RHS); 344b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } 345b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 346b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // Evaluate the BinOp on the true and false branches of the select. 347b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Value *TV; 348b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Value *FV; 349b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (SI == LHS) { 3501845009290e4d804ad377927bd8a08cca3036adcDuncan Sands TV = SimplifyBinOp(Opcode, SI->getTrueValue(), RHS, TD, DT, MaxRecurse); 3511845009290e4d804ad377927bd8a08cca3036adcDuncan Sands FV = SimplifyBinOp(Opcode, SI->getFalseValue(), RHS, TD, DT, MaxRecurse); 352b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } else { 3531845009290e4d804ad377927bd8a08cca3036adcDuncan Sands TV = SimplifyBinOp(Opcode, LHS, SI->getTrueValue(), TD, DT, MaxRecurse); 3541845009290e4d804ad377927bd8a08cca3036adcDuncan Sands FV = SimplifyBinOp(Opcode, LHS, SI->getFalseValue(), TD, DT, MaxRecurse); 355b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } 356b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 3577cf85e74e3885005ca8e5fdb155fa5351e255b85Duncan Sands // If they simplified to the same value, then return the common value. 358124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands // If they both failed to simplify then return null. 359124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (TV == FV) 360b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return TV; 361b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 362b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // If one branch simplified to undef, return the other one. 363b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (TV && isa<UndefValue>(TV)) 364b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return FV; 365b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (FV && isa<UndefValue>(FV)) 366b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return TV; 367b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 368b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // If applying the operation did not change the true and false select values, 369b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // then the result of the binop is the select itself. 370124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (TV == SI->getTrueValue() && FV == SI->getFalseValue()) 371b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return SI; 372b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 373b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // If one branch simplified and the other did not, and the simplified 374b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // value is equal to the unsimplified one, return the simplified value. 375b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // For example, select (cond, X, X & Z) & Z -> X & Z. 376b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if ((FV && !TV) || (TV && !FV)) { 377b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // Check that the simplified value has the form "X op Y" where "op" is the 378b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // same as the original operation. 379b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Instruction *Simplified = dyn_cast<Instruction>(FV ? FV : TV); 380b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (Simplified && Simplified->getOpcode() == Opcode) { 381b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // The value that didn't simplify is "UnsimplifiedLHS op UnsimplifiedRHS". 382b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // We already know that "op" is the same as for the simplified value. See 383b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // if the operands match too. If so, return the simplified value. 384b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Value *UnsimplifiedBranch = FV ? SI->getTrueValue() : SI->getFalseValue(); 385b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Value *UnsimplifiedLHS = SI == LHS ? UnsimplifiedBranch : LHS; 386b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Value *UnsimplifiedRHS = SI == LHS ? RHS : UnsimplifiedBranch; 387124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (Simplified->getOperand(0) == UnsimplifiedLHS && 388124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands Simplified->getOperand(1) == UnsimplifiedRHS) 389b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return Simplified; 390b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (Simplified->isCommutative() && 391124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands Simplified->getOperand(1) == UnsimplifiedLHS && 392124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands Simplified->getOperand(0) == UnsimplifiedRHS) 393b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return Simplified; 394b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } 395b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } 396b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 397b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return 0; 398b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands} 399b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 400b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// ThreadCmpOverSelect - In the case of a comparison with a select instruction, 401b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// try to simplify the comparison by seeing whether both branches of the select 402b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// result in the same value. Returns the common value if so, otherwise returns 403b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands/// null. 404b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sandsstatic Value *ThreadCmpOverSelect(CmpInst::Predicate Pred, Value *LHS, 405a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands Value *RHS, const TargetData *TD, 4061845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const DominatorTree *DT, 407a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands unsigned MaxRecurse) { 4080312a93693abc2eb682b2b101c889959888fd883Duncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 4090312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (!MaxRecurse--) 4100312a93693abc2eb682b2b101c889959888fd883Duncan Sands return 0; 4110312a93693abc2eb682b2b101c889959888fd883Duncan Sands 412b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // Make sure the select is on the LHS. 413b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands if (!isa<SelectInst>(LHS)) { 414b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands std::swap(LHS, RHS); 415b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands Pred = CmpInst::getSwappedPredicate(Pred); 416b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands } 417b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands assert(isa<SelectInst>(LHS) && "Not comparing with a select instruction!"); 418b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands SelectInst *SI = cast<SelectInst>(LHS); 419b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 42050ca4d37f7f3b460c6441eb5ad14625a7d86b5d9Duncan Sands // Now that we have "cmp select(Cond, TV, FV), RHS", analyse it. 421b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // Does "cmp TV, RHS" simplify? 4221845009290e4d804ad377927bd8a08cca3036adcDuncan Sands if (Value *TCmp = SimplifyCmpInst(Pred, SI->getTrueValue(), RHS, TD, DT, 42350ca4d37f7f3b460c6441eb5ad14625a7d86b5d9Duncan Sands MaxRecurse)) { 424b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // It does! Does "cmp FV, RHS" simplify? 4251845009290e4d804ad377927bd8a08cca3036adcDuncan Sands if (Value *FCmp = SimplifyCmpInst(Pred, SI->getFalseValue(), RHS, TD, DT, 42650ca4d37f7f3b460c6441eb5ad14625a7d86b5d9Duncan Sands MaxRecurse)) { 427b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // It does! If they simplified to the same value, then use it as the 428b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // result of the original comparison. 429124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (TCmp == FCmp) 430b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return TCmp; 43150ca4d37f7f3b460c6441eb5ad14625a7d86b5d9Duncan Sands Value *Cond = SI->getCondition(); 43250ca4d37f7f3b460c6441eb5ad14625a7d86b5d9Duncan Sands // If the false value simplified to false, then the result of the compare 43350ca4d37f7f3b460c6441eb5ad14625a7d86b5d9Duncan Sands // is equal to "Cond && TCmp". This also catches the case when the false 43450ca4d37f7f3b460c6441eb5ad14625a7d86b5d9Duncan Sands // value simplified to false and the true value to true, returning "Cond". 43550ca4d37f7f3b460c6441eb5ad14625a7d86b5d9Duncan Sands if (match(FCmp, m_Zero())) 43650ca4d37f7f3b460c6441eb5ad14625a7d86b5d9Duncan Sands if (Value *V = SimplifyAndInst(Cond, TCmp, TD, DT, MaxRecurse)) 43750ca4d37f7f3b460c6441eb5ad14625a7d86b5d9Duncan Sands return V; 43850ca4d37f7f3b460c6441eb5ad14625a7d86b5d9Duncan Sands // If the true value simplified to true, then the result of the compare 43950ca4d37f7f3b460c6441eb5ad14625a7d86b5d9Duncan Sands // is equal to "Cond || FCmp". 44050ca4d37f7f3b460c6441eb5ad14625a7d86b5d9Duncan Sands if (match(TCmp, m_One())) 44150ca4d37f7f3b460c6441eb5ad14625a7d86b5d9Duncan Sands if (Value *V = SimplifyOrInst(Cond, FCmp, TD, DT, MaxRecurse)) 44250ca4d37f7f3b460c6441eb5ad14625a7d86b5d9Duncan Sands return V; 44350ca4d37f7f3b460c6441eb5ad14625a7d86b5d9Duncan Sands // Finally, if the false value simplified to true and the true value to 44450ca4d37f7f3b460c6441eb5ad14625a7d86b5d9Duncan Sands // false, then the result of the compare is equal to "!Cond". 44550ca4d37f7f3b460c6441eb5ad14625a7d86b5d9Duncan Sands if (match(FCmp, m_One()) && match(TCmp, m_Zero())) 44650ca4d37f7f3b460c6441eb5ad14625a7d86b5d9Duncan Sands if (Value *V = 44750ca4d37f7f3b460c6441eb5ad14625a7d86b5d9Duncan Sands SimplifyXorInst(Cond, Constant::getAllOnesValue(Cond->getType()), 44850ca4d37f7f3b460c6441eb5ad14625a7d86b5d9Duncan Sands TD, DT, MaxRecurse)) 44950ca4d37f7f3b460c6441eb5ad14625a7d86b5d9Duncan Sands return V; 45050ca4d37f7f3b460c6441eb5ad14625a7d86b5d9Duncan Sands } 45150ca4d37f7f3b460c6441eb5ad14625a7d86b5d9Duncan Sands } 45250ca4d37f7f3b460c6441eb5ad14625a7d86b5d9Duncan Sands 453b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return 0; 454b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands} 455b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 456a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// ThreadBinOpOverPHI - In the case of a binary operation with an operand that 457a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// is a PHI instruction, try to simplify the binop by seeing whether evaluating 458a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// it on the incoming phi values yields the same result for every value. If so 459a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// returns the common value, otherwise returns null. 460a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *ThreadBinOpOverPHI(unsigned Opcode, Value *LHS, Value *RHS, 4611845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const TargetData *TD, const DominatorTree *DT, 4621845009290e4d804ad377927bd8a08cca3036adcDuncan Sands unsigned MaxRecurse) { 4630312a93693abc2eb682b2b101c889959888fd883Duncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 4640312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (!MaxRecurse--) 4650312a93693abc2eb682b2b101c889959888fd883Duncan Sands return 0; 4660312a93693abc2eb682b2b101c889959888fd883Duncan Sands 467a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands PHINode *PI; 468a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands if (isa<PHINode>(LHS)) { 469a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands PI = cast<PHINode>(LHS); 4701845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // Bail out if RHS and the phi may be mutually interdependent due to a loop. 4711845009290e4d804ad377927bd8a08cca3036adcDuncan Sands if (!ValueDominatesPHI(RHS, PI, DT)) 4721845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return 0; 473a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands } else { 474a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands assert(isa<PHINode>(RHS) && "No PHI instruction operand!"); 475a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands PI = cast<PHINode>(RHS); 4761845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // Bail out if LHS and the phi may be mutually interdependent due to a loop. 4771845009290e4d804ad377927bd8a08cca3036adcDuncan Sands if (!ValueDominatesPHI(LHS, PI, DT)) 4781845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return 0; 479a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands } 480a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 481a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // Evaluate the BinOp on the incoming phi values. 482a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands Value *CommonValue = 0; 483a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands for (unsigned i = 0, e = PI->getNumIncomingValues(); i != e; ++i) { 484552008946530e01efdad15044e1f621883d14a3aDuncan Sands Value *Incoming = PI->getIncomingValue(i); 485ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // If the incoming value is the phi node itself, it can safely be skipped. 486552008946530e01efdad15044e1f621883d14a3aDuncan Sands if (Incoming == PI) continue; 487a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands Value *V = PI == LHS ? 4881845009290e4d804ad377927bd8a08cca3036adcDuncan Sands SimplifyBinOp(Opcode, Incoming, RHS, TD, DT, MaxRecurse) : 4891845009290e4d804ad377927bd8a08cca3036adcDuncan Sands SimplifyBinOp(Opcode, LHS, Incoming, TD, DT, MaxRecurse); 490a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the operation failed to simplify, or simplified to a different value 491a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // to previously, then give up. 492a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands if (!V || (CommonValue && V != CommonValue)) 493a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return 0; 494a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands CommonValue = V; 495a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands } 496a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 497a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return CommonValue; 498a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 499a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 500a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// ThreadCmpOverPHI - In the case of a comparison with a PHI instruction, try 501a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// try to simplify the comparison by seeing whether comparing with all of the 502a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// incoming phi values yields the same result every time. If so returns the 503a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands/// common result, otherwise returns null. 504a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *ThreadCmpOverPHI(CmpInst::Predicate Pred, Value *LHS, Value *RHS, 5051845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const TargetData *TD, const DominatorTree *DT, 5061845009290e4d804ad377927bd8a08cca3036adcDuncan Sands unsigned MaxRecurse) { 5070312a93693abc2eb682b2b101c889959888fd883Duncan Sands // Recursion is always used, so bail out at once if we already hit the limit. 5080312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (!MaxRecurse--) 5090312a93693abc2eb682b2b101c889959888fd883Duncan Sands return 0; 5100312a93693abc2eb682b2b101c889959888fd883Duncan Sands 511a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // Make sure the phi is on the LHS. 512a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands if (!isa<PHINode>(LHS)) { 513a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands std::swap(LHS, RHS); 514a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands Pred = CmpInst::getSwappedPredicate(Pred); 515a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands } 516a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands assert(isa<PHINode>(LHS) && "Not comparing with a phi instruction!"); 517a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands PHINode *PI = cast<PHINode>(LHS); 518a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 5191845009290e4d804ad377927bd8a08cca3036adcDuncan Sands // Bail out if RHS and the phi may be mutually interdependent due to a loop. 5201845009290e4d804ad377927bd8a08cca3036adcDuncan Sands if (!ValueDominatesPHI(RHS, PI, DT)) 5211845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return 0; 5221845009290e4d804ad377927bd8a08cca3036adcDuncan Sands 523a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // Evaluate the BinOp on the incoming phi values. 524a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands Value *CommonValue = 0; 525a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands for (unsigned i = 0, e = PI->getNumIncomingValues(); i != e; ++i) { 526552008946530e01efdad15044e1f621883d14a3aDuncan Sands Value *Incoming = PI->getIncomingValue(i); 527ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // If the incoming value is the phi node itself, it can safely be skipped. 528552008946530e01efdad15044e1f621883d14a3aDuncan Sands if (Incoming == PI) continue; 5291845009290e4d804ad377927bd8a08cca3036adcDuncan Sands Value *V = SimplifyCmpInst(Pred, Incoming, RHS, TD, DT, MaxRecurse); 530a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the operation failed to simplify, or simplified to a different value 531a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // to previously, then give up. 532a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands if (!V || (CommonValue && V != CommonValue)) 533a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return 0; 534a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands CommonValue = V; 535a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands } 536a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 537a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return CommonValue; 538a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 539a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 5408aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner/// SimplifyAddInst - Given operands for an Add, see if we can 541d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner/// fold the result. If not, this returns null. 542ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sandsstatic Value *SimplifyAddInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, 543ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands const TargetData *TD, const DominatorTree *DT, 544ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands unsigned MaxRecurse) { 545d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 546d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 547d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Constant *Ops[] = { CLHS, CRHS }; 5488aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner return ConstantFoldInstOperands(Instruction::Add, CLHS->getType(), 5491d2f569c3428d70d0cf690c9adb459ad4a3ecff2Jay Foad Ops, TD); 5508aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner } 55112a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 5528aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner // Canonicalize the constant to the RHS. 5538aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner std::swap(Op0, Op1); 5548aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner } 55512a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 556fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X + undef -> undef 557f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 558fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return Op1; 55912a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 560fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X + 0 -> X 561fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands if (match(Op1, m_Zero())) 562fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return Op0; 563fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 564fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X + (Y - X) -> Y 565fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // (Y - X) + X -> Y 566ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands // Eg: X + -X -> 0 567124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands Value *Y = 0; 568124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (match(Op1, m_Sub(m_Value(Y), m_Specific(Op0))) || 569124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands match(Op0, m_Sub(m_Value(Y), m_Specific(Op1)))) 570fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return Y; 571fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 572fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X + ~X -> -1 since ~X = -X-1 573124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (match(Op0, m_Not(m_Specific(Op1))) || 574124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands match(Op1, m_Not(m_Specific(Op0)))) 575fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return Constant::getAllOnesValue(Op0->getType()); 57687689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands 57782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands /// i1 add -> xor. 57875d289ed6201e82718343d7a36d2a2fa082f6217Duncan Sands if (MaxRecurse && Op0->getType()->isIntegerTy(1)) 57907f30fbd734069b80b90c6aeea0ae645ce3880c0Duncan Sands if (Value *V = SimplifyXorInst(Op0, Op1, TD, DT, MaxRecurse-1)) 58007f30fbd734069b80b90c6aeea0ae645ce3880c0Duncan Sands return V; 58182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 582566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Try some generic simplifications for associative operations. 583566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Value *V = SimplifyAssociativeBinOp(Instruction::Add, Op0, Op1, TD, DT, 584566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands MaxRecurse)) 585566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return V; 586566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 5873421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Mul distributes over Add. Try some generic simplifications based on this. 5883421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = FactorizeBinOp(Instruction::Add, Op0, Op1, Instruction::Mul, 5893421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands TD, DT, MaxRecurse)) 5903421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 5913421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 59287689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // Threading Add over selects and phi nodes is pointless, so don't bother. 59387689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // Threading over the select in "A + select(cond, B, C)" means evaluating 59487689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // "A+B" and "A+C" and seeing if they are equal; but they are equal if and 59587689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // only if B and C are equal. If B and C are equal then (since we assume 59687689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // that operands have already been simplified) "select(cond, B, C)" should 59787689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // have been simplified to the common value of B and C already. Analysing 59887689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // "A+B" and "A+C" thus gains nothing, but costs compile time. Similarly 59987689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // for threading over phi nodes. 60087689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands 6018aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner return 0; 6028aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner} 6038aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner 604ee9a2e322af96accc9e55ed6373c0057453714b1Duncan SandsValue *llvm::SimplifyAddInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, 605ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands const TargetData *TD, const DominatorTree *DT) { 606ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands return ::SimplifyAddInst(Op0, Op1, isNSW, isNUW, TD, DT, RecursionLimit); 607ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands} 608ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands 609fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands/// SimplifySubInst - Given operands for a Sub, see if we can 610fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands/// fold the result. If not, this returns null. 611ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sandsstatic Value *SimplifySubInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, 6123421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands const TargetData *TD, const DominatorTree *DT, 613ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands unsigned MaxRecurse) { 614fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands if (Constant *CLHS = dyn_cast<Constant>(Op0)) 615fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 616fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands Constant *Ops[] = { CLHS, CRHS }; 617fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return ConstantFoldInstOperands(Instruction::Sub, CLHS->getType(), 6181d2f569c3428d70d0cf690c9adb459ad4a3ecff2Jay Foad Ops, TD); 619fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands } 620fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 621fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X - undef -> undef 622fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // undef - X -> undef 623f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op0, m_Undef()) || match(Op1, m_Undef())) 624fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return UndefValue::get(Op0->getType()); 625fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 626fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X - 0 -> X 627fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands if (match(Op1, m_Zero())) 628fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return Op0; 629fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 630fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // X - X -> 0 631124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (Op0 == Op1) 632fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return Constant::getNullValue(Op0->getType()); 633fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 634fe02c69f84ad52d42be934e4fe702f03e4991a6aDuncan Sands // (X*2) - X -> X 635fe02c69f84ad52d42be934e4fe702f03e4991a6aDuncan Sands // (X<<1) - X -> X 636b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands Value *X = 0; 637fe02c69f84ad52d42be934e4fe702f03e4991a6aDuncan Sands if (match(Op0, m_Mul(m_Specific(Op1), m_ConstantInt<2>())) || 638fe02c69f84ad52d42be934e4fe702f03e4991a6aDuncan Sands match(Op0, m_Shl(m_Specific(Op1), m_One()))) 639fe02c69f84ad52d42be934e4fe702f03e4991a6aDuncan Sands return Op1; 640fe02c69f84ad52d42be934e4fe702f03e4991a6aDuncan Sands 641b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // (X + Y) - Z -> X + (Y - Z) or Y + (X - Z) if everything simplifies. 642b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // For example, (X + Y) - Y -> X; (Y + X) - Y -> X 643b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands Value *Y = 0, *Z = Op1; 644b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands if (MaxRecurse && match(Op0, m_Add(m_Value(X), m_Value(Y)))) { // (X + Y) - Z 645b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // See if "V === Y - Z" simplifies. 646b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands if (Value *V = SimplifyBinOp(Instruction::Sub, Y, Z, TD, DT, MaxRecurse-1)) 647b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does! Now see if "X + V" simplifies. 648b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands if (Value *W = SimplifyBinOp(Instruction::Add, X, V, TD, DT, 649b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands MaxRecurse-1)) { 650b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does, we successfully reassociated! 651b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands ++NumReassoc; 652b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands return W; 653b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands } 654b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // See if "V === X - Z" simplifies. 655b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands if (Value *V = SimplifyBinOp(Instruction::Sub, X, Z, TD, DT, MaxRecurse-1)) 656b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does! Now see if "Y + V" simplifies. 657b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands if (Value *W = SimplifyBinOp(Instruction::Add, Y, V, TD, DT, 658b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands MaxRecurse-1)) { 659b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does, we successfully reassociated! 660b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands ++NumReassoc; 661b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands return W; 662b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands } 663b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands } 66482fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 665b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // X - (Y + Z) -> (X - Y) - Z or (X - Z) - Y if everything simplifies. 666b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // For example, X - (X + 1) -> -1 667b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands X = Op0; 668b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands if (MaxRecurse && match(Op1, m_Add(m_Value(Y), m_Value(Z)))) { // X - (Y + Z) 669b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // See if "V === X - Y" simplifies. 670b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands if (Value *V = SimplifyBinOp(Instruction::Sub, X, Y, TD, DT, MaxRecurse-1)) 671b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does! Now see if "V - Z" simplifies. 672b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands if (Value *W = SimplifyBinOp(Instruction::Sub, V, Z, TD, DT, 673b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands MaxRecurse-1)) { 674b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does, we successfully reassociated! 675b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands ++NumReassoc; 676b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands return W; 677b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands } 678b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // See if "V === X - Z" simplifies. 679b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands if (Value *V = SimplifyBinOp(Instruction::Sub, X, Z, TD, DT, MaxRecurse-1)) 680b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does! Now see if "V - Y" simplifies. 681b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands if (Value *W = SimplifyBinOp(Instruction::Sub, V, Y, TD, DT, 682b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands MaxRecurse-1)) { 683b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does, we successfully reassociated! 684b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands ++NumReassoc; 685b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands return W; 686b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands } 687b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands } 688b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands 689b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // Z - (X - Y) -> (Z - X) + Y if everything simplifies. 690b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // For example, X - (X - Y) -> Y. 691b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands Z = Op0; 692c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands if (MaxRecurse && match(Op1, m_Sub(m_Value(X), m_Value(Y)))) // Z - (X - Y) 693c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands // See if "V === Z - X" simplifies. 694c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands if (Value *V = SimplifyBinOp(Instruction::Sub, Z, X, TD, DT, MaxRecurse-1)) 695b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // It does! Now see if "V + Y" simplifies. 696c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands if (Value *W = SimplifyBinOp(Instruction::Add, V, Y, TD, DT, 697c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands MaxRecurse-1)) { 698c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands // It does, we successfully reassociated! 699c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands ++NumReassoc; 700c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands return W; 701c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands } 702c087e20331c8a4c3b77d96a73588e80c06d89e3dDuncan Sands 7033421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Mul distributes over Sub. Try some generic simplifications based on this. 7043421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = FactorizeBinOp(Instruction::Sub, Op0, Op1, Instruction::Mul, 7053421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands TD, DT, MaxRecurse)) 7063421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 7073421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 708b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands // i1 sub -> xor. 709b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands if (MaxRecurse && Op0->getType()->isIntegerTy(1)) 710b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands if (Value *V = SimplifyXorInst(Op0, Op1, TD, DT, MaxRecurse-1)) 711b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands return V; 712b2f3c383ec62b959ee27d0a5fb890894c4e49e86Duncan Sands 713fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // Threading Sub over selects and phi nodes is pointless, so don't bother. 714fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // Threading over the select in "A - select(cond, B, C)" means evaluating 715fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // "A-B" and "A-C" and seeing if they are equal; but they are equal if and 716fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // only if B and C are equal. If B and C are equal then (since we assume 717fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // that operands have already been simplified) "select(cond, B, C)" should 718fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // have been simplified to the common value of B and C already. Analysing 719fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // "A-B" and "A-C" thus gains nothing, but costs compile time. Similarly 720fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands // for threading over phi nodes. 721fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 722fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands return 0; 723fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands} 724fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands 725ee9a2e322af96accc9e55ed6373c0057453714b1Duncan SandsValue *llvm::SimplifySubInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, 726ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands const TargetData *TD, const DominatorTree *DT) { 727ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands return ::SimplifySubInst(Op0, Op1, isNSW, isNUW, TD, DT, RecursionLimit); 728ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands} 729ee9a2e322af96accc9e55ed6373c0057453714b1Duncan Sands 73082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands/// SimplifyMulInst - Given operands for a Mul, see if we can 73182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands/// fold the result. If not, this returns null. 73282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sandsstatic Value *SimplifyMulInst(Value *Op0, Value *Op1, const TargetData *TD, 73382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands const DominatorTree *DT, unsigned MaxRecurse) { 73482fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 73582fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 73682fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands Constant *Ops[] = { CLHS, CRHS }; 73782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return ConstantFoldInstOperands(Instruction::Mul, CLHS->getType(), 7381d2f569c3428d70d0cf690c9adb459ad4a3ecff2Jay Foad Ops, TD); 73982fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands } 74082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 74182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // Canonicalize the constant to the RHS. 74282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands std::swap(Op0, Op1); 74382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands } 74482fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 74582fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // X * undef -> 0 746f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 74782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return Constant::getNullValue(Op0->getType()); 74882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 74982fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // X * 0 -> 0 75082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (match(Op1, m_Zero())) 75182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return Op1; 75282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 75382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // X * 1 -> X 75482fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (match(Op1, m_One())) 75582fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return Op0; 75682fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 7571895e98ef38afbe011575cc25f4889d96e37421bDuncan Sands // (X / Y) * Y -> X if the division is exact. 7581895e98ef38afbe011575cc25f4889d96e37421bDuncan Sands Value *X = 0, *Y = 0; 759aeaf3d484b4d4c35e8794378c4b6cfbbde718dd1Chris Lattner if ((match(Op0, m_IDiv(m_Value(X), m_Value(Y))) && Y == Op1) || // (X / Y) * Y 760aeaf3d484b4d4c35e8794378c4b6cfbbde718dd1Chris Lattner (match(Op1, m_IDiv(m_Value(X), m_Value(Y))) && Y == Op0)) { // Y * (X / Y) 761c6ee9181a51fdfa3c07e1e53695681c55aa98ce4Chris Lattner BinaryOperator *Div = cast<BinaryOperator>(Y == Op1 ? Op0 : Op1); 762c6ee9181a51fdfa3c07e1e53695681c55aa98ce4Chris Lattner if (Div->isExact()) 7631895e98ef38afbe011575cc25f4889d96e37421bDuncan Sands return X; 7641895e98ef38afbe011575cc25f4889d96e37421bDuncan Sands } 7651895e98ef38afbe011575cc25f4889d96e37421bDuncan Sands 7665413880654585f01ea9880f24f07f27c8da56ba8Nick Lewycky // i1 mul -> and. 76775d289ed6201e82718343d7a36d2a2fa082f6217Duncan Sands if (MaxRecurse && Op0->getType()->isIntegerTy(1)) 76807f30fbd734069b80b90c6aeea0ae645ce3880c0Duncan Sands if (Value *V = SimplifyAndInst(Op0, Op1, TD, DT, MaxRecurse-1)) 76907f30fbd734069b80b90c6aeea0ae645ce3880c0Duncan Sands return V; 77082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 77182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // Try some generic simplifications for associative operations. 77282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (Value *V = SimplifyAssociativeBinOp(Instruction::Mul, Op0, Op1, TD, DT, 77382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands MaxRecurse)) 77482fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return V; 77582fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 77682fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // Mul distributes over Add. Try some generic simplifications based on this. 77782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (Value *V = ExpandBinOp(Instruction::Mul, Op0, Op1, Instruction::Add, 77882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands TD, DT, MaxRecurse)) 77982fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return V; 78082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 78182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // If the operation is with the result of a select instruction, check whether 78282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // operating on either branch of the select always yields the same value. 78382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) 78482fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (Value *V = ThreadBinOpOverSelect(Instruction::Mul, Op0, Op1, TD, DT, 78582fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands MaxRecurse)) 78682fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return V; 78782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 78882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // If the operation is with the result of a phi instruction, check whether 78982fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands // operating on all incoming values of the phi always yields the same value. 79082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (isa<PHINode>(Op0) || isa<PHINode>(Op1)) 79182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands if (Value *V = ThreadBinOpOverPHI(Instruction::Mul, Op0, Op1, TD, DT, 79282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands MaxRecurse)) 79382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return V; 79482fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 79582fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return 0; 79682fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands} 79782fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 79882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan SandsValue *llvm::SimplifyMulInst(Value *Op0, Value *Op1, const TargetData *TD, 79982fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands const DominatorTree *DT) { 80082fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands return ::SimplifyMulInst(Op0, Op1, TD, DT, RecursionLimit); 80182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands} 80282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands 803593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands/// SimplifyDiv - Given operands for an SDiv or UDiv, see if we can 804593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands/// fold the result. If not, this returns null. 805479b4b9ef06dd84097202ffa6aea07913cdf651cAnders Carlssonstatic Value *SimplifyDiv(Instruction::BinaryOps Opcode, Value *Op0, Value *Op1, 806593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands const TargetData *TD, const DominatorTree *DT, 807593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands unsigned MaxRecurse) { 808593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Constant *C0 = dyn_cast<Constant>(Op0)) { 809593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Constant *C1 = dyn_cast<Constant>(Op1)) { 810593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands Constant *Ops[] = { C0, C1 }; 8111d2f569c3428d70d0cf690c9adb459ad4a3ecff2Jay Foad return ConstantFoldInstOperands(Opcode, C0->getType(), Ops, TD); 812593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands } 813593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands } 814593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 815a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands bool isSigned = Opcode == Instruction::SDiv; 816a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands 817593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // X / undef -> undef 818f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 819593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return Op1; 820593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 821593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // undef / X -> 0 822f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op0, m_Undef())) 823593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return Constant::getNullValue(Op0->getType()); 824593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 825593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // 0 / X -> 0, we don't need to preserve faults! 826593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (match(Op0, m_Zero())) 827593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return Op0; 828593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 829593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // X / 1 -> X 830593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (match(Op1, m_One())) 831593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return Op0; 832593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 833593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Op0->getType()->isIntegerTy(1)) 834593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // It can't be division by zero, hence it must be division by one. 835593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return Op0; 836593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 837593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // X / X -> 1 838593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Op0 == Op1) 839593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return ConstantInt::get(Op0->getType(), 1); 840593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 841593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // (X * Y) / Y -> X if the multiplication does not overflow. 842593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands Value *X = 0, *Y = 0; 843593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (match(Op0, m_Mul(m_Value(X), m_Value(Y))) && (X == Op1 || Y == Op1)) { 844593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Y != Op1) std::swap(X, Y); // Ensure expression is (X * Y) / Y, Y = Op1 8454b720718fbda1194f925e0a9d931bc220e8b0e3aDuncan Sands BinaryOperator *Mul = cast<BinaryOperator>(Op0); 8464b720718fbda1194f925e0a9d931bc220e8b0e3aDuncan Sands // If the Mul knows it does not overflow, then we are good to go. 8474b720718fbda1194f925e0a9d931bc220e8b0e3aDuncan Sands if ((isSigned && Mul->hasNoSignedWrap()) || 8484b720718fbda1194f925e0a9d931bc220e8b0e3aDuncan Sands (!isSigned && Mul->hasNoUnsignedWrap())) 8494b720718fbda1194f925e0a9d931bc220e8b0e3aDuncan Sands return X; 850593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands // If X has the form X = A / Y then X * Y cannot overflow. 851593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (BinaryOperator *Div = dyn_cast<BinaryOperator>(X)) 852593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Div->getOpcode() == Opcode && Div->getOperand(1) == Y) 853593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return X; 854593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands } 855593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 856a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands // (X rem Y) / Y -> 0 857a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands if ((isSigned && match(Op0, m_SRem(m_Value(), m_Specific(Op1)))) || 858a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands (!isSigned && match(Op0, m_URem(m_Value(), m_Specific(Op1))))) 859a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands return Constant::getNullValue(Op0->getType()); 860a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands 861a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands // If the operation is with the result of a select instruction, check whether 862a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands // operating on either branch of the select always yields the same value. 863a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) 864a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands if (Value *V = ThreadBinOpOverSelect(Opcode, Op0, Op1, TD, DT, MaxRecurse)) 865a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands return V; 866a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands 867a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands // If the operation is with the result of a phi instruction, check whether 868a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands // operating on all incoming values of the phi always yields the same value. 869a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands if (isa<PHINode>(Op0) || isa<PHINode>(Op1)) 870a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands if (Value *V = ThreadBinOpOverPHI(Opcode, Op0, Op1, TD, DT, MaxRecurse)) 871a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands return V; 872a3e292c7e85efb33899f08238f57a85996a05a0bDuncan Sands 873593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return 0; 874593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands} 875593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 876593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands/// SimplifySDivInst - Given operands for an SDiv, see if we can 877593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands/// fold the result. If not, this returns null. 878593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sandsstatic Value *SimplifySDivInst(Value *Op0, Value *Op1, const TargetData *TD, 879593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands const DominatorTree *DT, unsigned MaxRecurse) { 880593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Value *V = SimplifyDiv(Instruction::SDiv, Op0, Op1, TD, DT, MaxRecurse)) 881593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return V; 882593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 883593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return 0; 884593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands} 885593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 886593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan SandsValue *llvm::SimplifySDivInst(Value *Op0, Value *Op1, const TargetData *TD, 8871fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel const DominatorTree *DT) { 888593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return ::SimplifySDivInst(Op0, Op1, TD, DT, RecursionLimit); 889593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands} 890593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 891593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands/// SimplifyUDivInst - Given operands for a UDiv, see if we can 892593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands/// fold the result. If not, this returns null. 893593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sandsstatic Value *SimplifyUDivInst(Value *Op0, Value *Op1, const TargetData *TD, 894593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands const DominatorTree *DT, unsigned MaxRecurse) { 895593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands if (Value *V = SimplifyDiv(Instruction::UDiv, Op0, Op1, TD, DT, MaxRecurse)) 896593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return V; 897593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 898593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return 0; 899593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands} 900593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 901593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan SandsValue *llvm::SimplifyUDivInst(Value *Op0, Value *Op1, const TargetData *TD, 9021fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel const DominatorTree *DT) { 903593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands return ::SimplifyUDivInst(Op0, Op1, TD, DT, RecursionLimit); 904593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands} 905593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands 906f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sandsstatic Value *SimplifyFDivInst(Value *Op0, Value *Op1, const TargetData *, 907f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands const DominatorTree *, unsigned) { 9081fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel // undef / X -> undef (the undef could be a snan). 909f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op0, m_Undef())) 9101fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel return Op0; 9111fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel 9121fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel // X / undef -> undef 913f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 9141fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel return Op1; 9151fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel 9161fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel return 0; 9171fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel} 9181fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel 9191fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van BommelValue *llvm::SimplifyFDivInst(Value *Op0, Value *Op1, const TargetData *TD, 9201fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel const DominatorTree *DT) { 9211fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel return ::SimplifyFDivInst(Op0, Op1, TD, DT, RecursionLimit); 9221fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel} 9231fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel 924f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands/// SimplifyRem - Given operands for an SRem or URem, see if we can 925f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands/// fold the result. If not, this returns null. 926f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sandsstatic Value *SimplifyRem(Instruction::BinaryOps Opcode, Value *Op0, Value *Op1, 927f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands const TargetData *TD, const DominatorTree *DT, 928f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands unsigned MaxRecurse) { 929f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (Constant *C0 = dyn_cast<Constant>(Op0)) { 930f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (Constant *C1 = dyn_cast<Constant>(Op1)) { 931f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands Constant *Ops[] = { C0, C1 }; 9321d2f569c3428d70d0cf690c9adb459ad4a3ecff2Jay Foad return ConstantFoldInstOperands(Opcode, C0->getType(), Ops, TD); 933f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands } 934f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands } 935f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 936f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // X % undef -> undef 937f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op1, m_Undef())) 938f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Op1; 939f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 940f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // undef % X -> 0 941f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op0, m_Undef())) 942f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Constant::getNullValue(Op0->getType()); 943f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 944f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // 0 % X -> 0, we don't need to preserve faults! 945f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op0, m_Zero())) 946f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Op0; 947f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 948f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // X % 0 -> undef, we don't need to preserve faults! 949f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op1, m_Zero())) 950f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return UndefValue::get(Op0->getType()); 951f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 952f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // X % 1 -> 0 953f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op1, m_One())) 954f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Constant::getNullValue(Op0->getType()); 955f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 956f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (Op0->getType()->isIntegerTy(1)) 957f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // It can't be remainder by zero, hence it must be remainder by one. 958f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Constant::getNullValue(Op0->getType()); 959f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 960f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // X % X -> 0 961f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (Op0 == Op1) 962f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Constant::getNullValue(Op0->getType()); 963f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 964f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // If the operation is with the result of a select instruction, check whether 965f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // operating on either branch of the select always yields the same value. 966f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) 967f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (Value *V = ThreadBinOpOverSelect(Opcode, Op0, Op1, TD, DT, MaxRecurse)) 968f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return V; 969f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 970f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // If the operation is with the result of a phi instruction, check whether 971f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // operating on all incoming values of the phi always yields the same value. 972f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (isa<PHINode>(Op0) || isa<PHINode>(Op1)) 973f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (Value *V = ThreadBinOpOverPHI(Opcode, Op0, Op1, TD, DT, MaxRecurse)) 974f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return V; 975f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 976f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return 0; 977f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 978f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 979f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands/// SimplifySRemInst - Given operands for an SRem, see if we can 980f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands/// fold the result. If not, this returns null. 981f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sandsstatic Value *SimplifySRemInst(Value *Op0, Value *Op1, const TargetData *TD, 982f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands const DominatorTree *DT, unsigned MaxRecurse) { 983f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (Value *V = SimplifyRem(Instruction::SRem, Op0, Op1, TD, DT, MaxRecurse)) 984f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return V; 985f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 986f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return 0; 987f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 988f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 989f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan SandsValue *llvm::SimplifySRemInst(Value *Op0, Value *Op1, const TargetData *TD, 990f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands const DominatorTree *DT) { 991f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return ::SimplifySRemInst(Op0, Op1, TD, DT, RecursionLimit); 992f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 993f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 994f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands/// SimplifyURemInst - Given operands for a URem, see if we can 995f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands/// fold the result. If not, this returns null. 996f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sandsstatic Value *SimplifyURemInst(Value *Op0, Value *Op1, const TargetData *TD, 997f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands const DominatorTree *DT, unsigned MaxRecurse) { 998f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (Value *V = SimplifyRem(Instruction::URem, Op0, Op1, TD, DT, MaxRecurse)) 999f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return V; 1000f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1001f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return 0; 1002f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1003f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1004f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan SandsValue *llvm::SimplifyURemInst(Value *Op0, Value *Op1, const TargetData *TD, 1005f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands const DominatorTree *DT) { 1006f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return ::SimplifyURemInst(Op0, Op1, TD, DT, RecursionLimit); 1007f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1008f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1009f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sandsstatic Value *SimplifyFRemInst(Value *Op0, Value *Op1, const TargetData *, 1010f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands const DominatorTree *, unsigned) { 1011f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // undef % X -> undef (the undef could be a snan). 1012f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op0, m_Undef())) 1013f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Op0; 1014f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1015f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands // X % undef -> undef 1016f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands if (match(Op1, m_Undef())) 1017f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return Op1; 1018f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1019f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return 0; 1020f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1021f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1022f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan SandsValue *llvm::SimplifyFRemInst(Value *Op0, Value *Op1, const TargetData *TD, 1023f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands const DominatorTree *DT) { 1024f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands return ::SimplifyFRemInst(Op0, Op1, TD, DT, RecursionLimit); 1025f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands} 1026f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands 1027cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands/// SimplifyShift - Given operands for an Shl, LShr or AShr, see if we can 1028c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands/// fold the result. If not, this returns null. 1029cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sandsstatic Value *SimplifyShift(unsigned Opcode, Value *Op0, Value *Op1, 1030cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands const TargetData *TD, const DominatorTree *DT, 1031cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands unsigned MaxRecurse) { 1032c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands if (Constant *C0 = dyn_cast<Constant>(Op0)) { 1033c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands if (Constant *C1 = dyn_cast<Constant>(Op1)) { 1034c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands Constant *Ops[] = { C0, C1 }; 10351d2f569c3428d70d0cf690c9adb459ad4a3ecff2Jay Foad return ConstantFoldInstOperands(Opcode, C0->getType(), Ops, TD); 1036c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands } 1037c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands } 1038c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1039cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // 0 shift by X -> 0 1040c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands if (match(Op0, m_Zero())) 1041c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return Op0; 1042c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1043cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // X shift by 0 -> X 1044c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands if (match(Op1, m_Zero())) 1045c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return Op0; 1046c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1047cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // X shift by undef -> undef because it may shift by the bitwidth. 1048f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 1049c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return Op1; 1050c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1051c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands // Shifting by the bitwidth or more is undefined. 1052c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands if (ConstantInt *CI = dyn_cast<ConstantInt>(Op1)) 1053c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands if (CI->getValue().getLimitedValue() >= 1054c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands Op0->getType()->getScalarSizeInBits()) 1055c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return UndefValue::get(Op0->getType()); 1056c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1057cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // If the operation is with the result of a select instruction, check whether 1058cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // operating on either branch of the select always yields the same value. 1059cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) 1060cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands if (Value *V = ThreadBinOpOverSelect(Opcode, Op0, Op1, TD, DT, MaxRecurse)) 1061cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return V; 1062cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands 1063cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // If the operation is with the result of a phi instruction, check whether 1064cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // operating on all incoming values of the phi always yields the same value. 1065cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands if (isa<PHINode>(Op0) || isa<PHINode>(Op1)) 1066cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands if (Value *V = ThreadBinOpOverPHI(Opcode, Op0, Op1, TD, DT, MaxRecurse)) 1067cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return V; 1068cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands 1069cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return 0; 1070cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands} 1071cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands 1072cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands/// SimplifyShlInst - Given operands for an Shl, see if we can 1073cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands/// fold the result. If not, this returns null. 107481a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattnerstatic Value *SimplifyShlInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, 107581a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner const TargetData *TD, const DominatorTree *DT, 107681a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner unsigned MaxRecurse) { 1077cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands if (Value *V = SimplifyShift(Instruction::Shl, Op0, Op1, TD, DT, MaxRecurse)) 1078cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return V; 1079cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands 1080cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands // undef << X -> 0 1081f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op0, m_Undef())) 1082cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return Constant::getNullValue(Op0->getType()); 1083cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands 108481a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner // (X >> A) << A -> X 108581a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Value *X; 108681a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner if (match(Op0, m_Shr(m_Value(X), m_Specific(Op1))) && 108781a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner cast<PossiblyExactOperator>(Op0)->isExact()) 108881a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner return X; 1089c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return 0; 1090c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands} 1091c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 109281a0dc911586c77421c2255aa417dc9b350b9e20Chris LattnerValue *llvm::SimplifyShlInst(Value *Op0, Value *Op1, bool isNSW, bool isNUW, 109381a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner const TargetData *TD, const DominatorTree *DT) { 109481a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner return ::SimplifyShlInst(Op0, Op1, isNSW, isNUW, TD, DT, RecursionLimit); 1095c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands} 1096c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1097c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands/// SimplifyLShrInst - Given operands for an LShr, see if we can 1098c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands/// fold the result. If not, this returns null. 109981a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattnerstatic Value *SimplifyLShrInst(Value *Op0, Value *Op1, bool isExact, 110081a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner const TargetData *TD, const DominatorTree *DT, 110181a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner unsigned MaxRecurse) { 1102cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands if (Value *V = SimplifyShift(Instruction::LShr, Op0, Op1, TD, DT, MaxRecurse)) 1103cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return V; 1104c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1105c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands // undef >>l X -> 0 1106f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op0, m_Undef())) 1107c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return Constant::getNullValue(Op0->getType()); 1108c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 110981a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner // (X << A) >> A -> X 111081a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Value *X; 111181a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner if (match(Op0, m_Shl(m_Value(X), m_Specific(Op1))) && 111281a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner cast<OverflowingBinaryOperator>(Op0)->hasNoUnsignedWrap()) 111381a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner return X; 111452fb846578714d14bbde9b28884a6a8729217677Duncan Sands 1115c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return 0; 1116c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands} 1117c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 111881a0dc911586c77421c2255aa417dc9b350b9e20Chris LattnerValue *llvm::SimplifyLShrInst(Value *Op0, Value *Op1, bool isExact, 111981a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner const TargetData *TD, const DominatorTree *DT) { 112081a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner return ::SimplifyLShrInst(Op0, Op1, isExact, TD, DT, RecursionLimit); 1121c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands} 1122c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1123c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands/// SimplifyAShrInst - Given operands for an AShr, see if we can 1124c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands/// fold the result. If not, this returns null. 112581a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattnerstatic Value *SimplifyAShrInst(Value *Op0, Value *Op1, bool isExact, 112681a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner const TargetData *TD, const DominatorTree *DT, 112781a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner unsigned MaxRecurse) { 1128cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands if (Value *V = SimplifyShift(Instruction::AShr, Op0, Op1, TD, DT, MaxRecurse)) 1129cf80bc1d4ac741620641c2bf48c25993bd478bd0Duncan Sands return V; 1130c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1131c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands // all ones >>a X -> all ones 1132c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands if (match(Op0, m_AllOnes())) 1133c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return Op0; 1134c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 1135c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands // undef >>a X -> all ones 1136f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op0, m_Undef())) 1137c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return Constant::getAllOnesValue(Op0->getType()); 1138c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 113981a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner // (X << A) >> A -> X 114081a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Value *X; 114181a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner if (match(Op0, m_Shl(m_Value(X), m_Specific(Op1))) && 114281a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner cast<OverflowingBinaryOperator>(Op0)->hasNoSignedWrap()) 114381a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner return X; 114452fb846578714d14bbde9b28884a6a8729217677Duncan Sands 1145c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands return 0; 1146c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands} 1147c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 114881a0dc911586c77421c2255aa417dc9b350b9e20Chris LattnerValue *llvm::SimplifyAShrInst(Value *Op0, Value *Op1, bool isExact, 114981a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner const TargetData *TD, const DominatorTree *DT) { 115081a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner return ::SimplifyAShrInst(Op0, Op1, isExact, TD, DT, RecursionLimit); 1151c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands} 1152c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands 11538aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner/// SimplifyAndInst - Given operands for an And, see if we can 11548aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner/// fold the result. If not, this returns null. 1155a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *SimplifyAndInst(Value *Op0, Value *Op1, const TargetData *TD, 11561845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const DominatorTree *DT, unsigned MaxRecurse) { 11578aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 11588aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 11598aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner Constant *Ops[] = { CLHS, CRHS }; 1160d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return ConstantFoldInstOperands(Instruction::And, CLHS->getType(), 11611d2f569c3428d70d0cf690c9adb459ad4a3ecff2Jay Foad Ops, TD); 1162d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 116312a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1164d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // Canonicalize the constant to the RHS. 1165d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner std::swap(Op0, Op1); 1166d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 116712a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1168d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X & undef -> 0 1169f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 1170d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Constant::getNullValue(Op0->getType()); 117112a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1172d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X & X = X 1173124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (Op0 == Op1) 1174d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 117512a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 11762b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // X & 0 = 0 11772b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (match(Op1, m_Zero())) 1178d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op1; 117912a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 11802b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // X & -1 = X 11812b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (match(Op1, m_AllOnes())) 11822b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return Op0; 118312a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1184d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // A & ~A = ~A & A = 0 118581a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner if (match(Op0, m_Not(m_Specific(Op1))) || 118681a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner match(Op1, m_Not(m_Specific(Op0)))) 1187d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Constant::getNullValue(Op0->getType()); 118812a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1189d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // (A | ?) & A = A 119081a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Value *A = 0, *B = 0; 1191d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (match(Op0, m_Or(m_Value(A), m_Value(B))) && 1192124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands (A == Op1 || B == Op1)) 1193d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op1; 119412a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1195d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // A & (A | ?) = A 1196d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (match(Op1, m_Or(m_Value(A), m_Value(B))) && 1197124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands (A == Op0 || B == Op0)) 1198d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 119912a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1200566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Try some generic simplifications for associative operations. 1201566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Value *V = SimplifyAssociativeBinOp(Instruction::And, Op0, Op1, TD, DT, 1202566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands MaxRecurse)) 1203566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return V; 12046844c8ea5a67e551be7106d6b7b9e1a64eecbe51Benjamin Kramer 12053421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // And distributes over Or. Try some generic simplifications based on this. 12063421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = ExpandBinOp(Instruction::And, Op0, Op1, Instruction::Or, 12073421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands TD, DT, MaxRecurse)) 12083421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 12093421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 12103421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // And distributes over Xor. Try some generic simplifications based on this. 12113421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = ExpandBinOp(Instruction::And, Op0, Op1, Instruction::Xor, 12123421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands TD, DT, MaxRecurse)) 12133421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 12143421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 12153421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Or distributes over And. Try some generic simplifications based on this. 12163421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = FactorizeBinOp(Instruction::And, Op0, Op1, Instruction::Or, 12173421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands TD, DT, MaxRecurse)) 12183421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 12193421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1220b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // If the operation is with the result of a select instruction, check whether 1221b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // operating on either branch of the select always yields the same value. 12220312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) 12231845009290e4d804ad377927bd8a08cca3036adcDuncan Sands if (Value *V = ThreadBinOpOverSelect(Instruction::And, Op0, Op1, TD, DT, 12240312a93693abc2eb682b2b101c889959888fd883Duncan Sands MaxRecurse)) 1225a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return V; 1226a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 1227a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the operation is with the result of a phi instruction, check whether 1228a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // operating on all incoming values of the phi always yields the same value. 12290312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<PHINode>(Op0) || isa<PHINode>(Op1)) 12301845009290e4d804ad377927bd8a08cca3036adcDuncan Sands if (Value *V = ThreadBinOpOverPHI(Instruction::And, Op0, Op1, TD, DT, 12310312a93693abc2eb682b2b101c889959888fd883Duncan Sands MaxRecurse)) 1232b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return V; 1233b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 1234d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return 0; 1235d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner} 12369f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 12371845009290e4d804ad377927bd8a08cca3036adcDuncan SandsValue *llvm::SimplifyAndInst(Value *Op0, Value *Op1, const TargetData *TD, 12381845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const DominatorTree *DT) { 12391845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return ::SimplifyAndInst(Op0, Op1, TD, DT, RecursionLimit); 1240a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 1241a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 1242d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner/// SimplifyOrInst - Given operands for an Or, see if we can 12439f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner/// fold the result. If not, this returns null. 1244a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *SimplifyOrInst(Value *Op0, Value *Op1, const TargetData *TD, 12451845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const DominatorTree *DT, unsigned MaxRecurse) { 1246d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 1247d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 1248d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Constant *Ops[] = { CLHS, CRHS }; 1249d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return ConstantFoldInstOperands(Instruction::Or, CLHS->getType(), 12501d2f569c3428d70d0cf690c9adb459ad4a3ecff2Jay Foad Ops, TD); 1251d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 125212a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1253d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // Canonicalize the constant to the RHS. 1254d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner std::swap(Op0, Op1); 1255d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 125612a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1257d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X | undef -> -1 1258f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 1259d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Constant::getAllOnesValue(Op0->getType()); 126012a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1261d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // X | X = X 1262124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (Op0 == Op1) 1263d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 1264d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 12652b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // X | 0 = X 12662b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (match(Op1, m_Zero())) 1267d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 126812a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 12692b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // X | -1 = -1 12702b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (match(Op1, m_AllOnes())) 12712b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return Op1; 127212a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1273d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // A | ~A = ~A | A = -1 127481a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner if (match(Op0, m_Not(m_Specific(Op1))) || 127581a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner match(Op1, m_Not(m_Specific(Op0)))) 1276d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Constant::getAllOnesValue(Op0->getType()); 127712a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1278d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // (A & ?) | A = A 127981a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Value *A = 0, *B = 0; 1280d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (match(Op0, m_And(m_Value(A), m_Value(B))) && 1281124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands (A == Op1 || B == Op1)) 1282d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op1; 128312a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1284d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // A | (A & ?) = A 1285d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (match(Op1, m_And(m_Value(A), m_Value(B))) && 1286124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands (A == Op0 || B == Op0)) 1287d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return Op0; 128812a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 128938f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer // ~(A & ?) | A = -1 129038f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer if (match(Op0, m_Not(m_And(m_Value(A), m_Value(B)))) && 129138f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer (A == Op1 || B == Op1)) 129238f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer return Constant::getAllOnesValue(Op1->getType()); 129338f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer 129438f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer // A | ~(A & ?) = -1 129538f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer if (match(Op1, m_Not(m_And(m_Value(A), m_Value(B)))) && 129638f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer (A == Op0 || B == Op0)) 129738f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer return Constant::getAllOnesValue(Op0->getType()); 129838f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer 1299566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Try some generic simplifications for associative operations. 1300566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Value *V = SimplifyAssociativeBinOp(Instruction::Or, Op0, Op1, TD, DT, 1301566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands MaxRecurse)) 1302566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return V; 13036844c8ea5a67e551be7106d6b7b9e1a64eecbe51Benjamin Kramer 13043421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // Or distributes over And. Try some generic simplifications based on this. 13053421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = ExpandBinOp(Instruction::Or, Op0, Op1, Instruction::And, 13063421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands TD, DT, MaxRecurse)) 13073421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 13083421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 13093421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // And distributes over Or. Try some generic simplifications based on this. 13103421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = FactorizeBinOp(Instruction::Or, Op0, Op1, Instruction::And, 13113421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands TD, DT, MaxRecurse)) 13123421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 13133421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 1314b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // If the operation is with the result of a select instruction, check whether 1315b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // operating on either branch of the select always yields the same value. 13160312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<SelectInst>(Op0) || isa<SelectInst>(Op1)) 13171845009290e4d804ad377927bd8a08cca3036adcDuncan Sands if (Value *V = ThreadBinOpOverSelect(Instruction::Or, Op0, Op1, TD, DT, 13180312a93693abc2eb682b2b101c889959888fd883Duncan Sands MaxRecurse)) 1319a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return V; 1320a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 1321a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the operation is with the result of a phi instruction, check whether 1322a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // operating on all incoming values of the phi always yields the same value. 13230312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<PHINode>(Op0) || isa<PHINode>(Op1)) 13241845009290e4d804ad377927bd8a08cca3036adcDuncan Sands if (Value *V = ThreadBinOpOverPHI(Instruction::Or, Op0, Op1, TD, DT, 13250312a93693abc2eb682b2b101c889959888fd883Duncan Sands MaxRecurse)) 1326b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return V; 1327b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 13289f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner return 0; 13299f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner} 13309f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 13311845009290e4d804ad377927bd8a08cca3036adcDuncan SandsValue *llvm::SimplifyOrInst(Value *Op0, Value *Op1, const TargetData *TD, 13321845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const DominatorTree *DT) { 13331845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return ::SimplifyOrInst(Op0, Op1, TD, DT, RecursionLimit); 1334a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 1335d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 13362b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands/// SimplifyXorInst - Given operands for a Xor, see if we can 13372b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands/// fold the result. If not, this returns null. 13382b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sandsstatic Value *SimplifyXorInst(Value *Op0, Value *Op1, const TargetData *TD, 13392b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands const DominatorTree *DT, unsigned MaxRecurse) { 13402b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (Constant *CLHS = dyn_cast<Constant>(Op0)) { 13412b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (Constant *CRHS = dyn_cast<Constant>(Op1)) { 13422b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands Constant *Ops[] = { CLHS, CRHS }; 13432b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return ConstantFoldInstOperands(Instruction::Xor, CLHS->getType(), 13441d2f569c3428d70d0cf690c9adb459ad4a3ecff2Jay Foad Ops, TD); 13452b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands } 13462b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 13472b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // Canonicalize the constant to the RHS. 13482b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands std::swap(Op0, Op1); 13492b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands } 13502b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 13512b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // A ^ undef -> undef 1352f9e4a986c03fe3af7dbc9de0b0a9251280fbdf41Duncan Sands if (match(Op1, m_Undef())) 1353f8b1a5ea9602bb65a5cf59d3d34f2851a08cdc3eDuncan Sands return Op1; 13542b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 13552b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // A ^ 0 = A 13562b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (match(Op1, m_Zero())) 13572b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return Op0; 13582b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 1359f23d4adbfaf870d5fa67c6bff0da7891d3a98f9dEli Friedman // A ^ A = 0 1360f23d4adbfaf870d5fa67c6bff0da7891d3a98f9dEli Friedman if (Op0 == Op1) 1361f23d4adbfaf870d5fa67c6bff0da7891d3a98f9dEli Friedman return Constant::getNullValue(Op0->getType()); 1362f23d4adbfaf870d5fa67c6bff0da7891d3a98f9dEli Friedman 13632b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands // A ^ ~A = ~A ^ A = -1 136481a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner if (match(Op0, m_Not(m_Specific(Op1))) || 136581a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner match(Op1, m_Not(m_Specific(Op0)))) 13662b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return Constant::getAllOnesValue(Op0->getType()); 13672b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 1368566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // Try some generic simplifications for associative operations. 1369566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Value *V = SimplifyAssociativeBinOp(Instruction::Xor, Op0, Op1, TD, DT, 1370566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands MaxRecurse)) 1371566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return V; 13722b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 13733421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands // And distributes over Xor. Try some generic simplifications based on this. 13743421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands if (Value *V = FactorizeBinOp(Instruction::Xor, Op0, Op1, Instruction::And, 13753421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands TD, DT, MaxRecurse)) 13763421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands return V; 13773421d908539cc489d2b1dac67d8cbc07160b01dbDuncan Sands 137887689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // Threading Xor over selects and phi nodes is pointless, so don't bother. 137987689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // Threading over the select in "A ^ select(cond, B, C)" means evaluating 138087689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // "A^B" and "A^C" and seeing if they are equal; but they are equal if and 138187689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // only if B and C are equal. If B and C are equal then (since we assume 138287689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // that operands have already been simplified) "select(cond, B, C)" should 138387689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // have been simplified to the common value of B and C already. Analysing 138487689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // "A^B" and "A^C" thus gains nothing, but costs compile time. Similarly 138587689cfc54993959adb20b89a56bc58aad18ca56Duncan Sands // for threading over phi nodes. 13862b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 13872b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return 0; 13882b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands} 13892b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 13902b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan SandsValue *llvm::SimplifyXorInst(Value *Op0, Value *Op1, const TargetData *TD, 13912b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands const DominatorTree *DT) { 13922b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return ::SimplifyXorInst(Op0, Op1, TD, DT, RecursionLimit); 13932b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands} 13942b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands 1395db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattnerstatic Type *GetCompareTy(Value *Op) { 1396210c5d4880b525e064088b6fec713260128c16ebChris Lattner return CmpInst::makeCmpResultType(Op->getType()); 1397210c5d4880b525e064088b6fec713260128c16ebChris Lattner} 1398210c5d4880b525e064088b6fec713260128c16ebChris Lattner 1399e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands/// ExtractEquivalentCondition - Rummage around inside V looking for something 1400e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands/// equivalent to the comparison "LHS Pred RHS". Return such a value if found, 1401e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands/// otherwise return null. Helper function for analyzing max/min idioms. 1402e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sandsstatic Value *ExtractEquivalentCondition(Value *V, CmpInst::Predicate Pred, 1403e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands Value *LHS, Value *RHS) { 1404e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands SelectInst *SI = dyn_cast<SelectInst>(V); 1405e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (!SI) 1406e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return 0; 1407e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands CmpInst *Cmp = dyn_cast<CmpInst>(SI->getCondition()); 1408e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (!Cmp) 1409e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return 0; 1410e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands Value *CmpLHS = Cmp->getOperand(0), *CmpRHS = Cmp->getOperand(1); 1411e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Pred == Cmp->getPredicate() && LHS == CmpLHS && RHS == CmpRHS) 1412e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return Cmp; 1413e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Pred == CmpInst::getSwappedPredicate(Cmp->getPredicate()) && 1414e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands LHS == CmpRHS && RHS == CmpLHS) 1415e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return Cmp; 1416e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return 0; 1417e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands} 1418e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands 14199dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// SimplifyICmpInst - Given operands for an ICmpInst, see if we can 14209dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// fold the result. If not, this returns null. 1421a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS, 14221845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const TargetData *TD, const DominatorTree *DT, 14231845009290e4d804ad377927bd8a08cca3036adcDuncan Sands unsigned MaxRecurse) { 14249f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner CmpInst::Predicate Pred = (CmpInst::Predicate)Predicate; 14259dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner assert(CmpInst::isIntPredicate(Pred) && "Not an integer compare!"); 142612a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1427d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(LHS)) { 14288f73deaa8732a556046bf4ac6207be55972e3b74Chris Lattner if (Constant *CRHS = dyn_cast<Constant>(RHS)) 14298f73deaa8732a556046bf4ac6207be55972e3b74Chris Lattner return ConstantFoldCompareInstOperands(Pred, CLHS, CRHS, TD); 1430d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner 1431d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // If we have a constant, make sure it is on the RHS. 1432d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner std::swap(LHS, RHS); 1433d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Pred = CmpInst::getSwappedPredicate(Pred); 1434d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 143512a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1436db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *ITy = GetCompareTy(LHS); // The return type. 1437db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *OpTy = LHS->getType(); // The operand type. 143812a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1439210c5d4880b525e064088b6fec713260128c16ebChris Lattner // icmp X, X -> true/false 1440c8e14b3d37b80abb6adb4b831af0452d9ecbf2b2Chris Lattner // X icmp undef -> true/false. For example, icmp ugt %X, undef -> false 1441c8e14b3d37b80abb6adb4b831af0452d9ecbf2b2Chris Lattner // because X could be 0. 1442124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (LHS == RHS || isa<UndefValue>(RHS)) 1443210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(ITy, CmpInst::isTrueWhenEqual(Pred)); 144412a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 14456dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // Special case logic when the operands have i1 type. 14466dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (OpTy->isIntegerTy(1) || (OpTy->isVectorTy() && 14476dc91253ab1872e118b08511a09d5c934988354eDuncan Sands cast<VectorType>(OpTy)->getElementType()->isIntegerTy(1))) { 14486dc91253ab1872e118b08511a09d5c934988354eDuncan Sands switch (Pred) { 14496dc91253ab1872e118b08511a09d5c934988354eDuncan Sands default: break; 14506dc91253ab1872e118b08511a09d5c934988354eDuncan Sands case ICmpInst::ICMP_EQ: 14516dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // X == 1 -> X 14526dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (match(RHS, m_One())) 14536dc91253ab1872e118b08511a09d5c934988354eDuncan Sands return LHS; 14546dc91253ab1872e118b08511a09d5c934988354eDuncan Sands break; 14556dc91253ab1872e118b08511a09d5c934988354eDuncan Sands case ICmpInst::ICMP_NE: 14566dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // X != 0 -> X 14576dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (match(RHS, m_Zero())) 14586dc91253ab1872e118b08511a09d5c934988354eDuncan Sands return LHS; 14596dc91253ab1872e118b08511a09d5c934988354eDuncan Sands break; 14606dc91253ab1872e118b08511a09d5c934988354eDuncan Sands case ICmpInst::ICMP_UGT: 14616dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // X >u 0 -> X 14626dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (match(RHS, m_Zero())) 14636dc91253ab1872e118b08511a09d5c934988354eDuncan Sands return LHS; 14646dc91253ab1872e118b08511a09d5c934988354eDuncan Sands break; 14656dc91253ab1872e118b08511a09d5c934988354eDuncan Sands case ICmpInst::ICMP_UGE: 14666dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // X >=u 1 -> X 14676dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (match(RHS, m_One())) 14686dc91253ab1872e118b08511a09d5c934988354eDuncan Sands return LHS; 14696dc91253ab1872e118b08511a09d5c934988354eDuncan Sands break; 14706dc91253ab1872e118b08511a09d5c934988354eDuncan Sands case ICmpInst::ICMP_SLT: 14716dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // X <s 0 -> X 14726dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (match(RHS, m_Zero())) 14736dc91253ab1872e118b08511a09d5c934988354eDuncan Sands return LHS; 14746dc91253ab1872e118b08511a09d5c934988354eDuncan Sands break; 14756dc91253ab1872e118b08511a09d5c934988354eDuncan Sands case ICmpInst::ICMP_SLE: 14766dc91253ab1872e118b08511a09d5c934988354eDuncan Sands // X <=s -1 -> X 14776dc91253ab1872e118b08511a09d5c934988354eDuncan Sands if (match(RHS, m_One())) 14786dc91253ab1872e118b08511a09d5c934988354eDuncan Sands return LHS; 14796dc91253ab1872e118b08511a09d5c934988354eDuncan Sands break; 14806dc91253ab1872e118b08511a09d5c934988354eDuncan Sands } 14816dc91253ab1872e118b08511a09d5c934988354eDuncan Sands } 148212a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 1483d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands // icmp <alloca*>, <global/alloca*/null> - Different stack variables have 1484d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands // different addresses, and what's more the address of a stack variable is 1485d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands // never null or equal to the address of a global. Note that generalizing 1486d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands // to the case where LHS is a global variable address or null is pointless, 1487d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands // since if both LHS and RHS are constants then we already constant folded 1488d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands // the compare, and if only one of them is then we moved it to RHS already. 1489d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (isa<AllocaInst>(LHS) && (isa<GlobalValue>(RHS) || isa<AllocaInst>(RHS) || 1490d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands isa<ConstantPointerNull>(RHS))) 149158bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky // We already know that LHS != RHS. 1492d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands return ConstantInt::get(ITy, CmpInst::isFalseWhenEqual(Pred)); 1493d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands 1494d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands // If we are comparing with zero then try hard since this is a common case. 1495d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (match(RHS, m_Zero())) { 1496d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands bool LHSKnownNonNegative, LHSKnownNegative; 1497d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands switch (Pred) { 1498d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands default: 1499d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands assert(false && "Unknown ICmp predicate!"); 1500d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_ULT: 1501f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 1502d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_UGE: 1503f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 1504d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_EQ: 1505d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_ULE: 1506d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (isKnownNonZero(LHS, TD)) 1507f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 1508d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands break; 1509d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_NE: 1510d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_UGT: 1511d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (isKnownNonZero(LHS, TD)) 1512f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 1513d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands break; 1514d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_SLT: 1515d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, TD); 1516d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNegative) 1517f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 1518d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNonNegative) 1519f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 1520d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands break; 1521d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_SLE: 1522d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, TD); 1523d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNegative) 1524f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 1525d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNonNegative && isKnownNonZero(LHS, TD)) 1526f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 1527d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands break; 1528d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_SGE: 1529d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, TD); 1530d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNegative) 1531f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 1532d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNonNegative) 1533f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 1534d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands break; 1535d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands case ICmpInst::ICMP_SGT: 1536d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands ComputeSignBit(LHS, LHSKnownNonNegative, LHSKnownNegative, TD); 1537d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNegative) 1538f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 1539d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands if (LHSKnownNonNegative && isKnownNonZero(LHS, TD)) 1540f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 1541d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands break; 1542d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands } 1543d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands } 1544d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands 1545d70d1a5c44609af091f6fc3e29193f9f4756a74fDuncan Sands // See if we are doing a comparison with a constant integer. 1546210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) { 15473a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // Rule out tautological comparisons (eg., ult 0 or uge 0). 15483a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky ConstantRange RHS_CR = ICmpInst::makeConstantRange(Pred, CI->getValue()); 15493a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (RHS_CR.isEmptySet()) 15503a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky return ConstantInt::getFalse(CI->getContext()); 15513a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (RHS_CR.isFullSet()) 15523a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky return ConstantInt::getTrue(CI->getContext()); 15533a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky 15543a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // Many binary operators with constant RHS have easy to compute constant 15553a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // range. Use them to check whether the comparison is a tautology. 15563a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky uint32_t Width = CI->getBitWidth(); 15573a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt Lower = APInt(Width, 0); 15583a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt Upper = APInt(Width, 0); 15593a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky ConstantInt *CI2; 15603a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (match(LHS, m_URem(m_Value(), m_ConstantInt(CI2)))) { 15613a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'urem x, CI2' produces [0, CI2). 15623a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = CI2->getValue(); 15633a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_SRem(m_Value(), m_ConstantInt(CI2)))) { 15643a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'srem x, CI2' produces (-|CI2|, |CI2|). 15653a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = CI2->getValue().abs(); 15663a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Lower = (-Upper) + 1; 15673a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_UDiv(m_Value(), m_ConstantInt(CI2)))) { 15683a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'udiv x, CI2' produces [0, UINT_MAX / CI2]. 15693a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt NegOne = APInt::getAllOnesValue(Width); 15703a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (!CI2->isZero()) 15713a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = NegOne.udiv(CI2->getValue()) + 1; 15723a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_SDiv(m_Value(), m_ConstantInt(CI2)))) { 15733a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'sdiv x, CI2' produces [INT_MIN / CI2, INT_MAX / CI2]. 15743a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt IntMin = APInt::getSignedMinValue(Width); 15753a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt IntMax = APInt::getSignedMaxValue(Width); 15763a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt Val = CI2->getValue().abs(); 15773a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (!Val.isMinValue()) { 15783a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Lower = IntMin.sdiv(Val); 15793a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = IntMax.sdiv(Val) + 1; 15803a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } 15813a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_LShr(m_Value(), m_ConstantInt(CI2)))) { 15823a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'lshr x, CI2' produces [0, UINT_MAX >> CI2]. 15833a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt NegOne = APInt::getAllOnesValue(Width); 15843a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (CI2->getValue().ult(Width)) 15853a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = NegOne.lshr(CI2->getValue()) + 1; 15863a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_AShr(m_Value(), m_ConstantInt(CI2)))) { 15873a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'ashr x, CI2' produces [INT_MIN >> CI2, INT_MAX >> CI2]. 15883a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt IntMin = APInt::getSignedMinValue(Width); 15893a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky APInt IntMax = APInt::getSignedMaxValue(Width); 15903a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (CI2->getValue().ult(Width)) { 15913a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Lower = IntMin.ashr(CI2->getValue()); 15923a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = IntMax.ashr(CI2->getValue()) + 1; 15933a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } 15943a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_Or(m_Value(), m_ConstantInt(CI2)))) { 15953a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'or x, CI2' produces [CI2, UINT_MAX]. 15963a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Lower = CI2->getValue(); 15973a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } else if (match(LHS, m_And(m_Value(), m_ConstantInt(CI2)))) { 15983a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky // 'and x, CI2' produces [0, CI2]. 15993a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky Upper = CI2->getValue() + 1; 16003a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky } 16013a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (Lower != Upper) { 16023a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky ConstantRange LHS_CR = ConstantRange(Lower, Upper); 16033a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (RHS_CR.contains(LHS_CR)) 16043a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky return ConstantInt::getTrue(RHS->getContext()); 16053a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky if (RHS_CR.inverse().contains(LHS_CR)) 16063a73e343d02ba3a00adf03311183cc0ccc960978Nick Lewycky return ConstantInt::getFalse(RHS->getContext()); 1607210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 1608210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 16091ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands 16109d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Compare of cast, for example (zext X) != 0 -> X != 0 16119d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (isa<CastInst>(LHS) && (isa<Constant>(RHS) || isa<CastInst>(RHS))) { 16129d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Instruction *LI = cast<CastInst>(LHS); 16139d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Value *SrcOp = LI->getOperand(0); 1614db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *SrcTy = SrcOp->getType(); 1615db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *DstTy = LI->getType(); 16169d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 16179d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Turn icmp (ptrtoint x), (ptrtoint/constant) into a compare of the input 16189d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // if the integer type is the same size as the pointer type. 16199d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (MaxRecurse && TD && isa<PtrToIntInst>(LI) && 16209d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands TD->getPointerSizeInBits() == DstTy->getPrimitiveSizeInBits()) { 16219d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Constant *RHSC = dyn_cast<Constant>(RHS)) { 16229d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Transfer the cast to the constant. 16239d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(Pred, SrcOp, 16249d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantExpr::getIntToPtr(RHSC, SrcTy), 16259d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands TD, DT, MaxRecurse-1)) 16269d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 16279d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } else if (PtrToIntInst *RI = dyn_cast<PtrToIntInst>(RHS)) { 16289d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (RI->getOperand(0)->getType() == SrcTy) 16299d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Compare without the cast. 16309d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(Pred, SrcOp, RI->getOperand(0), 16319d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands TD, DT, MaxRecurse-1)) 16329d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 16339d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 16349d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 16359d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 16369d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (isa<ZExtInst>(LHS)) { 16379d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Turn icmp (zext X), (zext Y) into a compare of X and Y if they have the 16389d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // same type. 16399d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (ZExtInst *RI = dyn_cast<ZExtInst>(RHS)) { 16409d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (MaxRecurse && SrcTy == RI->getOperand(0)->getType()) 16419d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Compare X and Y. Note that signed predicates become unsigned. 16429d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(ICmpInst::getUnsignedPredicate(Pred), 16439d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands SrcOp, RI->getOperand(0), TD, DT, 16449d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands MaxRecurse-1)) 16459d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 16469d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 16479d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Turn icmp (zext X), Cst into a compare of X and Cst if Cst is extended 16489d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // too. If not, then try to deduce the result of the comparison. 16499d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands else if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) { 16509d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Compute the constant that would happen if we truncated to SrcTy then 16519d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // reextended to DstTy. 16529d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant *Trunc = ConstantExpr::getTrunc(CI, SrcTy); 16539d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant *RExt = ConstantExpr::getCast(CastInst::ZExt, Trunc, DstTy); 16549d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 16559d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // If the re-extended constant didn't change then this is effectively 16569d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // also a case of comparing two zero-extended values. 16579d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (RExt == CI && MaxRecurse) 16589d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(ICmpInst::getUnsignedPredicate(Pred), 16599d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands SrcOp, Trunc, TD, DT, MaxRecurse-1)) 16609d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 16619d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 16629d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Otherwise the upper bits of LHS are zero while RHS has a non-zero bit 16639d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // there. Use this to work out the result of the comparison. 16649d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (RExt != CI) { 16659d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands switch (Pred) { 16669d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands default: 16679d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands assert(false && "Unknown ICmp predicate!"); 16689d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // LHS <u RHS. 16699d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_EQ: 16709d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_UGT: 16719d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_UGE: 16729d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return ConstantInt::getFalse(CI->getContext()); 16739d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 16749d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_NE: 16759d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_ULT: 16769d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_ULE: 16779d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return ConstantInt::getTrue(CI->getContext()); 16789d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 16799d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // LHS is non-negative. If RHS is negative then LHS >s LHS. If RHS 16809d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // is non-negative then LHS <s RHS. 16819d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SGT: 16829d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SGE: 16839d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return CI->getValue().isNegative() ? 16849d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getTrue(CI->getContext()) : 16859d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getFalse(CI->getContext()); 16869d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 16879d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SLT: 16889d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SLE: 16899d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return CI->getValue().isNegative() ? 16909d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getFalse(CI->getContext()) : 16919d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getTrue(CI->getContext()); 16929d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 16939d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 16949d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 16959d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 16969d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 16979d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (isa<SExtInst>(LHS)) { 16989d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Turn icmp (sext X), (sext Y) into a compare of X and Y if they have the 16999d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // same type. 17009d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (SExtInst *RI = dyn_cast<SExtInst>(RHS)) { 17019d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (MaxRecurse && SrcTy == RI->getOperand(0)->getType()) 17029d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Compare X and Y. Note that the predicate does not change. 17039d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(Pred, SrcOp, RI->getOperand(0), 17049d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands TD, DT, MaxRecurse-1)) 17059d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 17069d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 17079d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Turn icmp (sext X), Cst into a compare of X and Cst if Cst is extended 17089d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // too. If not, then try to deduce the result of the comparison. 17099d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands else if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) { 17109d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Compute the constant that would happen if we truncated to SrcTy then 17119d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // reextended to DstTy. 17129d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant *Trunc = ConstantExpr::getTrunc(CI, SrcTy); 17139d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant *RExt = ConstantExpr::getCast(CastInst::SExt, Trunc, DstTy); 17149d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 17159d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // If the re-extended constant didn't change then this is effectively 17169d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // also a case of comparing two sign-extended values. 17179d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (RExt == CI && MaxRecurse) 17189d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(Pred, SrcOp, Trunc, TD, DT, 17199d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands MaxRecurse-1)) 17209d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 17219d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 17229d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Otherwise the upper bits of LHS are all equal, while RHS has varying 17239d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // bits there. Use this to work out the result of the comparison. 17249d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (RExt != CI) { 17259d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands switch (Pred) { 17269d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands default: 17279d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands assert(false && "Unknown ICmp predicate!"); 17289d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_EQ: 17299d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return ConstantInt::getFalse(CI->getContext()); 17309d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_NE: 17319d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return ConstantInt::getTrue(CI->getContext()); 17329d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 17339d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // If RHS is non-negative then LHS <s RHS. If RHS is negative then 17349d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // LHS >s RHS. 17359d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SGT: 17369d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SGE: 17379d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return CI->getValue().isNegative() ? 17389d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getTrue(CI->getContext()) : 17399d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getFalse(CI->getContext()); 17409d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SLT: 17419d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_SLE: 17429d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return CI->getValue().isNegative() ? 17439d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getFalse(CI->getContext()) : 17449d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands ConstantInt::getTrue(CI->getContext()); 17459d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 17469d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // If LHS is non-negative then LHS <u RHS. If LHS is negative then 17479d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // LHS >u RHS. 17489d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_UGT: 17499d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_UGE: 17509d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Comparison is true iff the LHS <s 0. 17519d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (MaxRecurse) 17529d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(ICmpInst::ICMP_SLT, SrcOp, 17539d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant::getNullValue(SrcTy), 17549d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands TD, DT, MaxRecurse-1)) 17559d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 17569d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands break; 17579d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_ULT: 17589d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands case ICmpInst::ICMP_ULE: 17599d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // Comparison is true iff the LHS >=s 0. 17609d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (MaxRecurse) 17619d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (Value *V = SimplifyICmpInst(ICmpInst::ICMP_SGE, SrcOp, 17629d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant::getNullValue(SrcTy), 17639d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands TD, DT, MaxRecurse-1)) 17649d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return V; 17659d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands break; 17669d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 17679d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 17689d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 17699d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 17709d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands } 17719d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 177252fb846578714d14bbde9b28884a6a8729217677Duncan Sands // Special logic for binary operators. 177352fb846578714d14bbde9b28884a6a8729217677Duncan Sands BinaryOperator *LBO = dyn_cast<BinaryOperator>(LHS); 177452fb846578714d14bbde9b28884a6a8729217677Duncan Sands BinaryOperator *RBO = dyn_cast<BinaryOperator>(RHS); 177552fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (MaxRecurse && (LBO || RBO)) { 177652fb846578714d14bbde9b28884a6a8729217677Duncan Sands // Analyze the case when either LHS or RHS is an add instruction. 177752fb846578714d14bbde9b28884a6a8729217677Duncan Sands Value *A = 0, *B = 0, *C = 0, *D = 0; 177852fb846578714d14bbde9b28884a6a8729217677Duncan Sands // LHS = A + B (or A and B are null); RHS = C + D (or C and D are null). 177952fb846578714d14bbde9b28884a6a8729217677Duncan Sands bool NoLHSWrapProblem = false, NoRHSWrapProblem = false; 178052fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (LBO && LBO->getOpcode() == Instruction::Add) { 178152fb846578714d14bbde9b28884a6a8729217677Duncan Sands A = LBO->getOperand(0); B = LBO->getOperand(1); 178252fb846578714d14bbde9b28884a6a8729217677Duncan Sands NoLHSWrapProblem = ICmpInst::isEquality(Pred) || 178352fb846578714d14bbde9b28884a6a8729217677Duncan Sands (CmpInst::isUnsigned(Pred) && LBO->hasNoUnsignedWrap()) || 178452fb846578714d14bbde9b28884a6a8729217677Duncan Sands (CmpInst::isSigned(Pred) && LBO->hasNoSignedWrap()); 178552fb846578714d14bbde9b28884a6a8729217677Duncan Sands } 178652fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (RBO && RBO->getOpcode() == Instruction::Add) { 178752fb846578714d14bbde9b28884a6a8729217677Duncan Sands C = RBO->getOperand(0); D = RBO->getOperand(1); 178852fb846578714d14bbde9b28884a6a8729217677Duncan Sands NoRHSWrapProblem = ICmpInst::isEquality(Pred) || 178952fb846578714d14bbde9b28884a6a8729217677Duncan Sands (CmpInst::isUnsigned(Pred) && RBO->hasNoUnsignedWrap()) || 179052fb846578714d14bbde9b28884a6a8729217677Duncan Sands (CmpInst::isSigned(Pred) && RBO->hasNoSignedWrap()); 179152fb846578714d14bbde9b28884a6a8729217677Duncan Sands } 179252fb846578714d14bbde9b28884a6a8729217677Duncan Sands 179352fb846578714d14bbde9b28884a6a8729217677Duncan Sands // icmp (X+Y), X -> icmp Y, 0 for equalities or if there is no overflow. 179452fb846578714d14bbde9b28884a6a8729217677Duncan Sands if ((A == RHS || B == RHS) && NoLHSWrapProblem) 179552fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (Value *V = SimplifyICmpInst(Pred, A == RHS ? B : A, 179652fb846578714d14bbde9b28884a6a8729217677Duncan Sands Constant::getNullValue(RHS->getType()), 179752fb846578714d14bbde9b28884a6a8729217677Duncan Sands TD, DT, MaxRecurse-1)) 179852fb846578714d14bbde9b28884a6a8729217677Duncan Sands return V; 179952fb846578714d14bbde9b28884a6a8729217677Duncan Sands 180052fb846578714d14bbde9b28884a6a8729217677Duncan Sands // icmp X, (X+Y) -> icmp 0, Y for equalities or if there is no overflow. 180152fb846578714d14bbde9b28884a6a8729217677Duncan Sands if ((C == LHS || D == LHS) && NoRHSWrapProblem) 180252fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (Value *V = SimplifyICmpInst(Pred, 180352fb846578714d14bbde9b28884a6a8729217677Duncan Sands Constant::getNullValue(LHS->getType()), 180452fb846578714d14bbde9b28884a6a8729217677Duncan Sands C == LHS ? D : C, TD, DT, MaxRecurse-1)) 180552fb846578714d14bbde9b28884a6a8729217677Duncan Sands return V; 180652fb846578714d14bbde9b28884a6a8729217677Duncan Sands 180752fb846578714d14bbde9b28884a6a8729217677Duncan Sands // icmp (X+Y), (X+Z) -> icmp Y,Z for equalities or if there is no overflow. 180852fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (A && C && (A == C || A == D || B == C || B == D) && 180952fb846578714d14bbde9b28884a6a8729217677Duncan Sands NoLHSWrapProblem && NoRHSWrapProblem) { 181052fb846578714d14bbde9b28884a6a8729217677Duncan Sands // Determine Y and Z in the form icmp (X+Y), (X+Z). 181152fb846578714d14bbde9b28884a6a8729217677Duncan Sands Value *Y = (A == C || A == D) ? B : A; 181252fb846578714d14bbde9b28884a6a8729217677Duncan Sands Value *Z = (C == A || C == B) ? D : C; 181352fb846578714d14bbde9b28884a6a8729217677Duncan Sands if (Value *V = SimplifyICmpInst(Pred, Y, Z, TD, DT, MaxRecurse-1)) 181452fb846578714d14bbde9b28884a6a8729217677Duncan Sands return V; 181552fb846578714d14bbde9b28884a6a8729217677Duncan Sands } 181652fb846578714d14bbde9b28884a6a8729217677Duncan Sands } 181752fb846578714d14bbde9b28884a6a8729217677Duncan Sands 181884dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky if (LBO && match(LBO, m_URem(m_Value(), m_Specific(RHS)))) { 1819786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky bool KnownNonNegative, KnownNegative; 182088cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky switch (Pred) { 182188cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky default: 182288cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky break; 1823786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky case ICmpInst::ICMP_SGT: 1824786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky case ICmpInst::ICMP_SGE: 1825786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky ComputeSignBit(LHS, KnownNonNegative, KnownNegative, TD); 1826786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky if (!KnownNonNegative) 1827786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky break; 1828786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky // fall-through 182988cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky case ICmpInst::ICMP_EQ: 183088cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky case ICmpInst::ICMP_UGT: 183188cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky case ICmpInst::ICMP_UGE: 1832f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 1833786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky case ICmpInst::ICMP_SLT: 1834786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky case ICmpInst::ICMP_SLE: 1835786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky ComputeSignBit(LHS, KnownNonNegative, KnownNegative, TD); 1836786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky if (!KnownNonNegative) 1837786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky break; 1838786792784e898f29febb3e7270d54b0e21e3c904Nick Lewycky // fall-through 183988cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky case ICmpInst::ICMP_NE: 184088cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky case ICmpInst::ICMP_ULT: 184188cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky case ICmpInst::ICMP_ULE: 1842f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 184388cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky } 184488cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky } 184584dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky if (RBO && match(RBO, m_URem(m_Value(), m_Specific(LHS)))) { 184684dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky bool KnownNonNegative, KnownNegative; 184784dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky switch (Pred) { 184884dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky default: 184984dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky break; 185084dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_SGT: 185184dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_SGE: 185284dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky ComputeSignBit(RHS, KnownNonNegative, KnownNegative, TD); 185384dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky if (!KnownNonNegative) 185484dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky break; 185584dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky // fall-through 1856a0e2f38b25ce7c51c22ed40d8a315fe1dd98926dNick Lewycky case ICmpInst::ICMP_NE: 185784dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_UGT: 185884dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_UGE: 1859f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 186084dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_SLT: 186184dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_SLE: 186284dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky ComputeSignBit(RHS, KnownNonNegative, KnownNegative, TD); 186384dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky if (!KnownNonNegative) 186484dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky break; 186584dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky // fall-through 1866a0e2f38b25ce7c51c22ed40d8a315fe1dd98926dNick Lewycky case ICmpInst::ICMP_EQ: 186784dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_ULT: 186884dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky case ICmpInst::ICMP_ULE: 1869f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 187084dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky } 187184dd4fa2e36f72050f5c46577359f5df0467e3e4Nick Lewycky } 187288cd0aadb2849a259e8656b0ff8439ef660db7c5Nick Lewycky 187358bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (MaxRecurse && LBO && RBO && LBO->getOpcode() == RBO->getOpcode() && 187458bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky LBO->getOperand(1) == RBO->getOperand(1)) { 187558bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky switch (LBO->getOpcode()) { 187658bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky default: break; 187758bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::UDiv: 187858bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::LShr: 187958bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (ICmpInst::isSigned(Pred)) 188058bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 188158bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky // fall-through 188258bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::SDiv: 188358bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::AShr: 1884b6e7cd655c6ee119dbeacc321ee92387f983edb0Eli Friedman if (!LBO->isExact() || !RBO->isExact()) 188558bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 188658bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (Value *V = SimplifyICmpInst(Pred, LBO->getOperand(0), 188758bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky RBO->getOperand(0), TD, DT, MaxRecurse-1)) 188858bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky return V; 188958bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 189058bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::Shl: { 1891c9d904ee2ca36ab6238ed93c7ad2ea67b5fd0a23Duncan Sands bool NUW = LBO->hasNoUnsignedWrap() && RBO->hasNoUnsignedWrap(); 189258bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky bool NSW = LBO->hasNoSignedWrap() && RBO->hasNoSignedWrap(); 189358bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (!NUW && !NSW) 189458bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 189558bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (!NSW && ICmpInst::isSigned(Pred)) 189658bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 189758bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (Value *V = SimplifyICmpInst(Pred, LBO->getOperand(0), 189858bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky RBO->getOperand(0), TD, DT, MaxRecurse-1)) 189958bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky return V; 190058bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 190158bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky } 190258bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky } 190358bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky } 190458bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky 1905ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Simplify comparisons involving max/min. 1906ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands Value *A, *B; 1907ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands CmpInst::Predicate P = CmpInst::BAD_ICMP_PREDICATE; 1908ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands CmpInst::Predicate EqP; // Chosen so that "A == max/min(A,B)" iff "A EqP B". 1909ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands 19108140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Signed variants on "max(a,b)>=a -> true". 1911ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (match(LHS, m_SMax(m_Value(A), m_Value(B))) && (A == RHS || B == RHS)) { 1912ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != RHS) std::swap(A, B); // smax(A, B) pred A. 1913ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands EqP = CmpInst::ICMP_SGE; // "A == smax(A, B)" iff "A sge B". 1914ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as smax(A, B) pred A. 1915ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = Pred; 1916ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } else if (match(RHS, m_SMax(m_Value(A), m_Value(B))) && 1917ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands (A == LHS || B == LHS)) { 1918ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != LHS) std::swap(A, B); // A pred smax(A, B). 1919ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands EqP = CmpInst::ICMP_SGE; // "A == smax(A, B)" iff "A sge B". 1920ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as smax(A, B) swapped-pred A. 1921ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = CmpInst::getSwappedPredicate(Pred); 1922ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } else if (match(LHS, m_SMin(m_Value(A), m_Value(B))) && 1923ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands (A == RHS || B == RHS)) { 1924ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != RHS) std::swap(A, B); // smin(A, B) pred A. 1925ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands EqP = CmpInst::ICMP_SLE; // "A == smin(A, B)" iff "A sle B". 1926ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as smax(-A, -B) swapped-pred -A. 1927ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Note that we do not need to actually form -A or -B thanks to EqP. 1928ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = CmpInst::getSwappedPredicate(Pred); 1929ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } else if (match(RHS, m_SMin(m_Value(A), m_Value(B))) && 1930ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands (A == LHS || B == LHS)) { 1931ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != LHS) std::swap(A, B); // A pred smin(A, B). 1932ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands EqP = CmpInst::ICMP_SLE; // "A == smin(A, B)" iff "A sle B". 1933ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as smax(-A, -B) pred -A. 1934ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Note that we do not need to actually form -A or -B thanks to EqP. 1935ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = Pred; 1936ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } 1937ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (P != CmpInst::BAD_ICMP_PREDICATE) { 1938ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Cases correspond to "max(A, B) p A". 1939ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands switch (P) { 1940ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands default: 1941ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands break; 1942ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_EQ: 1943ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_SLE: 1944e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Equivalent to "A EqP B". This may be the same as the condition tested 1945e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // in the max/min; if so, we can just return that. 1946e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(LHS, EqP, A, B)) 1947e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 1948e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(RHS, EqP, A, B)) 1949e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 1950e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Otherwise, see if "A EqP B" simplifies. 1951ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (MaxRecurse) 1952ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (Value *V = SimplifyICmpInst(EqP, A, B, TD, DT, MaxRecurse-1)) 1953ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands return V; 1954ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands break; 1955ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_NE: 1956e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands case CmpInst::ICMP_SGT: { 1957e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands CmpInst::Predicate InvEqP = CmpInst::getInversePredicate(EqP); 1958e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Equivalent to "A InvEqP B". This may be the same as the condition 1959e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // tested in the max/min; if so, we can just return that. 1960e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(LHS, InvEqP, A, B)) 1961e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 1962e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(RHS, InvEqP, A, B)) 1963e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 1964e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Otherwise, see if "A InvEqP B" simplifies. 1965ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (MaxRecurse) 1966e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = SimplifyICmpInst(InvEqP, A, B, TD, DT, MaxRecurse-1)) 1967ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands return V; 1968ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands break; 1969e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands } 1970ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_SGE: 1971ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Always true. 1972f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 1973ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_SLT: 1974ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Always false. 1975f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 1976ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } 1977ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } 1978ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands 19798140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Unsigned variants on "max(a,b)>=a -> true". 1980ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = CmpInst::BAD_ICMP_PREDICATE; 1981ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (match(LHS, m_UMax(m_Value(A), m_Value(B))) && (A == RHS || B == RHS)) { 1982ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != RHS) std::swap(A, B); // umax(A, B) pred A. 1983ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands EqP = CmpInst::ICMP_UGE; // "A == umax(A, B)" iff "A uge B". 1984ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as umax(A, B) pred A. 1985ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = Pred; 1986ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } else if (match(RHS, m_UMax(m_Value(A), m_Value(B))) && 1987ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands (A == LHS || B == LHS)) { 1988ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != LHS) std::swap(A, B); // A pred umax(A, B). 1989ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands EqP = CmpInst::ICMP_UGE; // "A == umax(A, B)" iff "A uge B". 1990ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as umax(A, B) swapped-pred A. 1991ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = CmpInst::getSwappedPredicate(Pred); 1992ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } else if (match(LHS, m_UMin(m_Value(A), m_Value(B))) && 1993ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands (A == RHS || B == RHS)) { 1994ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != RHS) std::swap(A, B); // umin(A, B) pred A. 1995ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands EqP = CmpInst::ICMP_ULE; // "A == umin(A, B)" iff "A ule B". 1996ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as umax(-A, -B) swapped-pred -A. 1997ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Note that we do not need to actually form -A or -B thanks to EqP. 1998ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = CmpInst::getSwappedPredicate(Pred); 1999ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } else if (match(RHS, m_UMin(m_Value(A), m_Value(B))) && 2000ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands (A == LHS || B == LHS)) { 2001ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (A != LHS) std::swap(A, B); // A pred umin(A, B). 2002ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands EqP = CmpInst::ICMP_ULE; // "A == umin(A, B)" iff "A ule B". 2003ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // We analyze this as umax(-A, -B) pred -A. 2004ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Note that we do not need to actually form -A or -B thanks to EqP. 2005ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands P = Pred; 2006ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } 2007ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (P != CmpInst::BAD_ICMP_PREDICATE) { 2008ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Cases correspond to "max(A, B) p A". 2009ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands switch (P) { 2010ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands default: 2011ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands break; 2012ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_EQ: 2013ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_ULE: 2014e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Equivalent to "A EqP B". This may be the same as the condition tested 2015e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // in the max/min; if so, we can just return that. 2016e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(LHS, EqP, A, B)) 2017e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2018e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(RHS, EqP, A, B)) 2019e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2020e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Otherwise, see if "A EqP B" simplifies. 2021ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (MaxRecurse) 2022ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (Value *V = SimplifyICmpInst(EqP, A, B, TD, DT, MaxRecurse-1)) 2023ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands return V; 2024ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands break; 2025ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_NE: 2026e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands case CmpInst::ICMP_UGT: { 2027e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands CmpInst::Predicate InvEqP = CmpInst::getInversePredicate(EqP); 2028e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Equivalent to "A InvEqP B". This may be the same as the condition 2029e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // tested in the max/min; if so, we can just return that. 2030e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(LHS, InvEqP, A, B)) 2031e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2032e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = ExtractEquivalentCondition(RHS, InvEqP, A, B)) 2033e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands return V; 2034e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands // Otherwise, see if "A InvEqP B" simplifies. 2035ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands if (MaxRecurse) 2036e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands if (Value *V = SimplifyICmpInst(InvEqP, A, B, TD, DT, MaxRecurse-1)) 2037ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands return V; 2038ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands break; 2039e864b5b840c58d0b04324082ec94a7156743ed60Duncan Sands } 2040ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_UGE: 2041ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Always true. 2042f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 2043ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands case CmpInst::ICMP_ULT: 2044ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands // Always false. 2045f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 2046ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } 2047ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands } 2048ad20681cdeaf72383891b153b925624aa585be4dDuncan Sands 20498140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Variants on "max(x,y) >= min(x,z)". 20508140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands Value *C, *D; 20518140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (match(LHS, m_SMax(m_Value(A), m_Value(B))) && 20528140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands match(RHS, m_SMin(m_Value(C), m_Value(D))) && 20538140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands (A == C || A == D || B == C || B == D)) { 20548140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // max(x, ?) pred min(x, ?). 20558140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_SGE) 20568140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always true. 2057f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 20588140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_SLT) 20598140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always false. 2060f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 20618140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands } else if (match(LHS, m_SMin(m_Value(A), m_Value(B))) && 20628140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands match(RHS, m_SMax(m_Value(C), m_Value(D))) && 20638140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands (A == C || A == D || B == C || B == D)) { 20648140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // min(x, ?) pred max(x, ?). 20658140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_SLE) 20668140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always true. 2067f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 20688140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_SGT) 20698140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always false. 2070f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 20718140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands } else if (match(LHS, m_UMax(m_Value(A), m_Value(B))) && 20728140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands match(RHS, m_UMin(m_Value(C), m_Value(D))) && 20738140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands (A == C || A == D || B == C || B == D)) { 20748140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // max(x, ?) pred min(x, ?). 20758140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_UGE) 20768140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always true. 2077f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 20788140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_ULT) 20798140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always false. 2080f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 20818140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands } else if (match(LHS, m_UMin(m_Value(A), m_Value(B))) && 20828140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands match(RHS, m_UMax(m_Value(C), m_Value(D))) && 20838140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands (A == C || A == D || B == C || B == D)) { 20848140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // min(x, ?) pred max(x, ?). 20858140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_ULE) 20868140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always true. 2087f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getTrue(ITy); 20888140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands if (Pred == CmpInst::ICMP_UGT) 20898140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands // Always false. 2090f56138d4aeb6d271cb353d70a794fa1525d892c3Duncan Sands return getFalse(ITy); 20918140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands } 20928140ad32ce45281ed2bc4f6ca388a6ed9f806550Duncan Sands 20931ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands // If the comparison is with the result of a select instruction, check whether 20941ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands // comparing with either branch of the select always yields the same value. 20950312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<SelectInst>(LHS) || isa<SelectInst>(RHS)) 20960312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (Value *V = ThreadCmpOverSelect(Pred, LHS, RHS, TD, DT, MaxRecurse)) 2097a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return V; 2098a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 2099a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the comparison is with the result of a phi instruction, check whether 2100a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // doing the compare with each incoming phi value yields a common result. 21010312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<PHINode>(LHS) || isa<PHINode>(RHS)) 21020312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (Value *V = ThreadCmpOverPHI(Pred, LHS, RHS, TD, DT, MaxRecurse)) 21033bbb0cc42b67b4bf2c488285666999963bab0f7eDuncan Sands return V; 21041ac7c9979a2d723ff4649ffad58df02732872a5fDuncan Sands 21059dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner return 0; 21069dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner} 21079dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 2108a74a58c83be492b7d5b7383656f049909394cff4Duncan SandsValue *llvm::SimplifyICmpInst(unsigned Predicate, Value *LHS, Value *RHS, 21091845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const TargetData *TD, const DominatorTree *DT) { 21101845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return ::SimplifyICmpInst(Predicate, LHS, RHS, TD, DT, RecursionLimit); 2111a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 2112a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 21139dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// SimplifyFCmpInst - Given operands for an FCmpInst, see if we can 21149dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// fold the result. If not, this returns null. 2115a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *SimplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS, 21161845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const TargetData *TD, const DominatorTree *DT, 21171845009290e4d804ad377927bd8a08cca3036adcDuncan Sands unsigned MaxRecurse) { 21189dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner CmpInst::Predicate Pred = (CmpInst::Predicate)Predicate; 21199dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner assert(CmpInst::isFPPredicate(Pred) && "Not an FP compare!"); 21209dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 2121d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(LHS)) { 21229dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner if (Constant *CRHS = dyn_cast<Constant>(RHS)) 21239dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner return ConstantFoldCompareInstOperands(Pred, CLHS, CRHS, TD); 212412a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2125d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner // If we have a constant, make sure it is on the RHS. 2126d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner std::swap(LHS, RHS); 2127d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Pred = CmpInst::getSwappedPredicate(Pred); 2128d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 212912a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2130210c5d4880b525e064088b6fec713260128c16ebChris Lattner // Fold trivial predicates. 2131210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (Pred == FCmpInst::FCMP_FALSE) 2132210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(GetCompareTy(LHS), 0); 2133210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (Pred == FCmpInst::FCMP_TRUE) 2134210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(GetCompareTy(LHS), 1); 2135210c5d4880b525e064088b6fec713260128c16ebChris Lattner 2136210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (isa<UndefValue>(RHS)) // fcmp pred X, undef -> undef 2137210c5d4880b525e064088b6fec713260128c16ebChris Lattner return UndefValue::get(GetCompareTy(LHS)); 2138210c5d4880b525e064088b6fec713260128c16ebChris Lattner 2139210c5d4880b525e064088b6fec713260128c16ebChris Lattner // fcmp x,x -> true/false. Not all compares are foldable. 2140124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (LHS == RHS) { 2141210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (CmpInst::isTrueWhenEqual(Pred)) 2142210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(GetCompareTy(LHS), 1); 2143210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (CmpInst::isFalseWhenEqual(Pred)) 2144210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::get(GetCompareTy(LHS), 0); 2145210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 214612a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2147210c5d4880b525e064088b6fec713260128c16ebChris Lattner // Handle fcmp with constant RHS 2148210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (Constant *RHSC = dyn_cast<Constant>(RHS)) { 2149210c5d4880b525e064088b6fec713260128c16ebChris Lattner // If the constant is a nan, see if we can fold the comparison based on it. 2150210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (ConstantFP *CFP = dyn_cast<ConstantFP>(RHSC)) { 2151210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (CFP->getValueAPF().isNaN()) { 2152210c5d4880b525e064088b6fec713260128c16ebChris Lattner if (FCmpInst::isOrdered(Pred)) // True "if ordered and foo" 2153210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::getFalse(CFP->getContext()); 2154210c5d4880b525e064088b6fec713260128c16ebChris Lattner assert(FCmpInst::isUnordered(Pred) && 2155210c5d4880b525e064088b6fec713260128c16ebChris Lattner "Comparison must be either ordered or unordered!"); 2156210c5d4880b525e064088b6fec713260128c16ebChris Lattner // True if unordered. 2157210c5d4880b525e064088b6fec713260128c16ebChris Lattner return ConstantInt::getTrue(CFP->getContext()); 2158210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 21596b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // Check whether the constant is an infinity. 21606b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman if (CFP->getValueAPF().isInfinity()) { 21616b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman if (CFP->getValueAPF().isNegative()) { 21626b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman switch (Pred) { 21636b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman case FCmpInst::FCMP_OLT: 21646b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // No value is ordered and less than negative infinity. 21656b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman return ConstantInt::getFalse(CFP->getContext()); 21666b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman case FCmpInst::FCMP_UGE: 21676b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // All values are unordered with or at least negative infinity. 21686b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman return ConstantInt::getTrue(CFP->getContext()); 21696b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman default: 21706b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman break; 21716b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } 21726b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } else { 21736b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman switch (Pred) { 21746b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman case FCmpInst::FCMP_OGT: 21756b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // No value is ordered and greater than infinity. 21766b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman return ConstantInt::getFalse(CFP->getContext()); 21776b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman case FCmpInst::FCMP_ULE: 21786b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman // All values are unordered with and at most infinity. 21796b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman return ConstantInt::getTrue(CFP->getContext()); 21806b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman default: 21816b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman break; 21826b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } 21836b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } 21846b617a7213e159097a7e5c7216ed9b04921de4e1Dan Gohman } 2185210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 2186210c5d4880b525e064088b6fec713260128c16ebChris Lattner } 218712a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 218892826def593df7a422c7b07f09342febce81ddd3Duncan Sands // If the comparison is with the result of a select instruction, check whether 218992826def593df7a422c7b07f09342febce81ddd3Duncan Sands // comparing with either branch of the select always yields the same value. 21900312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<SelectInst>(LHS) || isa<SelectInst>(RHS)) 21910312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (Value *V = ThreadCmpOverSelect(Pred, LHS, RHS, TD, DT, MaxRecurse)) 2192a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return V; 2193a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 2194a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the comparison is with the result of a phi instruction, check whether 2195a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // doing the compare with each incoming phi value yields a common result. 21960312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<PHINode>(LHS) || isa<PHINode>(RHS)) 21970312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (Value *V = ThreadCmpOverPHI(Pred, LHS, RHS, TD, DT, MaxRecurse)) 21983bbb0cc42b67b4bf2c488285666999963bab0f7eDuncan Sands return V; 219992826def593df7a422c7b07f09342febce81ddd3Duncan Sands 22009f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner return 0; 22019f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner} 22029f3c25aeb3df77a336693308dc0f19a4983c99afChris Lattner 2203a74a58c83be492b7d5b7383656f049909394cff4Duncan SandsValue *llvm::SimplifyFCmpInst(unsigned Predicate, Value *LHS, Value *RHS, 22041845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const TargetData *TD, const DominatorTree *DT) { 22051845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return ::SimplifyFCmpInst(Predicate, LHS, RHS, TD, DT, RecursionLimit); 2206a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 2207a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 2208047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner/// SimplifySelectInst - Given operands for a SelectInst, see if we can fold 2209047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner/// the result. If not, this returns null. 2210124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan SandsValue *llvm::SimplifySelectInst(Value *CondVal, Value *TrueVal, Value *FalseVal, 2211124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands const TargetData *TD, const DominatorTree *) { 2212047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner // select true, X, Y -> X 2213047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner // select false, X, Y -> Y 2214047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner if (ConstantInt *CB = dyn_cast<ConstantInt>(CondVal)) 2215047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return CB->getZExtValue() ? TrueVal : FalseVal; 221612a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2217047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner // select C, X, X -> X 2218124708d9b47cc53cb11d8bfed75b241b6eec86d4Duncan Sands if (TrueVal == FalseVal) 2219047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return TrueVal; 222012a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2221047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner if (isa<UndefValue>(CondVal)) { // select undef, X, Y -> X or Y 2222047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner if (isa<Constant>(TrueVal)) 2223047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return TrueVal; 2224047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return FalseVal; 2225047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner } 222668c0dbc14fb7599987fb3e27be4e12c1ac36535eDan Gohman if (isa<UndefValue>(TrueVal)) // select C, undef, X -> X 222768c0dbc14fb7599987fb3e27be4e12c1ac36535eDan Gohman return FalseVal; 222868c0dbc14fb7599987fb3e27be4e12c1ac36535eDan Gohman if (isa<UndefValue>(FalseVal)) // select C, X, undef -> X 222968c0dbc14fb7599987fb3e27be4e12c1ac36535eDan Gohman return TrueVal; 223012a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2231047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner return 0; 2232047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner} 2233047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner 2234c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner/// SimplifyGEPInst - Given operands for an GetElementPtrInst, see if we can 2235c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner/// fold the result. If not, this returns null. 2236b9b54ebfed02f0654897d37e8a4448d3f8087558Jay FoadValue *llvm::SimplifyGEPInst(ArrayRef<Value *> Ops, 22371845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const TargetData *TD, const DominatorTree *) { 223885bbff6c94695f07cc1a9765b4d384ed18d2fd7cDuncan Sands // The type of the GEP pointer operand. 2239db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner PointerType *PtrTy = cast<PointerType>(Ops[0]->getType()); 224085bbff6c94695f07cc1a9765b4d384ed18d2fd7cDuncan Sands 2241c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner // getelementptr P -> P. 2242b9b54ebfed02f0654897d37e8a4448d3f8087558Jay Foad if (Ops.size() == 1) 2243c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner return Ops[0]; 2244c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner 224585bbff6c94695f07cc1a9765b4d384ed18d2fd7cDuncan Sands if (isa<UndefValue>(Ops[0])) { 224685bbff6c94695f07cc1a9765b4d384ed18d2fd7cDuncan Sands // Compute the (pointer) type returned by the GEP instruction. 2247a9203109f4ac95aa7e9624f2838e3d89623ec902Jay Foad Type *LastType = GetElementPtrInst::getIndexedType(PtrTy, Ops.slice(1)); 2248db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *GEPTy = PointerType::get(LastType, PtrTy->getAddressSpace()); 224985bbff6c94695f07cc1a9765b4d384ed18d2fd7cDuncan Sands return UndefValue::get(GEPTy); 225085bbff6c94695f07cc1a9765b4d384ed18d2fd7cDuncan Sands } 2251c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner 2252b9b54ebfed02f0654897d37e8a4448d3f8087558Jay Foad if (Ops.size() == 2) { 2253e60d79faf7ef7bc4847f9e5d067af00b98dced7bDuncan Sands // getelementptr P, 0 -> P. 2254c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner if (ConstantInt *C = dyn_cast<ConstantInt>(Ops[1])) 2255c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner if (C->isZero()) 2256c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner return Ops[0]; 2257e60d79faf7ef7bc4847f9e5d067af00b98dced7bDuncan Sands // getelementptr P, N -> P if P points to a type of zero size. 2258e60d79faf7ef7bc4847f9e5d067af00b98dced7bDuncan Sands if (TD) { 2259db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty = PtrTy->getElementType(); 2260a63395a30f9227bde826749d3480046301b47332Duncan Sands if (Ty->isSized() && TD->getTypeAllocSize(Ty) == 0) 2261e60d79faf7ef7bc4847f9e5d067af00b98dced7bDuncan Sands return Ops[0]; 2262e60d79faf7ef7bc4847f9e5d067af00b98dced7bDuncan Sands } 2263e60d79faf7ef7bc4847f9e5d067af00b98dced7bDuncan Sands } 226412a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2265c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner // Check to see if this is constant foldable. 2266b9b54ebfed02f0654897d37e8a4448d3f8087558Jay Foad for (unsigned i = 0, e = Ops.size(); i != e; ++i) 2267c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner if (!isa<Constant>(Ops[i])) 2268c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner return 0; 226912a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2270dab3d29605a5c83db41b28176273ef55961120c1Jay Foad return ConstantExpr::getGetElementPtr(cast<Constant>(Ops[0]), Ops.slice(1)); 2271c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner} 2272c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner 2273ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands/// SimplifyPHINode - See if we can fold the given phi. If not, returns null. 2274ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sandsstatic Value *SimplifyPHINode(PHINode *PN, const DominatorTree *DT) { 2275ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // If all of the PHI's incoming values are the same then replace the PHI node 2276ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // with the common value. 2277ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands Value *CommonValue = 0; 2278ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands bool HasUndefInput = false; 2279ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands for (unsigned i = 0, e = PN->getNumIncomingValues(); i != e; ++i) { 2280ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands Value *Incoming = PN->getIncomingValue(i); 2281ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // If the incoming value is the phi node itself, it can safely be skipped. 2282ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands if (Incoming == PN) continue; 2283ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands if (isa<UndefValue>(Incoming)) { 2284ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // Remember that we saw an undef value, but otherwise ignore them. 2285ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands HasUndefInput = true; 2286ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands continue; 2287ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands } 2288ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands if (CommonValue && Incoming != CommonValue) 2289ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands return 0; // Not the same, bail out. 2290ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands CommonValue = Incoming; 2291ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands } 2292ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands 2293ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // If CommonValue is null then all of the incoming values were either undef or 2294ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // equal to the phi node itself. 2295ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands if (!CommonValue) 2296ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands return UndefValue::get(PN->getType()); 2297ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands 2298ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // If we have a PHI node like phi(X, undef, X), where X is defined by some 2299ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // instruction, we cannot return X as the result of the PHI node unless it 2300ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands // dominates the PHI block. 2301ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands if (HasUndefInput) 2302ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands return ValueDominatesPHI(CommonValue, PN, DT) ? CommonValue : 0; 2303ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands 2304ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands return CommonValue; 2305ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands} 2306ff10341183adf74760e6118a55cbd1debf50f90fDuncan Sands 2307c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner 2308d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner//=== Helper functions for higher up the class hierarchy. 23099dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 2310d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner/// SimplifyBinOp - Given operands for a BinaryOperator, see if we can 2311d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner/// fold the result. If not, this returns null. 2312a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *SimplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS, 23131845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const TargetData *TD, const DominatorTree *DT, 23141845009290e4d804ad377927bd8a08cca3036adcDuncan Sands unsigned MaxRecurse) { 2315d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner switch (Opcode) { 231681a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner case Instruction::Add: 2317ffeb98ad3becfbb8e26270ef8751e37e4b6b0cd1Duncan Sands return SimplifyAddInst(LHS, RHS, /*isNSW*/false, /*isNUW*/false, 231881a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner TD, DT, MaxRecurse); 231981a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner case Instruction::Sub: 2320ffeb98ad3becfbb8e26270ef8751e37e4b6b0cd1Duncan Sands return SimplifySubInst(LHS, RHS, /*isNSW*/false, /*isNUW*/false, 232181a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner TD, DT, MaxRecurse); 232281a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner case Instruction::Mul: return SimplifyMulInst (LHS, RHS, TD, DT, MaxRecurse); 2323593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands case Instruction::SDiv: return SimplifySDivInst(LHS, RHS, TD, DT, MaxRecurse); 2324593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands case Instruction::UDiv: return SimplifyUDivInst(LHS, RHS, TD, DT, MaxRecurse); 23251fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel case Instruction::FDiv: return SimplifyFDivInst(LHS, RHS, TD, DT, MaxRecurse); 2326f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands case Instruction::SRem: return SimplifySRemInst(LHS, RHS, TD, DT, MaxRecurse); 2327f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands case Instruction::URem: return SimplifyURemInst(LHS, RHS, TD, DT, MaxRecurse); 2328f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands case Instruction::FRem: return SimplifyFRemInst(LHS, RHS, TD, DT, MaxRecurse); 232981a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner case Instruction::Shl: 2330ffeb98ad3becfbb8e26270ef8751e37e4b6b0cd1Duncan Sands return SimplifyShlInst(LHS, RHS, /*isNSW*/false, /*isNUW*/false, 233181a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner TD, DT, MaxRecurse); 233281a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner case Instruction::LShr: 2333ffeb98ad3becfbb8e26270ef8751e37e4b6b0cd1Duncan Sands return SimplifyLShrInst(LHS, RHS, /*isExact*/false, TD, DT, MaxRecurse); 233481a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner case Instruction::AShr: 2335ffeb98ad3becfbb8e26270ef8751e37e4b6b0cd1Duncan Sands return SimplifyAShrInst(LHS, RHS, /*isExact*/false, TD, DT, MaxRecurse); 233682fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands case Instruction::And: return SimplifyAndInst(LHS, RHS, TD, DT, MaxRecurse); 233781a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner case Instruction::Or: return SimplifyOrInst (LHS, RHS, TD, DT, MaxRecurse); 233882fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands case Instruction::Xor: return SimplifyXorInst(LHS, RHS, TD, DT, MaxRecurse); 2339d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner default: 2340d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CLHS = dyn_cast<Constant>(LHS)) 2341d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner if (Constant *CRHS = dyn_cast<Constant>(RHS)) { 2342d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner Constant *COps[] = {CLHS, CRHS}; 23431d2f569c3428d70d0cf690c9adb459ad4a3ecff2Jay Foad return ConstantFoldInstOperands(Opcode, LHS->getType(), COps, TD); 2344d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 2345b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 2346566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands // If the operation is associative, try some generic simplifications. 2347566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Instruction::isAssociative(Opcode)) 2348566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands if (Value *V = SimplifyAssociativeBinOp(Opcode, LHS, RHS, TD, DT, 2349566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands MaxRecurse)) 2350566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands return V; 2351566edb04b890cebca8f2eefa37af7371a1e756c9Duncan Sands 2352b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // If the operation is with the result of a select instruction, check whether 2353b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands // operating on either branch of the select always yields the same value. 23540312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<SelectInst>(LHS) || isa<SelectInst>(RHS)) 23551845009290e4d804ad377927bd8a08cca3036adcDuncan Sands if (Value *V = ThreadBinOpOverSelect(Opcode, LHS, RHS, TD, DT, 23560312a93693abc2eb682b2b101c889959888fd883Duncan Sands MaxRecurse)) 2357a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands return V; 2358a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 2359a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // If the operation is with the result of a phi instruction, check whether 2360a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands // operating on all incoming values of the phi always yields the same value. 23610312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (isa<PHINode>(LHS) || isa<PHINode>(RHS)) 23620312a93693abc2eb682b2b101c889959888fd883Duncan Sands if (Value *V = ThreadBinOpOverPHI(Opcode, LHS, RHS, TD, DT, MaxRecurse)) 2363b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands return V; 2364b2cbdc35ba85c04df15b0e991d9be371691ab08cDuncan Sands 2365d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner return 0; 2366d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner } 2367d06094f0682f2ede03caff4892b1a57469896d48Chris Lattner} 23689dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 236912a86f5b3199e72e6d967781acc76340f5920e46Duncan SandsValue *llvm::SimplifyBinOp(unsigned Opcode, Value *LHS, Value *RHS, 23701845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const TargetData *TD, const DominatorTree *DT) { 23711845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return ::SimplifyBinOp(Opcode, LHS, RHS, TD, DT, RecursionLimit); 2372a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 2373a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands 23749dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// SimplifyCmpInst - Given operands for a CmpInst, see if we can 23759dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner/// fold the result. 2376a74a58c83be492b7d5b7383656f049909394cff4Duncan Sandsstatic Value *SimplifyCmpInst(unsigned Predicate, Value *LHS, Value *RHS, 23771845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const TargetData *TD, const DominatorTree *DT, 23781845009290e4d804ad377927bd8a08cca3036adcDuncan Sands unsigned MaxRecurse) { 23799dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner if (CmpInst::isIntPredicate((CmpInst::Predicate)Predicate)) 23801845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return SimplifyICmpInst(Predicate, LHS, RHS, TD, DT, MaxRecurse); 23811845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return SimplifyFCmpInst(Predicate, LHS, RHS, TD, DT, MaxRecurse); 23829dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner} 23839dbb42944c4d7caddab21016b24cca31019a3fafChris Lattner 2384a74a58c83be492b7d5b7383656f049909394cff4Duncan SandsValue *llvm::SimplifyCmpInst(unsigned Predicate, Value *LHS, Value *RHS, 23851845009290e4d804ad377927bd8a08cca3036adcDuncan Sands const TargetData *TD, const DominatorTree *DT) { 23861845009290e4d804ad377927bd8a08cca3036adcDuncan Sands return ::SimplifyCmpInst(Predicate, LHS, RHS, TD, DT, RecursionLimit); 2387a74a58c83be492b7d5b7383656f049909394cff4Duncan Sands} 2388e34537856a544c83513e390ac9552a8bc3823346Chris Lattner 2389e34537856a544c83513e390ac9552a8bc3823346Chris Lattner/// SimplifyInstruction - See if we can compute a simplified version of this 2390e34537856a544c83513e390ac9552a8bc3823346Chris Lattner/// instruction. If not, this returns null. 2391eff0581583ef10e2872e9baf537a04b67d992101Duncan SandsValue *llvm::SimplifyInstruction(Instruction *I, const TargetData *TD, 2392eff0581583ef10e2872e9baf537a04b67d992101Duncan Sands const DominatorTree *DT) { 2393d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands Value *Result; 2394d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands 2395e34537856a544c83513e390ac9552a8bc3823346Chris Lattner switch (I->getOpcode()) { 2396e34537856a544c83513e390ac9552a8bc3823346Chris Lattner default: 2397d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands Result = ConstantFoldInstruction(I, TD); 2398d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 23998aee8efc0c2e387faa7dae39fdf613a22889b566Chris Lattner case Instruction::Add: 2400d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands Result = SimplifyAddInst(I->getOperand(0), I->getOperand(1), 2401d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands cast<BinaryOperator>(I)->hasNoSignedWrap(), 2402d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands cast<BinaryOperator>(I)->hasNoUnsignedWrap(), 2403d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands TD, DT); 2404d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 2405fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands case Instruction::Sub: 2406fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands Result = SimplifySubInst(I->getOperand(0), I->getOperand(1), 2407fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands cast<BinaryOperator>(I)->hasNoSignedWrap(), 2408fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands cast<BinaryOperator>(I)->hasNoUnsignedWrap(), 2409fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands TD, DT); 2410fea3b218d61708ea3577f4ef14c8f7677a94db95Duncan Sands break; 241182fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands case Instruction::Mul: 241282fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands Result = SimplifyMulInst(I->getOperand(0), I->getOperand(1), TD, DT); 241382fdab335881cd90f8f7ab3ad1f1ca0bb3ee886aDuncan Sands break; 2414593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands case Instruction::SDiv: 2415593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands Result = SimplifySDivInst(I->getOperand(0), I->getOperand(1), TD, DT); 2416593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands break; 2417593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands case Instruction::UDiv: 2418593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands Result = SimplifyUDivInst(I->getOperand(0), I->getOperand(1), TD, DT); 2419593faa53fa6d89841e601cc4571d143a6a05f0b4Duncan Sands break; 24201fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel case Instruction::FDiv: 24211fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel Result = SimplifyFDivInst(I->getOperand(0), I->getOperand(1), TD, DT); 24221fca2c32cc99197215d3fd32a4ad05214c74edd1Frits van Bommel break; 2423f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands case Instruction::SRem: 2424f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands Result = SimplifySRemInst(I->getOperand(0), I->getOperand(1), TD, DT); 2425f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands break; 2426f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands case Instruction::URem: 2427f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands Result = SimplifyURemInst(I->getOperand(0), I->getOperand(1), TD, DT); 2428f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands break; 2429f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands case Instruction::FRem: 2430f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands Result = SimplifyFRemInst(I->getOperand(0), I->getOperand(1), TD, DT); 2431f24ed77d2416b66178d8ff1d807858dfab37ca18Duncan Sands break; 2432c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands case Instruction::Shl: 243381a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Result = SimplifyShlInst(I->getOperand(0), I->getOperand(1), 243481a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner cast<BinaryOperator>(I)->hasNoSignedWrap(), 243581a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner cast<BinaryOperator>(I)->hasNoUnsignedWrap(), 243681a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner TD, DT); 2437c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands break; 2438c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands case Instruction::LShr: 243981a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Result = SimplifyLShrInst(I->getOperand(0), I->getOperand(1), 244081a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner cast<BinaryOperator>(I)->isExact(), 244181a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner TD, DT); 2442c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands break; 2443c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands case Instruction::AShr: 244481a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner Result = SimplifyAShrInst(I->getOperand(0), I->getOperand(1), 244581a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner cast<BinaryOperator>(I)->isExact(), 244681a0dc911586c77421c2255aa417dc9b350b9e20Chris Lattner TD, DT); 2447c43cee3fbb3098f0647e50dd2c13bc55b027a228Duncan Sands break; 2448e34537856a544c83513e390ac9552a8bc3823346Chris Lattner case Instruction::And: 2449d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands Result = SimplifyAndInst(I->getOperand(0), I->getOperand(1), TD, DT); 2450d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 2451e34537856a544c83513e390ac9552a8bc3823346Chris Lattner case Instruction::Or: 2452d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands Result = SimplifyOrInst(I->getOperand(0), I->getOperand(1), TD, DT); 2453d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 24542b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands case Instruction::Xor: 24552b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands Result = SimplifyXorInst(I->getOperand(0), I->getOperand(1), TD, DT); 24562b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands break; 2457e34537856a544c83513e390ac9552a8bc3823346Chris Lattner case Instruction::ICmp: 2458d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands Result = SimplifyICmpInst(cast<ICmpInst>(I)->getPredicate(), 2459d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands I->getOperand(0), I->getOperand(1), TD, DT); 2460d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 2461e34537856a544c83513e390ac9552a8bc3823346Chris Lattner case Instruction::FCmp: 2462d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands Result = SimplifyFCmpInst(cast<FCmpInst>(I)->getPredicate(), 2463d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands I->getOperand(0), I->getOperand(1), TD, DT); 2464d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 2465047542669a20505fc7c5f2d93caa5610aa3db2c5Chris Lattner case Instruction::Select: 2466d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands Result = SimplifySelectInst(I->getOperand(0), I->getOperand(1), 2467d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands I->getOperand(2), TD, DT); 2468d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 2469c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner case Instruction::GetElementPtr: { 2470c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner SmallVector<Value*, 8> Ops(I->op_begin(), I->op_end()); 2471b9b54ebfed02f0654897d37e8a4448d3f8087558Jay Foad Result = SimplifyGEPInst(Ops, TD, DT); 2472d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 2473c514c1f5218b8fe7499a0b9a4737860344cf4c43Chris Lattner } 2474cd6636c737a82949ad13db2d0d918af6424fb78bDuncan Sands case Instruction::PHI: 2475d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands Result = SimplifyPHINode(cast<PHINode>(I), DT); 2476d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands break; 2477e34537856a544c83513e390ac9552a8bc3823346Chris Lattner } 2478d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands 2479d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands /// If called on unreachable code, the above logic may report that the 2480d261dc650a01ac5c51ab10f97f1e35aa6a770721Duncan Sands /// instruction simplified to itself. Make life easier for users by 2481f8b1a5ea9602bb65a5cf59d3d34f2851a08cdc3eDuncan Sands /// detecting that case here, returning a safe value instead. 2482f8b1a5ea9602bb65a5cf59d3d34f2851a08cdc3eDuncan Sands return Result == I ? UndefValue::get(I->getType()) : Result; 2483e34537856a544c83513e390ac9552a8bc3823346Chris Lattner} 2484e34537856a544c83513e390ac9552a8bc3823346Chris Lattner 248540d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// ReplaceAndSimplifyAllUses - Perform From->replaceAllUsesWith(To) and then 248640d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// delete the From instruction. In addition to a basic RAUW, this does a 248740d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// recursive simplification of the newly formed instructions. This catches 248840d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// things where one simplification exposes other opportunities. This only 248940d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// simplifies and deletes scalar operations, it does not change the CFG. 249040d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner/// 249140d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattnervoid llvm::ReplaceAndSimplifyAllUses(Instruction *From, Value *To, 2492eff0581583ef10e2872e9baf537a04b67d992101Duncan Sands const TargetData *TD, 2493eff0581583ef10e2872e9baf537a04b67d992101Duncan Sands const DominatorTree *DT) { 249440d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner assert(From != To && "ReplaceAndSimplifyAllUses(X,X) is not valid!"); 249512a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2496d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // FromHandle/ToHandle - This keeps a WeakVH on the from/to values so that 2497d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // we can know if it gets deleted out from under us or replaced in a 2498d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // recursive simplification. 249940d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner WeakVH FromHandle(From); 2500d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner WeakVH ToHandle(To); 250112a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 250240d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner while (!From->use_empty()) { 250340d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner // Update the instruction to use the new value. 2504d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner Use &TheUse = From->use_begin().getUse(); 2505d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner Instruction *User = cast<Instruction>(TheUse.getUser()); 2506d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner TheUse = To; 2507d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner 2508d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // Check to see if the instruction can be folded due to the operand 2509d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // replacement. For example changing (or X, Y) into (or X, -1) can replace 2510d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // the 'or' with -1. 2511d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner Value *SimplifiedVal; 2512d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner { 2513d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // Sanity check to make sure 'User' doesn't dangle across 2514d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // SimplifyInstruction. 2515d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner AssertingVH<> UserHandle(User); 251612a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2517eff0581583ef10e2872e9baf537a04b67d992101Duncan Sands SimplifiedVal = SimplifyInstruction(User, TD, DT); 2518d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner if (SimplifiedVal == 0) continue; 251940d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner } 252012a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2521d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // Recursively simplify this user to the new value. 2522eff0581583ef10e2872e9baf537a04b67d992101Duncan Sands ReplaceAndSimplifyAllUses(User, SimplifiedVal, TD, DT); 2523d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner From = dyn_cast_or_null<Instruction>((Value*)FromHandle); 2524d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner To = ToHandle; 252512a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2526d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner assert(ToHandle && "To value deleted by recursive simplification?"); 252712a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2528d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // If the recursive simplification ended up revisiting and deleting 2529d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // 'From' then we're done. 2530d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner if (From == 0) 2531d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner return; 253240d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner } 253312a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 2534d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner // If 'From' has value handles referring to it, do a real RAUW to update them. 2535d2bfe54b0a9f28c021d4f0790bdb5224d5579447Chris Lattner From->replaceAllUsesWith(To); 253612a86f5b3199e72e6d967781acc76340f5920e46Duncan Sands 253740d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner From->eraseFromParent(); 253840d8c28b27377199b7465ba2c5a2c59c6fd12fa9Chris Lattner} 2539