InstCombineAndOrXor.cpp revision cc687faba373e6aa3cefe594bd9f3212e18617eb
125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner//===- InstCombineAndOrXor.cpp --------------------------------------------===// 225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner// 325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner// The LLVM Compiler Infrastructure 425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner// 525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner// This file is distributed under the University of Illinois Open Source 625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner// License. See LICENSE.TXT for details. 725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner// 825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner//===----------------------------------------------------------------------===// 925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner// 1025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner// This file implements the visitAnd, visitOr, and visitXor functions. 1125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner// 1225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner//===----------------------------------------------------------------------===// 1325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 1425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner#include "InstCombine.h" 1525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner#include "llvm/Analysis/InstructionSimplify.h" 160b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Intrinsics.h" 17d70be0b2c199183077626a9e756ecd14b807dd56Anders Carlsson#include "llvm/Support/ConstantRange.h" 1825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner#include "llvm/Support/PatternMatch.h" 19d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Transforms/Utils/CmpInstAnalysis.h" 2025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattnerusing namespace llvm; 2125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattnerusing namespace PatternMatch; 2225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 2325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 2425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// AddOne - Add one to a ConstantInt. 2525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattnerstatic Constant *AddOne(Constant *C) { 2625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return ConstantExpr::getAdd(C, ConstantInt::get(C->getType(), 1)); 2725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 2825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// SubOne - Subtract one from a ConstantInt. 2925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattnerstatic Constant *SubOne(ConstantInt *C) { 3025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return ConstantInt::get(C->getContext(), C->getValue()-1); 3125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 3225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 3325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// isFreeToInvert - Return true if the specified value is free to invert (apply 3425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// ~ to). This happens in cases where the ~ can be eliminated. 3525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattnerstatic inline bool isFreeToInvert(Value *V) { 3625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ~(~(X)) -> X. 3725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (BinaryOperator::isNot(V)) 3825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return true; 3941a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 4025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Constants can be considered to be not'ed values. 4125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (isa<ConstantInt>(V)) 4225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return true; 4341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 4425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Compares can be inverted if they have a single use. 4525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (CmpInst *CI = dyn_cast<CmpInst>(V)) 4625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return CI->hasOneUse(); 4741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 4825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return false; 4925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 5025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 5125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattnerstatic inline Value *dyn_castNotVal(Value *V) { 5225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If this is not(not(x)) don't return that this is a not: we want the two 5325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // not's to be folded first. 5425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (BinaryOperator::isNot(V)) { 5525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Operand = BinaryOperator::getNotArgument(V); 5625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (!isFreeToInvert(Operand)) 5725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return Operand; 5825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 5941a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 6025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Constants can be considered to be not'ed values... 6125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ConstantInt *C = dyn_cast<ConstantInt>(V)) 6225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return ConstantInt::get(C->getType(), ~C->getValue()); 6325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return 0; 6425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 6525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 6625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// getFCmpCode - Similar to getICmpCode but for FCmpInst. This encodes a fcmp 6725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// predicate into a three bit mask. It also returns whether it is an ordered 6825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// predicate by reference. 6925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattnerstatic unsigned getFCmpCode(FCmpInst::Predicate CC, bool &isOrdered) { 7025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner isOrdered = false; 7125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (CC) { 7225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case FCmpInst::FCMP_ORD: isOrdered = true; return 0; // 000 7325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case FCmpInst::FCMP_UNO: return 0; // 000 7425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case FCmpInst::FCMP_OGT: isOrdered = true; return 1; // 001 7525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case FCmpInst::FCMP_UGT: return 1; // 001 7625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case FCmpInst::FCMP_OEQ: isOrdered = true; return 2; // 010 7725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case FCmpInst::FCMP_UEQ: return 2; // 010 7825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case FCmpInst::FCMP_OGE: isOrdered = true; return 3; // 011 7925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case FCmpInst::FCMP_UGE: return 3; // 011 8025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case FCmpInst::FCMP_OLT: isOrdered = true; return 4; // 100 8125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case FCmpInst::FCMP_ULT: return 4; // 100 8225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case FCmpInst::FCMP_ONE: isOrdered = true; return 5; // 101 8325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case FCmpInst::FCMP_UNE: return 5; // 101 8425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case FCmpInst::FCMP_OLE: isOrdered = true; return 6; // 110 8525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case FCmpInst::FCMP_ULE: return 6; // 110 8625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // True -> 7 8725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: 8825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Not expecting FCMP_FALSE and FCMP_TRUE; 8925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner llvm_unreachable("Unexpected FCmp predicate!"); 9025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 9125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 9225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 937ba962fe4ac04acd12db803cbc255b0c00a6e4eaBenjamin Kramer/// getNewICmpValue - This is the complement of getICmpCode, which turns an 9441a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper/// opcode and two operands into either a constant true or false, or a brand 9525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// new ICmp instruction. The sign is passed in to determine which kind 9625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// of predicate to use in the new icmp instruction. 977ba962fe4ac04acd12db803cbc255b0c00a6e4eaBenjamin Kramerstatic Value *getNewICmpValue(bool Sign, unsigned Code, Value *LHS, Value *RHS, 987ba962fe4ac04acd12db803cbc255b0c00a6e4eaBenjamin Kramer InstCombiner::BuilderTy *Builder) { 992e33944c101f2a08ed1d85e807830f2fc089dd06Pete Cooper ICmpInst::Predicate NewPred; 1002e33944c101f2a08ed1d85e807830f2fc089dd06Pete Cooper if (Value *NewConstant = getICmpValue(Sign, Code, LHS, RHS, NewPred)) 1012e33944c101f2a08ed1d85e807830f2fc089dd06Pete Cooper return NewConstant; 1022e33944c101f2a08ed1d85e807830f2fc089dd06Pete Cooper return Builder->CreateICmp(NewPred, LHS, RHS); 10325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 10425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 10525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// getFCmpValue - This is the complement of getFCmpCode, which turns an 10625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// opcode and two operands into either a FCmp instruction. isordered is passed 10725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// in to determine which kind of predicate to use in the new fcmp instruction. 10825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattnerstatic Value *getFCmpValue(bool isordered, unsigned code, 109f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner Value *LHS, Value *RHS, 110f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner InstCombiner::BuilderTy *Builder) { 111d6f645ac09a28b5b45f390b2597444514be8a70eChris Lattner CmpInst::Predicate Pred; 11225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (code) { 113858143816d43e58b17bfd11cb1b57afbd7f0f893Craig Topper default: llvm_unreachable("Illegal FCmp code!"); 114d6f645ac09a28b5b45f390b2597444514be8a70eChris Lattner case 0: Pred = isordered ? FCmpInst::FCMP_ORD : FCmpInst::FCMP_UNO; break; 115d6f645ac09a28b5b45f390b2597444514be8a70eChris Lattner case 1: Pred = isordered ? FCmpInst::FCMP_OGT : FCmpInst::FCMP_UGT; break; 116d6f645ac09a28b5b45f390b2597444514be8a70eChris Lattner case 2: Pred = isordered ? FCmpInst::FCMP_OEQ : FCmpInst::FCMP_UEQ; break; 117d6f645ac09a28b5b45f390b2597444514be8a70eChris Lattner case 3: Pred = isordered ? FCmpInst::FCMP_OGE : FCmpInst::FCMP_UGE; break; 118d6f645ac09a28b5b45f390b2597444514be8a70eChris Lattner case 4: Pred = isordered ? FCmpInst::FCMP_OLT : FCmpInst::FCMP_ULT; break; 119d6f645ac09a28b5b45f390b2597444514be8a70eChris Lattner case 5: Pred = isordered ? FCmpInst::FCMP_ONE : FCmpInst::FCMP_UNE; break; 120d6f645ac09a28b5b45f390b2597444514be8a70eChris Lattner case 6: Pred = isordered ? FCmpInst::FCMP_OLE : FCmpInst::FCMP_ULE; break; 12141a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper case 7: 1225d2e1889622cc20ada6146041e6d862a6588194fOwen Anderson if (!isordered) return ConstantInt::getTrue(LHS->getContext()); 1235d2e1889622cc20ada6146041e6d862a6588194fOwen Anderson Pred = FCmpInst::FCMP_ORD; break; 12425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 125f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateFCmp(Pred, LHS, RHS); 12625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 12725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 12825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner// OptAndOp - This handles expressions of the form ((val OP C1) & C2). Where 12925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner// the Op parameter is 'OP', OpRHS is 'C1', and AndRHS is 'C2'. Op is 13025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner// guaranteed to be a binary operator. 13125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris LattnerInstruction *InstCombiner::OptAndOp(Instruction *Op, 13225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt *OpRHS, 13325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt *AndRHS, 13425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner BinaryOperator &TheAnd) { 13525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *X = Op->getOperand(0); 13625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Constant *Together = 0; 13725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (!Op->isShift()) 13825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Together = ConstantExpr::getAnd(AndRHS, OpRHS); 13925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 14025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (Op->getOpcode()) { 14125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case Instruction::Xor: 14225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op->hasOneUse()) { 14325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (X ^ C1) & C2 --> (X & C2) ^ (C1&C2) 14425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *And = Builder->CreateAnd(X, AndRHS); 14525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner And->takeName(Op); 14625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateXor(And, Together); 14725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 14825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 14925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case Instruction::Or: 1502c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson if (Op->hasOneUse()){ 1512c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson if (Together != OpRHS) { 1522c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson // (X | C1) & C2 --> (X | (C1&C2)) & C2 1532c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson Value *Or = Builder->CreateOr(X, Together); 1542c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson Or->takeName(Op); 1552c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson return BinaryOperator::CreateAnd(Or, AndRHS); 1562c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson } 15741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 1582c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson ConstantInt *TogetherCI = dyn_cast<ConstantInt>(Together); 1592c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson if (TogetherCI && !TogetherCI->isZero()){ 1602c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson // (X | C1) & C2 --> (X & (C2^(C1&C2))) | C1 1612c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson // NOTE: This reduces the number of bits set in the & mask, which 1622c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson // can expose opportunities for store narrowing. 1632c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson Together = ConstantExpr::getXor(AndRHS, Together); 1642c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson Value *And = Builder->CreateAnd(X, Together); 1652c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson And->takeName(Op); 1662c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson return BinaryOperator::CreateOr(And, OpRHS); 1672c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson } 16825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 16941a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 17025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 17125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case Instruction::Add: 17225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op->hasOneUse()) { 17325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Adding a one to a single bit bit-field should be turned into an XOR 17425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // of the bit. First thing to check is to see if this AND is with a 17525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // single bit constant. 17625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner const APInt &AndRHSV = cast<ConstantInt>(AndRHS)->getValue(); 17725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 17825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If there is only one bit set. 17925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (AndRHSV.isPowerOf2()) { 18025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Ok, at this point, we know that we are masking the result of the 18125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ADD down to exactly one bit. If the constant we are adding has 18225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // no bits set below this bit, then we can eliminate the ADD. 18325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner const APInt& AddRHS = cast<ConstantInt>(OpRHS)->getValue(); 18425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 18525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Check to see if any bits below the one bit set in AndRHSV are set. 18625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if ((AddRHS & (AndRHSV-1)) == 0) { 18725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If not, the only thing that can effect the output of the AND is 18825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // the bit specified by AndRHSV. If that bit is set, the effect of 18925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // the XOR is to toggle the bit. If it is clear, then the ADD has 19025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // no effect. 19125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if ((AddRHS & AndRHSV) == 0) { // Bit is not set, noop 19225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner TheAnd.setOperand(0, X); 19325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return &TheAnd; 19425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } else { 19525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Pull the XOR out of the AND. 19625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NewAnd = Builder->CreateAnd(X, AndRHS); 19725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner NewAnd->takeName(Op); 19825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateXor(NewAnd, AndRHS); 19925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 20025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 20125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 20225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 20325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 20425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 20525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case Instruction::Shl: { 20625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // We know that the AND will not produce any of the bits shifted in, so if 20725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // the anded constant includes them, clear them now! 20825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // 20925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner uint32_t BitWidth = AndRHS->getType()->getBitWidth(); 21025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner uint32_t OpRHSVal = OpRHS->getLimitedValue(BitWidth); 21125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner APInt ShlMask(APInt::getHighBitsSet(BitWidth, BitWidth-OpRHSVal)); 21225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt *CI = ConstantInt::get(AndRHS->getContext(), 21325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner AndRHS->getValue() & ShlMask); 21425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 215da1d660aa285b724818bdd547f1b538011cc5459Chris Lattner if (CI->getValue() == ShlMask) 216da1d660aa285b724818bdd547f1b538011cc5459Chris Lattner // Masking out bits that the shift already masks. 21725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return ReplaceInstUsesWith(TheAnd, Op); // No need for the and. 21841a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 219da1d660aa285b724818bdd547f1b538011cc5459Chris Lattner if (CI != AndRHS) { // Reducing bits set in and. 22025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner TheAnd.setOperand(1, CI); 22125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return &TheAnd; 22225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 22325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 22425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 22525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case Instruction::LShr: { 22625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // We know that the AND will not produce any of the bits shifted in, so if 22725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // the anded constant includes them, clear them now! This only applies to 22825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // unsigned shifts, because a signed shr may bring in set bits! 22925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // 23025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner uint32_t BitWidth = AndRHS->getType()->getBitWidth(); 23125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner uint32_t OpRHSVal = OpRHS->getLimitedValue(BitWidth); 23225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner APInt ShrMask(APInt::getLowBitsSet(BitWidth, BitWidth - OpRHSVal)); 23325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt *CI = ConstantInt::get(Op->getContext(), 23425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner AndRHS->getValue() & ShrMask); 23525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 236da1d660aa285b724818bdd547f1b538011cc5459Chris Lattner if (CI->getValue() == ShrMask) 237da1d660aa285b724818bdd547f1b538011cc5459Chris Lattner // Masking out bits that the shift already masks. 23825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return ReplaceInstUsesWith(TheAnd, Op); 23941a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 240da1d660aa285b724818bdd547f1b538011cc5459Chris Lattner if (CI != AndRHS) { 24125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner TheAnd.setOperand(1, CI); // Reduce bits set in and cst. 24225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return &TheAnd; 24325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 24425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 24525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 24625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case Instruction::AShr: 24725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Signed shr. 24825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // See if this is shifting in some sign extension, then masking it out 24925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // with an and. 25025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op->hasOneUse()) { 25125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner uint32_t BitWidth = AndRHS->getType()->getBitWidth(); 25225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner uint32_t OpRHSVal = OpRHS->getLimitedValue(BitWidth); 25325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner APInt ShrMask(APInt::getLowBitsSet(BitWidth, BitWidth - OpRHSVal)); 25425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Constant *C = ConstantInt::get(Op->getContext(), 25525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner AndRHS->getValue() & ShrMask); 25625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (C == AndRHS) { // Masking out bits shifted in. 25725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (Val ashr C1) & C2 -> (Val lshr C1) & C2 25825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Make the argument unsigned. 25925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *ShVal = Op->getOperand(0); 26025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ShVal = Builder->CreateLShr(ShVal, OpRHS, Op->getName()); 26125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateAnd(ShVal, AndRHS, TheAnd.getName()); 26225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 26325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 26425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 26525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 26625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return 0; 26725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 26825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 26925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 27025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// InsertRangeTest - Emit a computation of: (V >= Lo && V < Hi) if Inside is 2717a2bdde0a0eebcd2125055e0eacaca040f0b766cChris Lattner/// true, otherwise (V < Lo || V >= Hi). In practice, we emit the more efficient 27245fc0b65e22124333d0545675e18d2dd00ebe967NAKAMURA Takumi/// (V-Lo) \<u Hi-Lo. This method expects that Lo <= Hi. isSigned indicates 27325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// whether to treat the V, Lo and HI as signed or not. IB is the location to 27425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// insert new instructions. 275f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris LattnerValue *InstCombiner::InsertRangeTest(Value *V, Constant *Lo, Constant *Hi, 276f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner bool isSigned, bool Inside) { 27741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper assert(cast<ConstantInt>(ConstantExpr::getICmp((isSigned ? 27825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ICmpInst::ICMP_SLE:ICmpInst::ICMP_ULE), Lo, Hi))->getZExtValue() && 27925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner "Lo is not <= Hi in range emission code!"); 28041a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 28125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Inside) { 28225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Lo == Hi) // Trivially false. 283f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return ConstantInt::getFalse(V->getContext()); 28425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 28525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // V >= Min && V < Hi --> V < Hi 28625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (cast<ConstantInt>(Lo)->isMinValue(isSigned)) { 28741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper ICmpInst::Predicate pred = (isSigned ? 28825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT); 289f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateICmp(pred, V, Hi); 29025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 29125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 29225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Emit V-Lo <u Hi-Lo 29325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Constant *NegLo = ConstantExpr::getNeg(Lo); 29425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Add = Builder->CreateAdd(V, NegLo, V->getName()+".off"); 29525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Constant *UpperBound = ConstantExpr::getAdd(NegLo, Hi); 296f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateICmpULT(Add, UpperBound); 29725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 29825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 29925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Lo == Hi) // Trivially true. 300f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return ConstantInt::getTrue(V->getContext()); 30125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 30225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // V < Min || V >= Hi -> V > Hi-1 30325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Hi = SubOne(cast<ConstantInt>(Hi)); 30425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (cast<ConstantInt>(Lo)->isMinValue(isSigned)) { 30541a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper ICmpInst::Predicate pred = (isSigned ? 30625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT); 307f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateICmp(pred, V, Hi); 30825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 30925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 31025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Emit V-Lo >u Hi-1-Lo 31125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Note that Hi has already had one subtracted from it, above. 31225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt *NegLo = cast<ConstantInt>(ConstantExpr::getNeg(Lo)); 31325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Add = Builder->CreateAdd(V, NegLo, V->getName()+".off"); 31425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Constant *LowerBound = ConstantExpr::getAdd(NegLo, Hi); 315f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateICmpUGT(Add, LowerBound); 31625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 31725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 31894c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru// isRunOfOnes - Returns true iff Val consists of one contiguous run of 1s with 31925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner// any number of 0s on either side. The 1s are allowed to wrap from LSB to 32025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner// MSB, so 0x000FFF0, 0x0000FFFF, and 0xFF0000FF are all runs. 0x0F0F0000 is 32125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner// not, since all 1s are not contiguous. 32225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattnerstatic bool isRunOfOnes(ConstantInt *Val, uint32_t &MB, uint32_t &ME) { 32325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner const APInt& V = Val->getValue(); 32425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner uint32_t BitWidth = Val->getType()->getBitWidth(); 32525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (!APIntOps::isShiftedMask(BitWidth, V)) return false; 32625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 32725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // look for the first zero bit after the run of ones 32825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner MB = BitWidth - ((V - 1) ^ V).countLeadingZeros(); 32925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // look for the first non-zero bit 33041a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper ME = V.getActiveBits(); 33125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return true; 33225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 33325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 33425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// FoldLogicalPlusAnd - This is part of an expression (LHS +/- RHS) & Mask, 33525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// where isSub determines whether the operator is a sub. If we can fold one of 33625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// the following xforms: 33741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper/// 33894c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru/// ((A & N) +/- B) & Mask -> (A +/- B) & Mask iff N&Mask == Mask 33994c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru/// ((A | N) +/- B) & Mask -> (A +/- B) & Mask iff N&Mask == 0 34094c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru/// ((A ^ N) +/- B) & Mask -> (A +/- B) & Mask iff N&Mask == 0 34125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// 34225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// return (A +/- B). 34325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// 34425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris LattnerValue *InstCombiner::FoldLogicalPlusAnd(Value *LHS, Value *RHS, 34525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt *Mask, bool isSub, 34625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Instruction &I) { 34725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Instruction *LHSI = dyn_cast<Instruction>(LHS); 34825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (!LHSI || LHSI->getNumOperands() != 2 || 34925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner !isa<ConstantInt>(LHSI->getOperand(1))) return 0; 35025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 35125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt *N = cast<ConstantInt>(LHSI->getOperand(1)); 35225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 35325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (LHSI->getOpcode()) { 35425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: return 0; 35525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case Instruction::And: 35625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ConstantExpr::getAnd(N, Mask) == Mask) { 35725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If the AndRHS is a power of two minus one (0+1+), this is simple. 35841a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper if ((Mask->getValue().countLeadingZeros() + 35941a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper Mask->getValue().countPopulation()) == 36025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Mask->getValue().getBitWidth()) 36125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 36225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 36325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Otherwise, if Mask is 0+1+0+, and if B is known to have the low 0+ 36425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // part, we don't need any explicit masks to take them out of A. If that 36525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // is all N is, ignore it. 36625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner uint32_t MB = 0, ME = 0; 36725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (isRunOfOnes(Mask, MB, ME)) { // begin/end bit of run, inclusive 36825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner uint32_t BitWidth = cast<IntegerType>(RHS->getType())->getBitWidth(); 36925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner APInt Mask(APInt::getLowBitsSet(BitWidth, MB-1)); 37025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (MaskedValueIsZero(RHS, Mask)) 37125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 37225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 37325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 37425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return 0; 37525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case Instruction::Or: 37625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case Instruction::Xor: 37725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If the AndRHS is a power of two minus one (0+1+), and N&Mask == 0 37841a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper if ((Mask->getValue().countLeadingZeros() + 37925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Mask->getValue().countPopulation()) == Mask->getValue().getBitWidth() 38025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner && ConstantExpr::getAnd(N, Mask)->isNullValue()) 38125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 38225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return 0; 38325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 38441a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 38525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (isSub) 38625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return Builder->CreateSub(LHSI->getOperand(0), RHS, "fold"); 38725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return Builder->CreateAdd(LHSI->getOperand(0), RHS, "fold"); 38825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 38925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 3905c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// enum for classifying (icmp eq (A & B), C) and (icmp ne (A & B), C) 39141a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper/// One of A and B is considered the mask, the other the value. This is 39241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper/// described as the "AMask" or "BMask" part of the enum. If the enum 3935c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// contains only "Mask", then both A and B can be considered masks. 3945c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// If A is the mask, then it was proven, that (A & C) == C. This 3955c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// is trivial if C == A, or C == 0. If both A and C are constants, this 3965c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// proof is also easy. 3975c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// For the following explanations we assume that A is the mask. 39841a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper/// The part "AllOnes" declares, that the comparison is true only 3995c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// if (A & B) == A, or all bits of A are set in B. 4005c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// Example: (icmp eq (A & 3), 3) -> FoldMskICmp_AMask_AllOnes 40141a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper/// The part "AllZeroes" declares, that the comparison is true only 4025c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// if (A & B) == 0, or all bits of A are cleared in B. 4035c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// Example: (icmp eq (A & 3), 0) -> FoldMskICmp_Mask_AllZeroes 40441a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper/// The part "Mixed" declares, that (A & B) == C and C might or might not 4055c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// contain any number of one bits and zero bits. 4065c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// Example: (icmp eq (A & 3), 1) -> FoldMskICmp_AMask_Mixed 4075c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// The Part "Not" means, that in above descriptions "==" should be replaced 4085c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// by "!=". 4095c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// Example: (icmp ne (A & 3), 3) -> FoldMskICmp_AMask_NotAllOnes 4105c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// If the mask A contains a single bit, then the following is equivalent: 4115c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// (icmp eq (A & B), A) equals (icmp ne (A & B), 0) 4125c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// (icmp ne (A & B), A) equals (icmp eq (A & B), 0) 4135c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Andersonenum MaskedICmpType { 4145c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_AMask_AllOnes = 1, 4155c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_AMask_NotAllOnes = 2, 4165c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_BMask_AllOnes = 4, 4175c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_BMask_NotAllOnes = 8, 4185c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_Mask_AllZeroes = 16, 4195c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_Mask_NotAllZeroes = 32, 4205c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_AMask_Mixed = 64, 4215c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_AMask_NotMixed = 128, 4225c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_BMask_Mixed = 256, 4235c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_BMask_NotMixed = 512 4245c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson}; 4255c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson 4265c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// return the set of pattern classes (from MaskedICmpType) 4275c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// that (icmp SCC (A & B), C) satisfies 42841a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topperstatic unsigned getTypeOfMaskedICmp(Value* A, Value* B, Value* C, 4295c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson ICmpInst::Predicate SCC) 4305c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson{ 4315c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson ConstantInt *ACst = dyn_cast<ConstantInt>(A); 4325c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson ConstantInt *BCst = dyn_cast<ConstantInt>(B); 4335c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson ConstantInt *CCst = dyn_cast<ConstantInt>(C); 4345c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson bool icmp_eq = (SCC == ICmpInst::ICMP_EQ); 43541a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper bool icmp_abit = (ACst != 0 && !ACst->isZero() && 4365c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson ACst->getValue().isPowerOf2()); 43741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper bool icmp_bbit = (BCst != 0 && !BCst->isZero() && 4385c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson BCst->getValue().isPowerOf2()); 4395c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson unsigned result = 0; 4405c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (CCst != 0 && CCst->isZero()) { 4415c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // if C is zero, then both A and B qualify as mask 4425c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson result |= (icmp_eq ? (FoldMskICmp_Mask_AllZeroes | 4435c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_Mask_AllZeroes | 4445c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_AMask_Mixed | 4455c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_BMask_Mixed) 4465c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson : (FoldMskICmp_Mask_NotAllZeroes | 4475c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_Mask_NotAllZeroes | 4485c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_AMask_NotMixed | 4495c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_BMask_NotMixed)); 4505c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (icmp_abit) 4515c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson result |= (icmp_eq ? (FoldMskICmp_AMask_NotAllOnes | 45241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper FoldMskICmp_AMask_NotMixed) 4535c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson : (FoldMskICmp_AMask_AllOnes | 4545c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_AMask_Mixed)); 4555c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (icmp_bbit) 4565c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson result |= (icmp_eq ? (FoldMskICmp_BMask_NotAllOnes | 45741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper FoldMskICmp_BMask_NotMixed) 4585c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson : (FoldMskICmp_BMask_AllOnes | 4595c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_BMask_Mixed)); 4605c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson return result; 4615c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson } 4625c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (A == C) { 4635c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson result |= (icmp_eq ? (FoldMskICmp_AMask_AllOnes | 4645c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_AMask_Mixed) 4655c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson : (FoldMskICmp_AMask_NotAllOnes | 4665c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_AMask_NotMixed)); 4675c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (icmp_abit) 4685c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson result |= (icmp_eq ? (FoldMskICmp_Mask_NotAllZeroes | 4695c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_AMask_NotMixed) 4705c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson : (FoldMskICmp_Mask_AllZeroes | 4715c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_AMask_Mixed)); 47200f8102758316cf754668b98c748c2a349f37966Craig Topper } else if (ACst != 0 && CCst != 0 && 47300f8102758316cf754668b98c748c2a349f37966Craig Topper ConstantExpr::getAnd(ACst, CCst) == CCst) { 4745c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson result |= (icmp_eq ? FoldMskICmp_AMask_Mixed 4755c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson : FoldMskICmp_AMask_NotMixed); 4765c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson } 47700f8102758316cf754668b98c748c2a349f37966Craig Topper if (B == C) { 4785c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson result |= (icmp_eq ? (FoldMskICmp_BMask_AllOnes | 4795c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_BMask_Mixed) 4805c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson : (FoldMskICmp_BMask_NotAllOnes | 4815c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_BMask_NotMixed)); 4825c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (icmp_bbit) 4835c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson result |= (icmp_eq ? (FoldMskICmp_Mask_NotAllZeroes | 48441a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper FoldMskICmp_BMask_NotMixed) 4855c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson : (FoldMskICmp_Mask_AllZeroes | 4865c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_BMask_Mixed)); 48700f8102758316cf754668b98c748c2a349f37966Craig Topper } else if (BCst != 0 && CCst != 0 && 48800f8102758316cf754668b98c748c2a349f37966Craig Topper ConstantExpr::getAnd(BCst, CCst) == CCst) { 4895c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson result |= (icmp_eq ? FoldMskICmp_BMask_Mixed 4905c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson : FoldMskICmp_BMask_NotMixed); 4915c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson } 4925c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson return result; 4935c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson} 4945c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson 49547a86077212bb680c3273842b1aba801757836eaBenjamin Kramer/// decomposeBitTestICmp - Decompose an icmp into the form ((X & Y) pred Z) 49647a86077212bb680c3273842b1aba801757836eaBenjamin Kramer/// if possible. The returned predicate is either == or !=. Returns false if 49747a86077212bb680c3273842b1aba801757836eaBenjamin Kramer/// decomposition fails. 49847a86077212bb680c3273842b1aba801757836eaBenjamin Kramerstatic bool decomposeBitTestICmp(const ICmpInst *I, ICmpInst::Predicate &Pred, 49947a86077212bb680c3273842b1aba801757836eaBenjamin Kramer Value *&X, Value *&Y, Value *&Z) { 50047a86077212bb680c3273842b1aba801757836eaBenjamin Kramer // X < 0 is equivalent to (X & SignBit) != 0. 50147a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (I->getPredicate() == ICmpInst::ICMP_SLT) 50247a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (ConstantInt *C = dyn_cast<ConstantInt>(I->getOperand(1))) 50347a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (C->isZero()) { 50447a86077212bb680c3273842b1aba801757836eaBenjamin Kramer X = I->getOperand(0); 50547a86077212bb680c3273842b1aba801757836eaBenjamin Kramer Y = ConstantInt::get(I->getContext(), 50647a86077212bb680c3273842b1aba801757836eaBenjamin Kramer APInt::getSignBit(C->getBitWidth())); 50747a86077212bb680c3273842b1aba801757836eaBenjamin Kramer Pred = ICmpInst::ICMP_NE; 50847a86077212bb680c3273842b1aba801757836eaBenjamin Kramer Z = C; 50947a86077212bb680c3273842b1aba801757836eaBenjamin Kramer return true; 51047a86077212bb680c3273842b1aba801757836eaBenjamin Kramer } 51147a86077212bb680c3273842b1aba801757836eaBenjamin Kramer 51247a86077212bb680c3273842b1aba801757836eaBenjamin Kramer // X > -1 is equivalent to (X & SignBit) == 0. 51347a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (I->getPredicate() == ICmpInst::ICMP_SGT) 51447a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (ConstantInt *C = dyn_cast<ConstantInt>(I->getOperand(1))) 51547a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (C->isAllOnesValue()) { 51647a86077212bb680c3273842b1aba801757836eaBenjamin Kramer X = I->getOperand(0); 51747a86077212bb680c3273842b1aba801757836eaBenjamin Kramer Y = ConstantInt::get(I->getContext(), 51847a86077212bb680c3273842b1aba801757836eaBenjamin Kramer APInt::getSignBit(C->getBitWidth())); 51947a86077212bb680c3273842b1aba801757836eaBenjamin Kramer Pred = ICmpInst::ICMP_EQ; 52047a86077212bb680c3273842b1aba801757836eaBenjamin Kramer Z = ConstantInt::getNullValue(C->getType()); 52147a86077212bb680c3273842b1aba801757836eaBenjamin Kramer return true; 52247a86077212bb680c3273842b1aba801757836eaBenjamin Kramer } 52347a86077212bb680c3273842b1aba801757836eaBenjamin Kramer 52447a86077212bb680c3273842b1aba801757836eaBenjamin Kramer return false; 52547a86077212bb680c3273842b1aba801757836eaBenjamin Kramer} 52647a86077212bb680c3273842b1aba801757836eaBenjamin Kramer 5275c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// foldLogOpOfMaskedICmpsHelper: 5285c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// handle (icmp(A & B) ==/!= C) &/| (icmp(A & D) ==/!= E) 5295c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// return the set of pattern classes (from MaskedICmpType) 5305c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// that both LHS and RHS satisfy 53141a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topperstatic unsigned foldLogOpOfMaskedICmpsHelper(Value*& A, 5325c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value*& B, Value*& C, 5335c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value*& D, Value*& E, 53447a86077212bb680c3273842b1aba801757836eaBenjamin Kramer ICmpInst *LHS, ICmpInst *RHS, 53547a86077212bb680c3273842b1aba801757836eaBenjamin Kramer ICmpInst::Predicate &LHSCC, 53647a86077212bb680c3273842b1aba801757836eaBenjamin Kramer ICmpInst::Predicate &RHSCC) { 5375c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (LHS->getOperand(0)->getType() != RHS->getOperand(0)->getType()) return 0; 5385c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // vectors are not (yet?) supported 5395c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (LHS->getOperand(0)->getType()->isVectorTy()) return 0; 5405c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson 5415c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // Here comes the tricky part: 54241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper // LHS might be of the form L11 & L12 == X, X == L21 & L22, 5435c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // and L11 & L12 == L21 & L22. The same goes for RHS. 5445c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // Now we must find those components L** and R**, that are equal, so 54541a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper // that we can extract the parameters A, B, C, D, and E for the canonical 5465c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // above. 5475c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value *L1 = LHS->getOperand(0); 5485c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value *L2 = LHS->getOperand(1); 5495c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value *L11,*L12,*L21,*L22; 55047a86077212bb680c3273842b1aba801757836eaBenjamin Kramer // Check whether the icmp can be decomposed into a bit test. 55147a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (decomposeBitTestICmp(LHS, LHSCC, L11, L12, L2)) { 55247a86077212bb680c3273842b1aba801757836eaBenjamin Kramer L21 = L22 = L1 = 0; 55347a86077212bb680c3273842b1aba801757836eaBenjamin Kramer } else { 55447a86077212bb680c3273842b1aba801757836eaBenjamin Kramer // Look for ANDs in the LHS icmp. 55547a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (match(L1, m_And(m_Value(L11), m_Value(L12)))) { 55647a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (!match(L2, m_And(m_Value(L21), m_Value(L22)))) 55747a86077212bb680c3273842b1aba801757836eaBenjamin Kramer L21 = L22 = 0; 55847a86077212bb680c3273842b1aba801757836eaBenjamin Kramer } else { 55947a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (!match(L2, m_And(m_Value(L11), m_Value(L12)))) 56047a86077212bb680c3273842b1aba801757836eaBenjamin Kramer return 0; 56147a86077212bb680c3273842b1aba801757836eaBenjamin Kramer std::swap(L1, L2); 5625c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson L21 = L22 = 0; 56347a86077212bb680c3273842b1aba801757836eaBenjamin Kramer } 5645c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson } 5655c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson 56647a86077212bb680c3273842b1aba801757836eaBenjamin Kramer // Bail if LHS was a icmp that can't be decomposed into an equality. 56747a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (!ICmpInst::isEquality(LHSCC)) 56847a86077212bb680c3273842b1aba801757836eaBenjamin Kramer return 0; 56947a86077212bb680c3273842b1aba801757836eaBenjamin Kramer 5705c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value *R1 = RHS->getOperand(0); 5715c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value *R2 = RHS->getOperand(1); 5725c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value *R11,*R12; 5735c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson bool ok = false; 57447a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (decomposeBitTestICmp(RHS, RHSCC, R11, R12, R2)) { 57547a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (R11 == L11 || R11 == L12 || R11 == L21 || R11 == L22) { 57647a86077212bb680c3273842b1aba801757836eaBenjamin Kramer A = R11; D = R12; 57747a86077212bb680c3273842b1aba801757836eaBenjamin Kramer } else if (R12 == L11 || R12 == L12 || R12 == L21 || R12 == L22) { 57847a86077212bb680c3273842b1aba801757836eaBenjamin Kramer A = R12; D = R11; 57947a86077212bb680c3273842b1aba801757836eaBenjamin Kramer } else { 58047a86077212bb680c3273842b1aba801757836eaBenjamin Kramer return 0; 5815c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson } 58247a86077212bb680c3273842b1aba801757836eaBenjamin Kramer E = R2; R1 = 0; ok = true; 58347a86077212bb680c3273842b1aba801757836eaBenjamin Kramer } else if (match(R1, m_And(m_Value(R11), m_Value(R12)))) { 58447a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (R11 == L11 || R11 == L12 || R11 == L21 || R11 == L22) { 58547a86077212bb680c3273842b1aba801757836eaBenjamin Kramer A = R11; D = R12; E = R2; ok = true; 58647a86077212bb680c3273842b1aba801757836eaBenjamin Kramer } else if (R12 == L11 || R12 == L12 || R12 == L21 || R12 == L22) { 5875c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson A = R12; D = R11; E = R2; ok = true; 5885c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson } 5895c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson } 59047a86077212bb680c3273842b1aba801757836eaBenjamin Kramer 59147a86077212bb680c3273842b1aba801757836eaBenjamin Kramer // Bail if RHS was a icmp that can't be decomposed into an equality. 59247a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (!ICmpInst::isEquality(RHSCC)) 59347a86077212bb680c3273842b1aba801757836eaBenjamin Kramer return 0; 59447a86077212bb680c3273842b1aba801757836eaBenjamin Kramer 59547a86077212bb680c3273842b1aba801757836eaBenjamin Kramer // Look for ANDs in on the right side of the RHS icmp. 5965c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (!ok && match(R2, m_And(m_Value(R11), m_Value(R12)))) { 59747a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (R11 == L11 || R11 == L12 || R11 == L21 || R11 == L22) { 59847a86077212bb680c3273842b1aba801757836eaBenjamin Kramer A = R11; D = R12; E = R1; ok = true; 59947a86077212bb680c3273842b1aba801757836eaBenjamin Kramer } else if (R12 == L11 || R12 == L12 || R12 == L21 || R12 == L22) { 6005c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson A = R12; D = R11; E = R1; ok = true; 60147a86077212bb680c3273842b1aba801757836eaBenjamin Kramer } else { 6025c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson return 0; 60347a86077212bb680c3273842b1aba801757836eaBenjamin Kramer } 6045c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson } 6055c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (!ok) 6065c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson return 0; 6075c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson 6085c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (L11 == A) { 6095c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson B = L12; C = L2; 61000f8102758316cf754668b98c748c2a349f37966Craig Topper } else if (L12 == A) { 6115c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson B = L11; C = L2; 61200f8102758316cf754668b98c748c2a349f37966Craig Topper } else if (L21 == A) { 6135c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson B = L22; C = L1; 61400f8102758316cf754668b98c748c2a349f37966Craig Topper } else if (L22 == A) { 6155c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson B = L21; C = L1; 6165c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson } 6175c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson 6185c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson unsigned left_type = getTypeOfMaskedICmp(A, B, C, LHSCC); 6195c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson unsigned right_type = getTypeOfMaskedICmp(A, D, E, RHSCC); 6205c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson return left_type & right_type; 6215c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson} 6225c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// foldLogOpOfMaskedICmps: 6235c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// try to fold (icmp(A & B) ==/!= C) &/| (icmp(A & D) ==/!= E) 6245c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// into a single (icmp(A & X) ==/!= Y) 6255c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Andersonstatic Value* foldLogOpOfMaskedICmps(ICmpInst *LHS, ICmpInst *RHS, 6265c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson ICmpInst::Predicate NEWCC, 6275c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson llvm::InstCombiner::BuilderTy* Builder) { 6285c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value *A = 0, *B = 0, *C = 0, *D = 0, *E = 0; 62947a86077212bb680c3273842b1aba801757836eaBenjamin Kramer ICmpInst::Predicate LHSCC = LHS->getPredicate(), RHSCC = RHS->getPredicate(); 63047a86077212bb680c3273842b1aba801757836eaBenjamin Kramer unsigned mask = foldLogOpOfMaskedICmpsHelper(A, B, C, D, E, LHS, RHS, 63147a86077212bb680c3273842b1aba801757836eaBenjamin Kramer LHSCC, RHSCC); 6327e4ac32a4e674c077317f190e9507ccb26eeaf3fBenjamin Kramer if (mask == 0) return 0; 63347a86077212bb680c3273842b1aba801757836eaBenjamin Kramer assert(ICmpInst::isEquality(LHSCC) && ICmpInst::isEquality(RHSCC) && 63447a86077212bb680c3273842b1aba801757836eaBenjamin Kramer "foldLogOpOfMaskedICmpsHelper must return an equality predicate."); 6355c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson 6365c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (NEWCC == ICmpInst::ICMP_NE) 6375c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson mask >>= 1; // treat "Not"-states as normal states 6385c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson 6395c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (mask & FoldMskICmp_Mask_AllZeroes) { 64041a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper // (icmp eq (A & B), 0) & (icmp eq (A & D), 0) 6415c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // -> (icmp eq (A & (B|D)), 0) 6425c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value* newOr = Builder->CreateOr(B, D); 6435c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value* newAnd = Builder->CreateAnd(A, newOr); 6445c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // we can't use C as zero, because we might actually handle 64541a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper // (icmp ne (A & B), B) & (icmp ne (A & D), D) 6465c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // with B and D, having a single bit set 6475c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value* zero = Constant::getNullValue(A->getType()); 6485c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson return Builder->CreateICmp(NEWCC, newAnd, zero); 6495c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson } 65000f8102758316cf754668b98c748c2a349f37966Craig Topper if (mask & FoldMskICmp_BMask_AllOnes) { 65141a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper // (icmp eq (A & B), B) & (icmp eq (A & D), D) 6525c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // -> (icmp eq (A & (B|D)), (B|D)) 6535c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value* newOr = Builder->CreateOr(B, D); 6545c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value* newAnd = Builder->CreateAnd(A, newOr); 6555c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson return Builder->CreateICmp(NEWCC, newAnd, newOr); 65641a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper } 65700f8102758316cf754668b98c748c2a349f37966Craig Topper if (mask & FoldMskICmp_AMask_AllOnes) { 65841a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper // (icmp eq (A & B), A) & (icmp eq (A & D), A) 6595c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // -> (icmp eq (A & (B&D)), A) 6605c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value* newAnd1 = Builder->CreateAnd(B, D); 6615c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value* newAnd = Builder->CreateAnd(A, newAnd1); 6625c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson return Builder->CreateICmp(NEWCC, newAnd, A); 6635c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson } 66400f8102758316cf754668b98c748c2a349f37966Craig Topper if (mask & FoldMskICmp_BMask_Mixed) { 66541a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper // (icmp eq (A & B), C) & (icmp eq (A & D), E) 6665c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // We already know that B & C == C && D & E == E. 6675c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // If we can prove that (B & D) & (C ^ E) == 0, that is, the bits of 6685c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // C and E, which are shared by both the mask B and the mask D, don't 6695c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // contradict, then we can transform to 6705c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // -> (icmp eq (A & (B|D)), (C|E)) 6715c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // Currently, we only handle the case of B, C, D, and E being constant. 6725c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson ConstantInt *BCst = dyn_cast<ConstantInt>(B); 6735c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (BCst == 0) return 0; 6745c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson ConstantInt *DCst = dyn_cast<ConstantInt>(D); 6755c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (DCst == 0) return 0; 6765c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // we can't simply use C and E, because we might actually handle 67741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper // (icmp ne (A & B), B) & (icmp eq (A & D), D) 6785c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // with B and D, having a single bit set 6795c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson 6805c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson ConstantInt *CCst = dyn_cast<ConstantInt>(C); 6815c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (CCst == 0) return 0; 68247a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (LHSCC != NEWCC) 6835c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson CCst = dyn_cast<ConstantInt>( ConstantExpr::getXor(BCst, CCst) ); 6845c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson ConstantInt *ECst = dyn_cast<ConstantInt>(E); 6855c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (ECst == 0) return 0; 68647a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (RHSCC != NEWCC) 6875c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson ECst = dyn_cast<ConstantInt>( ConstantExpr::getXor(DCst, ECst) ); 6885c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson ConstantInt* MCst = dyn_cast<ConstantInt>( 6895c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson ConstantExpr::getAnd(ConstantExpr::getAnd(BCst, DCst), 6905c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson ConstantExpr::getXor(CCst, ECst)) ); 6915c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // if there is a conflict we should actually return a false for the 6925c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // whole construct 6935c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (!MCst->isZero()) 6945c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson return 0; 69544cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner Value *newOr1 = Builder->CreateOr(B, D); 69644cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner Value *newOr2 = ConstantExpr::getOr(CCst, ECst); 69744cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner Value *newAnd = Builder->CreateAnd(A, newOr1); 6985c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson return Builder->CreateICmp(NEWCC, newAnd, newOr2); 6995c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson } 7005c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson return 0; 7015c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson} 7025c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson 70325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// FoldAndOfICmps - Fold (icmp)&(icmp) if possible. 704f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris LattnerValue *InstCombiner::FoldAndOfICmps(ICmpInst *LHS, ICmpInst *RHS) { 70525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ICmpInst::Predicate LHSCC = LHS->getPredicate(), RHSCC = RHS->getPredicate(); 70625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 70725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (icmp1 A, B) & (icmp2 A, B) --> (icmp3 A, B) 70825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (PredicatesFoldable(LHSCC, RHSCC)) { 70925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHS->getOperand(0) == RHS->getOperand(1) && 71025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner LHS->getOperand(1) == RHS->getOperand(0)) 71125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner LHS->swapOperands(); 71225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHS->getOperand(0) == RHS->getOperand(0) && 71325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner LHS->getOperand(1) == RHS->getOperand(1)) { 71425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Op0 = LHS->getOperand(0), *Op1 = LHS->getOperand(1); 71525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner unsigned Code = getICmpCode(LHS) & getICmpCode(RHS); 71625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner bool isSigned = LHS->isSigned() || RHS->isSigned(); 7172e33944c101f2a08ed1d85e807830f2fc089dd06Pete Cooper return getNewICmpValue(isSigned, Code, Op0, Op1, Builder); 71825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 71925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 7205c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson 72144cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner // handle (roughly): (icmp eq (A & B), C) & (icmp eq (A & D), E) 72244cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner if (Value *V = foldLogOpOfMaskedICmps(LHS, RHS, ICmpInst::ICMP_EQ, Builder)) 72344cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner return V; 72441a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 72525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // This only handles icmp of constants: (icmp1 A, C1) & (icmp2 B, C2). 72625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Val = LHS->getOperand(0), *Val2 = RHS->getOperand(0); 72725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt *LHSCst = dyn_cast<ConstantInt>(LHS->getOperand(1)); 72825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt *RHSCst = dyn_cast<ConstantInt>(RHS->getOperand(1)); 72925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHSCst == 0 || RHSCst == 0) return 0; 73041a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 73125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHSCst == RHSCst && LHSCC == RHSCC) { 73225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (icmp ult A, C) & (icmp ult B, C) --> (icmp ult (A|B), C) 73325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // where C is a power of 2 73425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHSCC == ICmpInst::ICMP_ULT && 73525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner LHSCst->getValue().isPowerOf2()) { 73625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NewOr = Builder->CreateOr(Val, Val2); 737f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateICmp(LHSCC, NewOr, LHSCst); 73825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 73941a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 74025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (icmp eq A, 0) & (icmp eq B, 0) --> (icmp eq (A|B), 0) 74125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHSCC == ICmpInst::ICMP_EQ && LHSCst->isZero()) { 74225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NewOr = Builder->CreateOr(Val, Val2); 743f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateICmp(LHSCC, NewOr, LHSCst); 74425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 74525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 746264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer 747e12d58362176a7ea7ead7afa157194c18359499fBenjamin Kramer // (trunc x) == C1 & (and x, CA) == C2 -> (and x, CA|CMAX) == C1|C2 748264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer // where CMAX is the all ones value for the truncated type, 74994c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // iff the lower bits of C2 and CA are zero. 750e1b66f11459c7f1523939fb6ac1dfdc93e1d26efBill Wendling if (LHSCC == ICmpInst::ICMP_EQ && LHSCC == RHSCC && 751264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer LHS->hasOneUse() && RHS->hasOneUse()) { 752264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer Value *V; 753264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer ConstantInt *AndCst, *SmallCst = 0, *BigCst = 0; 754264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer 755264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer // (trunc x) == C1 & (and x, CA) == C2 75600f8102758316cf754668b98c748c2a349f37966Craig Topper // (and x, CA) == C2 & (trunc x) == C1 757264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer if (match(Val2, m_Trunc(m_Value(V))) && 758264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer match(Val, m_And(m_Specific(V), m_ConstantInt(AndCst)))) { 759264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer SmallCst = RHSCst; 760264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer BigCst = LHSCst; 76100f8102758316cf754668b98c748c2a349f37966Craig Topper } else if (match(Val, m_Trunc(m_Value(V))) && 76200f8102758316cf754668b98c748c2a349f37966Craig Topper match(Val2, m_And(m_Specific(V), m_ConstantInt(AndCst)))) { 763264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer SmallCst = LHSCst; 764264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer BigCst = RHSCst; 765264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer } 766264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer 767264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer if (SmallCst && BigCst) { 768264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer unsigned BigBitSize = BigCst->getType()->getBitWidth(); 769264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer unsigned SmallBitSize = SmallCst->getType()->getBitWidth(); 770264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer 771264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer // Check that the low bits are zero. 772264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer APInt Low = APInt::getLowBitsSet(BigBitSize, SmallBitSize); 773b0884f3f13ca6e5d83e3232d8390a4d58739d57cBenjamin Kramer if ((Low & AndCst->getValue()) == 0 && (Low & BigCst->getValue()) == 0) { 774264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer Value *NewAnd = Builder->CreateAnd(V, Low | AndCst->getValue()); 775264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer APInt N = SmallCst->getValue().zext(BigBitSize) | BigCst->getValue(); 776264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer Value *NewVal = ConstantInt::get(AndCst->getType()->getContext(), N); 777264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer return Builder->CreateICmp(LHSCC, NewAnd, NewVal); 778264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer } 779264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer } 780264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer } 781dfb806f6ba53b792171b928b57def9d0182d2f5fBenjamin Kramer 78225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // From here on, we only handle: 78325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (icmp1 A, C1) & (icmp2 A, C2) --> something simpler. 78425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Val != Val2) return 0; 78541a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 78625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ICMP_[US][GL]E X, CST is folded to ICMP_[US][GL]T elsewhere. 78725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHSCC == ICmpInst::ICMP_UGE || LHSCC == ICmpInst::ICMP_ULE || 78825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner RHSCC == ICmpInst::ICMP_UGE || RHSCC == ICmpInst::ICMP_ULE || 78925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner LHSCC == ICmpInst::ICMP_SGE || LHSCC == ICmpInst::ICMP_SLE || 79025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner RHSCC == ICmpInst::ICMP_SGE || RHSCC == ICmpInst::ICMP_SLE) 79125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return 0; 792d70be0b2c199183077626a9e756ecd14b807dd56Anders Carlsson 793d70be0b2c199183077626a9e756ecd14b807dd56Anders Carlsson // Make a constant range that's the intersection of the two icmp ranges. 794d70be0b2c199183077626a9e756ecd14b807dd56Anders Carlsson // If the intersection is empty, we know that the result is false. 79541a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper ConstantRange LHSRange = 796d70be0b2c199183077626a9e756ecd14b807dd56Anders Carlsson ConstantRange::makeICmpRegion(LHSCC, LHSCst->getValue()); 79741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper ConstantRange RHSRange = 798d70be0b2c199183077626a9e756ecd14b807dd56Anders Carlsson ConstantRange::makeICmpRegion(RHSCC, RHSCst->getValue()); 799d70be0b2c199183077626a9e756ecd14b807dd56Anders Carlsson 800d70be0b2c199183077626a9e756ecd14b807dd56Anders Carlsson if (LHSRange.intersectWith(RHSRange).isEmptySet()) 801d70be0b2c199183077626a9e756ecd14b807dd56Anders Carlsson return ConstantInt::get(CmpInst::makeCmpResultType(LHS->getType()), 0); 802d70be0b2c199183077626a9e756ecd14b807dd56Anders Carlsson 80325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // We can't fold (ugt x, C) & (sgt x, C2). 80425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (!PredicatesFoldable(LHSCC, RHSCC)) 80525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return 0; 80641a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 80725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Ensure that the larger constant is on the RHS. 80825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner bool ShouldSwap; 80925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (CmpInst::isSigned(LHSCC) || 81041a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper (ICmpInst::isEquality(LHSCC) && 81125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner CmpInst::isSigned(RHSCC))) 81225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ShouldSwap = LHSCst->getValue().sgt(RHSCst->getValue()); 81325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner else 81425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ShouldSwap = LHSCst->getValue().ugt(RHSCst->getValue()); 81541a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 81625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ShouldSwap) { 81725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(LHS, RHS); 81825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(LHSCst, RHSCst); 81925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(LHSCC, RHSCC); 82025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 82125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 822f451cb870efcf9e0302d25ed05f4cac6bb494e42Dan Gohman // At this point, we know we have two icmp instructions 82325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // comparing a value against two constants and and'ing the result 82425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // together. Because of the above check, we know that we only have 82541a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper // icmp eq, icmp ne, icmp [su]lt, and icmp [SU]gt here. We also know 82641a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper // (from the icmp folding check above), that the two constants 82725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // are not equal and that the larger constant is on the RHS 82825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner assert(LHSCst != RHSCst && "Compares not folded above?"); 82925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 83025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (LHSCC) { 83125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: llvm_unreachable("Unknown integer condition code!"); 83225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_EQ: 83325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (RHSCC) { 83425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: llvm_unreachable("Unknown integer condition code!"); 83525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_NE: // (X == 13 & X != 15) -> X == 13 83625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_ULT: // (X == 13 & X < 15) -> X == 13 83725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SLT: // (X == 13 & X < 15) -> X == 13 838f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return LHS; 83925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 84025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_NE: 84125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (RHSCC) { 84225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: llvm_unreachable("Unknown integer condition code!"); 84325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_ULT: 84425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHSCst == SubOne(RHSCst)) // (X != 13 & X u< 14) -> X < 13 845f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateICmpULT(Val, LHSCst); 84625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; // (X != 13 & X u< 15) -> no change 84725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SLT: 84825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHSCst == SubOne(RHSCst)) // (X != 13 & X s< 14) -> X < 13 849f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateICmpSLT(Val, LHSCst); 85025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; // (X != 13 & X s< 15) -> no change 85125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_EQ: // (X != 13 & X == 15) -> X == 15 85225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_UGT: // (X != 13 & X u> 15) -> X u> 15 85325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SGT: // (X != 13 & X s> 15) -> X s> 15 854f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return RHS; 85525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_NE: 85625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHSCst == SubOne(RHSCst)){// (X != 13 & X != 14) -> X-13 >u 1 85725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Constant *AddCST = ConstantExpr::getNeg(LHSCst); 85825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Add = Builder->CreateAdd(Val, AddCST, Val->getName()+".off"); 859f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateICmpUGT(Add, ConstantInt::get(Add->getType(), 1)); 86025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 86125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; // (X != 13 & X != 15) -> no change 86225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 86325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 86425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_ULT: 86525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (RHSCC) { 86625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: llvm_unreachable("Unknown integer condition code!"); 86725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_EQ: // (X u< 13 & X == 15) -> false 86825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_UGT: // (X u< 13 & X u> 15) -> false 869f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return ConstantInt::get(CmpInst::makeCmpResultType(LHS->getType()), 0); 87025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SGT: // (X u< 13 & X s> 15) -> no change 87125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 87225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_NE: // (X u< 13 & X != 15) -> X u< 13 87325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_ULT: // (X u< 13 & X u< 15) -> X u< 13 874f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return LHS; 87525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SLT: // (X u< 13 & X s< 15) -> no change 87625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 87725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 87825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 87925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SLT: 88025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (RHSCC) { 88125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: llvm_unreachable("Unknown integer condition code!"); 88225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_UGT: // (X s< 13 & X u> 15) -> no change 88325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 88425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_NE: // (X s< 13 & X != 15) -> X < 13 88525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SLT: // (X s< 13 & X s< 15) -> X < 13 886f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return LHS; 88725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_ULT: // (X s< 13 & X u< 15) -> no change 88825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 88925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 89025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 89125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_UGT: 89225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (RHSCC) { 89325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: llvm_unreachable("Unknown integer condition code!"); 89425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_EQ: // (X u> 13 & X == 15) -> X == 15 89525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_UGT: // (X u> 13 & X u> 15) -> X u> 15 896f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return RHS; 89725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SGT: // (X u> 13 & X s> 15) -> no change 89825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 89925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_NE: 90025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (RHSCst == AddOne(LHSCst)) // (X u> 13 & X != 14) -> X u> 14 901f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateICmp(LHSCC, Val, RHSCst); 90225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; // (X u> 13 & X != 15) -> no change 90325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_ULT: // (X u> 13 & X u< 15) -> (X-14) <u 1 904f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return InsertRangeTest(Val, AddOne(LHSCst), RHSCst, false, true); 90525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SLT: // (X u> 13 & X s< 15) -> no change 90625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 90725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 90825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 90925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SGT: 91025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (RHSCC) { 91125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: llvm_unreachable("Unknown integer condition code!"); 91225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_EQ: // (X s> 13 & X == 15) -> X == 15 91325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SGT: // (X s> 13 & X s> 15) -> X s> 15 914f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return RHS; 91525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_UGT: // (X s> 13 & X u> 15) -> no change 91625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 91725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_NE: 91825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (RHSCst == AddOne(LHSCst)) // (X s> 13 & X != 14) -> X s> 14 919f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateICmp(LHSCC, Val, RHSCst); 92025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; // (X s> 13 & X != 15) -> no change 92125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SLT: // (X s> 13 & X s< 15) -> (X-14) s< 1 922f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return InsertRangeTest(Val, AddOne(LHSCst), RHSCst, true, true); 92325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_ULT: // (X s> 13 & X u< 15) -> no change 92425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 92525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 92625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 92725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 92841a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 92925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return 0; 93025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 93125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 932f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner/// FoldAndOfFCmps - Optimize (fcmp)&(fcmp). NOTE: Unlike the rest of 933f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner/// instcombine, this returns a Value which should already be inserted into the 934f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner/// function. 935f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris LattnerValue *InstCombiner::FoldAndOfFCmps(FCmpInst *LHS, FCmpInst *RHS) { 93625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHS->getPredicate() == FCmpInst::FCMP_ORD && 93725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner RHS->getPredicate() == FCmpInst::FCMP_ORD) { 93825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (fcmp ord x, c) & (fcmp ord y, c) -> (fcmp ord x, y) 93925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ConstantFP *LHSC = dyn_cast<ConstantFP>(LHS->getOperand(1))) 94025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ConstantFP *RHSC = dyn_cast<ConstantFP>(RHS->getOperand(1))) { 94125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If either of the constants are nans, then the whole thing returns 94225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // false. 94325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHSC->getValueAPF().isNaN() || RHSC->getValueAPF().isNaN()) 944f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return ConstantInt::getFalse(LHS->getContext()); 945f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateFCmpORD(LHS->getOperand(0), RHS->getOperand(0)); 94625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 94741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 94825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Handle vector zeros. This occurs because the canonical form of 94925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // "fcmp ord x,x" is "fcmp ord x, 0". 95025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (isa<ConstantAggregateZero>(LHS->getOperand(1)) && 95125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner isa<ConstantAggregateZero>(RHS->getOperand(1))) 952f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateFCmpORD(LHS->getOperand(0), RHS->getOperand(0)); 95325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return 0; 95425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 95541a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 95625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Op0LHS = LHS->getOperand(0), *Op0RHS = LHS->getOperand(1); 95725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Op1LHS = RHS->getOperand(0), *Op1RHS = RHS->getOperand(1); 95825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner FCmpInst::Predicate Op0CC = LHS->getPredicate(), Op1CC = RHS->getPredicate(); 95941a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 96041a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 96125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0LHS == Op1RHS && Op0RHS == Op1LHS) { 96225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Swap RHS operands to match LHS. 96325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op1CC = FCmpInst::getSwappedPredicate(Op1CC); 96425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(Op1LHS, Op1RHS); 96525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 96641a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 96725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0LHS == Op1LHS && Op0RHS == Op1RHS) { 96825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Simplify (fcmp cc0 x, y) & (fcmp cc1 x, y). 96925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0CC == Op1CC) 970f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateFCmp((FCmpInst::Predicate)Op0CC, Op0LHS, Op0RHS); 97125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0CC == FCmpInst::FCMP_FALSE || Op1CC == FCmpInst::FCMP_FALSE) 972f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return ConstantInt::get(CmpInst::makeCmpResultType(LHS->getType()), 0); 97325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0CC == FCmpInst::FCMP_TRUE) 974f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return RHS; 97525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op1CC == FCmpInst::FCMP_TRUE) 976f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return LHS; 97741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 97825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner bool Op0Ordered; 97925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner bool Op1Ordered; 98025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner unsigned Op0Pred = getFCmpCode(Op0CC, Op0Ordered); 98125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner unsigned Op1Pred = getFCmpCode(Op1CC, Op1Ordered); 9828b421c8eb2c41ee66cd1023bc7c262bdfaea481dChad Rosier // uno && ord -> false 9838b421c8eb2c41ee66cd1023bc7c262bdfaea481dChad Rosier if (Op0Pred == 0 && Op1Pred == 0 && Op0Ordered != Op1Ordered) 9848b421c8eb2c41ee66cd1023bc7c262bdfaea481dChad Rosier return ConstantInt::get(CmpInst::makeCmpResultType(LHS->getType()), 0); 98525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op1Pred == 0) { 98625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(LHS, RHS); 98725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(Op0Pred, Op1Pred); 98825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(Op0Ordered, Op1Ordered); 98925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 99025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0Pred == 0) { 9917a0575b9a8ca291c33495623eae171394f33b58fManman Ren // uno && ueq -> uno && (uno || eq) -> uno 99225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ord && olt -> ord && (ord && lt) -> olt 9937a0575b9a8ca291c33495623eae171394f33b58fManman Ren if (!Op0Ordered && (Op0Ordered == Op1Ordered)) 9947a0575b9a8ca291c33495623eae171394f33b58fManman Ren return LHS; 9957a0575b9a8ca291c33495623eae171394f33b58fManman Ren if (Op0Ordered && (Op0Ordered == Op1Ordered)) 996f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return RHS; 99741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 99825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // uno && oeq -> uno && (ord && eq) -> false 99925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (!Op0Ordered) 1000f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return ConstantInt::get(CmpInst::makeCmpResultType(LHS->getType()), 0); 100125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ord && ueq -> ord && (uno || eq) -> oeq 1002f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return getFCmpValue(true, Op1Pred, Op0LHS, Op0RHS, Builder); 100325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 100425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 100525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 100625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return 0; 100725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 100825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 100925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 101025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris LattnerInstruction *InstCombiner::visitAnd(BinaryOperator &I) { 1011096aa79276b8527a3cbbb3691e40e729dea09523Duncan Sands bool Changed = SimplifyAssociativeOrCommutative(I); 101225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1); 101325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 101425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Value *V = SimplifyAndInst(Op0, Op1, TD)) 101525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return ReplaceInstUsesWith(I, V); 101625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 101737bf92b5238434b00fde79347ba5336e7554e562Duncan Sands // (A|B)&(A|C) -> A|(B&C) etc 101837bf92b5238434b00fde79347ba5336e7554e562Duncan Sands if (Value *V = SimplifyUsingDistributiveLaws(I)) 101937bf92b5238434b00fde79347ba5336e7554e562Duncan Sands return ReplaceInstUsesWith(I, V); 10205057f381418ddc8c96699c40479ead993cd62e7bDuncan Sands 102141a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper // See if we can simplify any instructions used by the instruction whose sole 102225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // purpose is to compute bits we don't care about. 102325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (SimplifyDemandedInstructionBits(I)) 102441a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper return &I; 102525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 102625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ConstantInt *AndRHS = dyn_cast<ConstantInt>(Op1)) { 102725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner const APInt &AndRHSMask = AndRHS->getValue(); 102825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 102925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Optimize a variety of ((val OP C1) & C2) combinations... 103025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (BinaryOperator *Op0I = dyn_cast<BinaryOperator>(Op0)) { 103125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Op0LHS = Op0I->getOperand(0); 103225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Op0RHS = Op0I->getOperand(1); 103325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (Op0I->getOpcode()) { 103425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: break; 103525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case Instruction::Xor: 103644cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner case Instruction::Or: { 103725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If the mask is only needed on one incoming arm, push it up. 103825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (!Op0I->hasOneUse()) break; 103941a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 104044cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner APInt NotAndRHS(~AndRHSMask); 104125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (MaskedValueIsZero(Op0LHS, NotAndRHS)) { 104225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Not masking anything out for the LHS, move to RHS. 104325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NewRHS = Builder->CreateAnd(Op0RHS, AndRHS, 104425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op0RHS->getName()+".masked"); 104525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::Create(Op0I->getOpcode(), Op0LHS, NewRHS); 104625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 104725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (!isa<Constant>(Op0RHS) && 104825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner MaskedValueIsZero(Op0RHS, NotAndRHS)) { 104925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Not masking anything out for the RHS, move to LHS. 105025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NewLHS = Builder->CreateAnd(Op0LHS, AndRHS, 105125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op0LHS->getName()+".masked"); 105225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::Create(Op0I->getOpcode(), NewLHS, Op0RHS); 105325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 105425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 105525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 105644cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner } 105725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case Instruction::Add: 105894c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // ((A & N) + B) & AndRHS -> (A + B) & AndRHS iff N&AndRHS == AndRHS. 105994c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // ((A | N) + B) & AndRHS -> (A + B) & AndRHS iff N&AndRHS == 0 106094c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // ((A ^ N) + B) & AndRHS -> (A + B) & AndRHS iff N&AndRHS == 0 106125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Value *V = FoldLogicalPlusAnd(Op0LHS, Op0RHS, AndRHS, false, I)) 106225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateAnd(V, AndRHS); 106325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Value *V = FoldLogicalPlusAnd(Op0RHS, Op0LHS, AndRHS, false, I)) 106425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateAnd(V, AndRHS); // Add commutes 106525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 106625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 106725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case Instruction::Sub: 106894c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // ((A & N) - B) & AndRHS -> (A - B) & AndRHS iff N&AndRHS == AndRHS. 106994c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // ((A | N) - B) & AndRHS -> (A - B) & AndRHS iff N&AndRHS == 0 107094c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // ((A ^ N) - B) & AndRHS -> (A - B) & AndRHS iff N&AndRHS == 0 107125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Value *V = FoldLogicalPlusAnd(Op0LHS, Op0RHS, AndRHS, true, I)) 107225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateAnd(V, AndRHS); 107325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 107494c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // (A - N) & AndRHS -> -N & AndRHS iff A&AndRHS==0 and AndRHS 107525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // has 1's for all bits that the subtraction with A might affect. 107644cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner if (Op0I->hasOneUse() && !match(Op0LHS, m_Zero())) { 107725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner uint32_t BitWidth = AndRHSMask.getBitWidth(); 107825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner uint32_t Zeros = AndRHSMask.countLeadingZeros(); 107925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner APInt Mask = APInt::getLowBitsSet(BitWidth, BitWidth - Zeros); 108025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 108144cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner if (MaskedValueIsZero(Op0LHS, Mask)) { 108225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NewNeg = Builder->CreateNeg(Op0RHS); 108325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateAnd(NewNeg, AndRHS); 108425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 108525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 108625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 108725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 108825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case Instruction::Shl: 108925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case Instruction::LShr: 109025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (1 << x) & 1 --> zext(x == 0) 109125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (1 >> x) & 1 --> zext(x == 0) 109225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (AndRHSMask == 1 && Op0LHS == AndRHS) { 109325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NewICmp = 109425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Builder->CreateICmpEQ(Op0RHS, Constant::getNullValue(I.getType())); 109525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return new ZExtInst(NewICmp, I.getType()); 109625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 109725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 109825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 109941a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 110025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ConstantInt *Op0CI = dyn_cast<ConstantInt>(Op0I->getOperand(1))) 110125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Instruction *Res = OptAndOp(Op0I, Op0CI, AndRHS, I)) 110225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return Res; 110344cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner } 110441a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 110544cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner // If this is an integer truncation, and if the source is an 'and' with 110644cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner // immediate, transform it. This frequently occurs for bitfield accesses. 110744cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner { 110844cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner Value *X = 0; ConstantInt *YC = 0; 110944cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner if (match(Op0, m_Trunc(m_And(m_Value(X), m_ConstantInt(YC))))) { 111044cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner // Change: and (trunc (and X, YC) to T), C2 111144cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner // into : and (trunc X to T), trunc(YC) & C2 111241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper // This will fold the two constants together, which may allow 111344cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner // other simplifications. 111444cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner Value *NewCast = Builder->CreateTrunc(X, I.getType(), "and.shrunk"); 111544cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner Constant *C3 = ConstantExpr::getTrunc(YC, I.getType()); 111644cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner C3 = ConstantExpr::getAnd(C3, AndRHS); 111744cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner return BinaryOperator::CreateAnd(NewCast, C3); 111825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 111925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 112025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 112125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Try to fold constant and into select arguments. 112225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (SelectInst *SI = dyn_cast<SelectInst>(Op0)) 112325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Instruction *R = FoldOpIntoSelect(I, SI)) 112425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return R; 112525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (isa<PHINode>(Op0)) 112625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Instruction *NV = FoldOpIntoPhi(I)) 112725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return NV; 112825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 112925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 113025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 113125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (~A & ~B) == (~(A | B)) - De Morgan's Law 113225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Value *Op0NotVal = dyn_castNotVal(Op0)) 113325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Value *Op1NotVal = dyn_castNotVal(Op1)) 113425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0->hasOneUse() && Op1->hasOneUse()) { 113525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Or = Builder->CreateOr(Op0NotVal, Op1NotVal, 113625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner I.getName()+".demorgan"); 113725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateNot(Or); 113825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 113941a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 114025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner { 114125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *A = 0, *B = 0, *C = 0, *D = 0; 114225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (A|B) & ~(A&B) -> A^B 114325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (match(Op0, m_Or(m_Value(A), m_Value(B))) && 114425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(Op1, m_Not(m_And(m_Value(C), m_Value(D)))) && 114525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ((A == C && B == D) || (A == D && B == C))) 114625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateXor(A, B); 114741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 114825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ~(A&B) & (A|B) -> A^B 114925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (match(Op1, m_Or(m_Value(A), m_Value(B))) && 115025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(Op0, m_Not(m_And(m_Value(C), m_Value(D)))) && 115125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ((A == C && B == D) || (A == D && B == C))) 115225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateXor(A, B); 115341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 1154c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman // A&(A^B) => A & ~B 1155c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman { 1156c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman Value *tmpOp0 = Op0; 1157c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman Value *tmpOp1 = Op1; 1158c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman if (Op0->hasOneUse() && 1159c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman match(Op0, m_Xor(m_Value(A), m_Value(B)))) { 1160c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman if (A == Op1 || B == Op1 ) { 1161c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman tmpOp1 = Op0; 1162c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman tmpOp0 = Op1; 1163c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman // Simplify below 1164c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman } 116525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 116625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 1167c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman if (tmpOp1->hasOneUse() && 1168c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman match(tmpOp1, m_Xor(m_Value(A), m_Value(B)))) { 1169c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman if (B == tmpOp0) { 1170c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman std::swap(A, B); 1171c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman } 1172c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman // Notice that the patten (A&(~B)) is actually (A&(-1^B)), so if 1173c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman // A is originally -1 (or a vector of -1 and undefs), then we enter 1174c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman // an endless loop. By checking that A is non-constant we ensure that 1175c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman // we will never get to the loop. 1176c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman if (A == tmpOp0 && !isa<Constant>(A)) // A&(A^B) -> A & ~B 1177a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer return BinaryOperator::CreateAnd(A, Builder->CreateNot(B)); 117825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 117925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 118025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 118125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (A&((~A)|B)) -> A&B 118225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (match(Op0, m_Or(m_Not(m_Specific(Op1)), m_Value(A))) || 118325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(Op0, m_Or(m_Value(A), m_Not(m_Specific(Op1))))) 118425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateAnd(A, Op1); 118525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (match(Op1, m_Or(m_Not(m_Specific(Op0)), m_Value(A))) || 118625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(Op1, m_Or(m_Value(A), m_Not(m_Specific(Op0))))) 118725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateAnd(A, Op0); 118825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 118941a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 119025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ICmpInst *RHS = dyn_cast<ICmpInst>(Op1)) 119125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ICmpInst *LHS = dyn_cast<ICmpInst>(Op0)) 1192f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner if (Value *Res = FoldAndOfICmps(LHS, RHS)) 1193f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return ReplaceInstUsesWith(I, Res); 119441a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 11958c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner // If and'ing two fcmp, try combine them into one. 11968c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner if (FCmpInst *LHS = dyn_cast<FCmpInst>(I.getOperand(0))) 11978c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner if (FCmpInst *RHS = dyn_cast<FCmpInst>(I.getOperand(1))) 1198f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner if (Value *Res = FoldAndOfFCmps(LHS, RHS)) 1199f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return ReplaceInstUsesWith(I, Res); 120041a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 120141a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 120225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // fold (and (cast A), (cast B)) -> (cast (and A, B)) 120325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (CastInst *Op0C = dyn_cast<CastInst>(Op0)) 12048c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner if (CastInst *Op1C = dyn_cast<CastInst>(Op1)) { 1205db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *SrcTy = Op0C->getOperand(0)->getType(); 12068c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner if (Op0C->getOpcode() == Op1C->getOpcode() && // same cast kind ? 12078c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner SrcTy == Op1C->getOperand(0)->getType() && 1208b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands SrcTy->isIntOrIntVectorTy()) { 12098c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner Value *Op0COp = Op0C->getOperand(0), *Op1COp = Op1C->getOperand(0); 121041a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 12118c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner // Only do this if the casts both really cause code to be generated. 12128c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner if (ShouldOptimizeCast(Op0C->getOpcode(), Op0COp, I.getType()) && 12138c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner ShouldOptimizeCast(Op1C->getOpcode(), Op1COp, I.getType())) { 12148c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner Value *NewOp = Builder->CreateAnd(Op0COp, Op1COp, I.getName()); 121525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return CastInst::Create(Op0C->getOpcode(), NewOp, I.getType()); 121625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 121741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 12188c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner // If this is and(cast(icmp), cast(icmp)), try to fold this even if the 12198c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner // cast is otherwise not optimizable. This happens for vector sexts. 12208c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner if (ICmpInst *RHS = dyn_cast<ICmpInst>(Op1COp)) 12218c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner if (ICmpInst *LHS = dyn_cast<ICmpInst>(Op0COp)) 1222f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner if (Value *Res = FoldAndOfICmps(LHS, RHS)) 12238c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner return CastInst::Create(Op0C->getOpcode(), Res, I.getType()); 122441a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 12258c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner // If this is and(cast(fcmp), cast(fcmp)), try to fold this even if the 12268c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner // cast is otherwise not optimizable. This happens for vector sexts. 12278c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner if (FCmpInst *RHS = dyn_cast<FCmpInst>(Op1COp)) 12288c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner if (FCmpInst *LHS = dyn_cast<FCmpInst>(Op0COp)) 1229f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner if (Value *Res = FoldAndOfFCmps(LHS, RHS)) 12308c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner return CastInst::Create(Op0C->getOpcode(), Res, I.getType()); 123125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 12328c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner } 123341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 123425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (X >> Z) & (Y >> Z) -> (X&Y) >> Z for all shifts. 123525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (BinaryOperator *SI1 = dyn_cast<BinaryOperator>(Op1)) { 123625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (BinaryOperator *SI0 = dyn_cast<BinaryOperator>(Op0)) 123741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper if (SI0->isShift() && SI0->getOpcode() == SI1->getOpcode() && 123825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner SI0->getOperand(1) == SI1->getOperand(1) && 123925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner (SI0->hasOneUse() || SI1->hasOneUse())) { 124025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NewOp = 124125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Builder->CreateAnd(SI0->getOperand(0), SI1->getOperand(0), 124225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner SI0->getName()); 124341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper return BinaryOperator::Create(SI1->getOpcode(), NewOp, 124425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner SI1->getOperand(1)); 124525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 124625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 124725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 1248cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem { 1249cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem Value *X = 0; 1250cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem bool OpsSwapped = false; 1251cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem // Canonicalize SExt or Not to the LHS 1252cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem if (match(Op1, m_SExt(m_Value())) || 1253cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem match(Op1, m_Not(m_Value()))) { 1254cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem std::swap(Op0, Op1); 1255cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem OpsSwapped = true; 1256cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem } 1257cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem 1258cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem // Fold (and (sext bool to A), B) --> (select bool, B, 0) 1259cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem if (match(Op0, m_SExt(m_Value(X))) && 1260cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem X->getType()->getScalarType()->isIntegerTy(1)) { 1261cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem Value *Zero = Constant::getNullValue(Op1->getType()); 1262cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem return SelectInst::Create(X, Op1, Zero); 1263cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem } 1264cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem 1265cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem // Fold (and ~(sext bool to A), B) --> (select bool, 0, B) 1266cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem if (match(Op0, m_Not(m_SExt(m_Value(X)))) && 1267cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem X->getType()->getScalarType()->isIntegerTy(1)) { 1268cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem Value *Zero = Constant::getNullValue(Op0->getType()); 1269cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem return SelectInst::Create(X, Zero, Op1); 1270cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem } 1271cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem 1272cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem if (OpsSwapped) 1273cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem std::swap(Op0, Op1); 1274cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem } 1275cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem 127625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return Changed ? &I : 0; 127725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 127825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 127925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// CollectBSwapParts - Analyze the specified subexpression and see if it is 128025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// capable of providing pieces of a bswap. The subexpression provides pieces 128125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// of a bswap if it is proven that each of the non-zero bytes in the output of 128225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// the expression came from the corresponding "byte swapped" byte in some other 128325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// value. For example, if the current subexpression is "(shl i32 %X, 24)" then 128425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// we know that the expression deposits the low byte of %X into the high byte 128525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// of the bswap result and that all other bytes are zero. This expression is 128625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// accepted, the high byte of ByteValues is set to X to indicate a correct 128725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// match. 128825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// 128925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// This function returns true if the match was unsuccessful and false if so. 129025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// On entry to the function the "OverallLeftShift" is a signed integer value 129125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// indicating the number of bytes that the subexpression is later shifted. For 129225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// example, if the expression is later right shifted by 16 bits, the 129325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// OverallLeftShift value would be -2 on entry. This is used to specify which 129425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// byte of ByteValues is actually being set. 129525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// 129625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// Similarly, ByteMask is a bitmask where a bit is clear if its corresponding 129725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// byte is masked to zero by a user. For example, in (X & 255), X will be 129825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// processed with a bytemask of 1. Because bytemask is 32-bits, this limits 129925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// this function to working on up to 32-byte (256 bit) values. ByteMask is 130025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// always in the local (OverallLeftShift) coordinate space. 130125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// 130225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattnerstatic bool CollectBSwapParts(Value *V, int OverallLeftShift, uint32_t ByteMask, 130325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner SmallVector<Value*, 8> &ByteValues) { 130425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Instruction *I = dyn_cast<Instruction>(V)) { 130525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If this is an or instruction, it may be an inner node of the bswap. 130625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (I->getOpcode() == Instruction::Or) { 130725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return CollectBSwapParts(I->getOperand(0), OverallLeftShift, ByteMask, 130825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ByteValues) || 130925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner CollectBSwapParts(I->getOperand(1), OverallLeftShift, ByteMask, 131025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ByteValues); 131125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 131241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 131325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If this is a logical shift by a constant multiple of 8, recurse with 131425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // OverallLeftShift and ByteMask adjusted. 131525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (I->isLogicalShift() && isa<ConstantInt>(I->getOperand(1))) { 131641a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper unsigned ShAmt = 131725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner cast<ConstantInt>(I->getOperand(1))->getLimitedValue(~0U); 131825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Ensure the shift amount is defined and of a byte value. 131925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if ((ShAmt & 7) || (ShAmt > 8*ByteValues.size())) 132025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return true; 132125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 132225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner unsigned ByteShift = ShAmt >> 3; 132325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (I->getOpcode() == Instruction::Shl) { 132425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // X << 2 -> collect(X, +2) 132525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner OverallLeftShift += ByteShift; 132625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ByteMask >>= ByteShift; 132725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } else { 132825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // X >>u 2 -> collect(X, -2) 132925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner OverallLeftShift -= ByteShift; 133025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ByteMask <<= ByteShift; 133125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ByteMask &= (~0U >> (32-ByteValues.size())); 133225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 133325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 133425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (OverallLeftShift >= (int)ByteValues.size()) return true; 133525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (OverallLeftShift <= -(int)ByteValues.size()) return true; 133625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 133741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper return CollectBSwapParts(I->getOperand(0), OverallLeftShift, ByteMask, 133825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ByteValues); 133925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 134025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 134125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If this is a logical 'and' with a mask that clears bytes, clear the 134225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // corresponding bytes in ByteMask. 134325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (I->getOpcode() == Instruction::And && 134425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner isa<ConstantInt>(I->getOperand(1))) { 134525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Scan every byte of the and mask, seeing if the byte is either 0 or 255. 134625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner unsigned NumBytes = ByteValues.size(); 134725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner APInt Byte(I->getType()->getPrimitiveSizeInBits(), 255); 134825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner const APInt &AndMask = cast<ConstantInt>(I->getOperand(1))->getValue(); 134941a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 135025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner for (unsigned i = 0; i != NumBytes; ++i, Byte <<= 8) { 135125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If this byte is masked out by a later operation, we don't care what 135225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // the and mask is. 135325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if ((ByteMask & (1 << i)) == 0) 135425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner continue; 135541a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 135625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If the AndMask is all zeros for this byte, clear the bit. 135725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner APInt MaskB = AndMask & Byte; 135825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (MaskB == 0) { 135925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ByteMask &= ~(1U << i); 136025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner continue; 136125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 136241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 136325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If the AndMask is not all ones for this byte, it's not a bytezap. 136425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (MaskB != Byte) 136525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return true; 136625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 136725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Otherwise, this byte is kept. 136825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 136925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 137041a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper return CollectBSwapParts(I->getOperand(0), OverallLeftShift, ByteMask, 137125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ByteValues); 137225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 137325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 137441a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 137525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Okay, we got to something that isn't a shift, 'or' or 'and'. This must be 137625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // the input value to the bswap. Some observations: 1) if more than one byte 137725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // is demanded from this input, then it could not be successfully assembled 137825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // into a byteswap. At least one of the two bytes would not be aligned with 137925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // their ultimate destination. 138025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (!isPowerOf2_32(ByteMask)) return true; 138125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner unsigned InputByteNo = CountTrailingZeros_32(ByteMask); 138241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 138325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // 2) The input and ultimate destinations must line up: if byte 3 of an i32 138425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // is demanded, it needs to go into byte 0 of the result. This means that the 138525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // byte needs to be shifted until it lands in the right byte bucket. The 138625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // shift amount depends on the position: if the byte is coming from the high 138725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // part of the value (e.g. byte 3) then it must be shifted right. If from the 138825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // low part, it must be shifted left. 138925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner unsigned DestByteNo = InputByteNo + OverallLeftShift; 1390de813b7108de64829ab006e6b998a7b38d119eccChris Lattner if (ByteValues.size()-1-DestByteNo != InputByteNo) 1391de813b7108de64829ab006e6b998a7b38d119eccChris Lattner return true; 139241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 139325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If the destination byte value is already defined, the values are or'd 139425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // together, which isn't a bswap (unless it's an or of the same bits). 139525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ByteValues[DestByteNo] && ByteValues[DestByteNo] != V) 139625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return true; 139725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ByteValues[DestByteNo] = V; 139825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return false; 139925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 140025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 140125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// MatchBSwap - Given an OR instruction, check to see if this is a bswap idiom. 140225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// If so, insert the new bswap intrinsic and return it. 140325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris LattnerInstruction *InstCombiner::MatchBSwap(BinaryOperator &I) { 14045fdd6c8793462549e3593890ec61573da06e3346Jay Foad IntegerType *ITy = dyn_cast<IntegerType>(I.getType()); 140541a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper if (!ITy || ITy->getBitWidth() % 16 || 140625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ByteMask only allows up to 32-byte values. 140741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper ITy->getBitWidth() > 32*8) 140825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return 0; // Can only bswap pairs of bytes. Can't do vectors. 140941a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 141025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner /// ByteValues - For each byte of the result, we keep track of which value 141125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner /// defines each byte. 141225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner SmallVector<Value*, 8> ByteValues; 141325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ByteValues.resize(ITy->getBitWidth()/8); 141441a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 141525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Try to find all the pieces corresponding to the bswap. 141625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner uint32_t ByteMask = ~0U >> (32-ByteValues.size()); 141725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (CollectBSwapParts(&I, 0, ByteMask, ByteValues)) 141825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return 0; 141941a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 142025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Check to see if all of the bytes come from the same value. 142125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *V = ByteValues[0]; 142225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (V == 0) return 0; // Didn't find a byte? Must be zero. 142341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 142425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Check to make sure that all of the bytes come from the same value. 142525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner for (unsigned i = 1, e = ByteValues.size(); i != e; ++i) 142625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ByteValues[i] != V) 142725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return 0; 142825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Module *M = I.getParent()->getParent()->getParent(); 1429eb9a85f09e18b3fe88499710404b38d3a9128f62Benjamin Kramer Function *F = Intrinsic::getDeclaration(M, Intrinsic::bswap, ITy); 143025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return CallInst::Create(F, V); 143125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 143225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 143325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// MatchSelectFromAndOr - We have an expression of the form (A&C)|(B&D). Check 143425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// If A is (cond?-1:0) and either B or D is ~(cond?-1,0) or (cond?0,-1), then 143525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// we can simplify this expression to "cond ? C : D or B". 143625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattnerstatic Instruction *MatchSelectFromAndOr(Value *A, Value *B, 143725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *C, Value *D) { 143825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If A is not a select of -1/0, this cannot match. 143925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Cond = 0; 1440e538db4fb0ec30500da721a2a698946fa36db1a8Chris Lattner if (!match(A, m_SExt(m_Value(Cond))) || 1441b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands !Cond->getType()->isIntegerTy(1)) 144225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return 0; 144325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 144425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ((cond?-1:0)&C) | (B&(cond?0:-1)) -> cond ? C : B. 1445e576f292ee5f7af40489a68fa626d53a14e46a10Chris Lattner if (match(D, m_Not(m_SExt(m_Specific(Cond))))) 144625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return SelectInst::Create(Cond, C, B); 1447e576f292ee5f7af40489a68fa626d53a14e46a10Chris Lattner if (match(D, m_SExt(m_Not(m_Specific(Cond))))) 144874529826a70546d71c6558e9a3917244a87acfe9Chris Lattner return SelectInst::Create(Cond, C, B); 144941a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 145025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ((cond?-1:0)&C) | ((cond?0:-1)&D) -> cond ? C : D. 1451e576f292ee5f7af40489a68fa626d53a14e46a10Chris Lattner if (match(B, m_Not(m_SExt(m_Specific(Cond))))) 145274529826a70546d71c6558e9a3917244a87acfe9Chris Lattner return SelectInst::Create(Cond, C, D); 1453e576f292ee5f7af40489a68fa626d53a14e46a10Chris Lattner if (match(B, m_SExt(m_Not(m_Specific(Cond))))) 145425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return SelectInst::Create(Cond, C, D); 145525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return 0; 145625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 145725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 1458f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner/// FoldOrOfICmps - Fold (icmp)|(icmp) if possible. 1459f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris LattnerValue *InstCombiner::FoldOrOfICmps(ICmpInst *LHS, ICmpInst *RHS) { 146025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ICmpInst::Predicate LHSCC = LHS->getPredicate(), RHSCC = RHS->getPredicate(); 146125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 146225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (icmp1 A, B) | (icmp2 A, B) --> (icmp3 A, B) 146325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (PredicatesFoldable(LHSCC, RHSCC)) { 146425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHS->getOperand(0) == RHS->getOperand(1) && 146525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner LHS->getOperand(1) == RHS->getOperand(0)) 146625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner LHS->swapOperands(); 146725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHS->getOperand(0) == RHS->getOperand(0) && 146825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner LHS->getOperand(1) == RHS->getOperand(1)) { 146925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Op0 = LHS->getOperand(0), *Op1 = LHS->getOperand(1); 147025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner unsigned Code = getICmpCode(LHS) | getICmpCode(RHS); 147125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner bool isSigned = LHS->isSigned() || RHS->isSigned(); 14722e33944c101f2a08ed1d85e807830f2fc089dd06Pete Cooper return getNewICmpValue(isSigned, Code, Op0, Op1, Builder); 147325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 147425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 14754dc1ac094714a5866b9d32c6bbf2ecaa672fde48Benjamin Kramer 14764dc1ac094714a5866b9d32c6bbf2ecaa672fde48Benjamin Kramer // handle (roughly): 14774dc1ac094714a5866b9d32c6bbf2ecaa672fde48Benjamin Kramer // (icmp ne (A & B), C) | (icmp ne (A & D), E) 14784dc1ac094714a5866b9d32c6bbf2ecaa672fde48Benjamin Kramer if (Value *V = foldLogOpOfMaskedICmps(LHS, RHS, ICmpInst::ICMP_NE, Builder)) 14794dc1ac094714a5866b9d32c6bbf2ecaa672fde48Benjamin Kramer return V; 14805c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson 148125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // This only handles icmp of constants: (icmp1 A, C1) | (icmp2 B, C2). 148225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Val = LHS->getOperand(0), *Val2 = RHS->getOperand(0); 148325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt *LHSCst = dyn_cast<ConstantInt>(LHS->getOperand(1)); 148425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt *RHSCst = dyn_cast<ConstantInt>(RHS->getOperand(1)); 148525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHSCst == 0 || RHSCst == 0) return 0; 148625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 148761378363b76ad84dc7effff506d7c3e991225743Owen Anderson if (LHSCst == RHSCst && LHSCC == RHSCC) { 148861378363b76ad84dc7effff506d7c3e991225743Owen Anderson // (icmp ne A, 0) | (icmp ne B, 0) --> (icmp ne (A|B), 0) 148961378363b76ad84dc7effff506d7c3e991225743Owen Anderson if (LHSCC == ICmpInst::ICMP_NE && LHSCst->isZero()) { 149061378363b76ad84dc7effff506d7c3e991225743Owen Anderson Value *NewOr = Builder->CreateOr(Val, Val2); 149161378363b76ad84dc7effff506d7c3e991225743Owen Anderson return Builder->CreateICmp(LHSCC, NewOr, LHSCst); 149261378363b76ad84dc7effff506d7c3e991225743Owen Anderson } 1493dfb806f6ba53b792171b928b57def9d0182d2f5fBenjamin Kramer } 1494dfb806f6ba53b792171b928b57def9d0182d2f5fBenjamin Kramer 1495b0de244f23c2e11505cab729f198dfaaa2028532Benjamin Kramer // (icmp ult (X + CA), C1) | (icmp eq X, C2) -> (icmp ule (X + CA), C1) 149694c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // iff C2 + CA == C1. 1497b0de244f23c2e11505cab729f198dfaaa2028532Benjamin Kramer if (LHSCC == ICmpInst::ICMP_ULT && RHSCC == ICmpInst::ICMP_EQ) { 14985337f20c1516296edcea6bc3da6cdc74329142aeBenjamin Kramer ConstantInt *AddCst; 14995337f20c1516296edcea6bc3da6cdc74329142aeBenjamin Kramer if (match(Val, m_Add(m_Specific(Val2), m_ConstantInt(AddCst)))) 15005337f20c1516296edcea6bc3da6cdc74329142aeBenjamin Kramer if (RHSCst->getValue() + AddCst->getValue() == LHSCst->getValue()) 1501b0de244f23c2e11505cab729f198dfaaa2028532Benjamin Kramer return Builder->CreateICmpULE(Val, LHSCst); 15025337f20c1516296edcea6bc3da6cdc74329142aeBenjamin Kramer } 15035337f20c1516296edcea6bc3da6cdc74329142aeBenjamin Kramer 150425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // From here on, we only handle: 150525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (icmp1 A, C1) | (icmp2 A, C2) --> something simpler. 150625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Val != Val2) return 0; 150741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 150825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ICMP_[US][GL]E X, CST is folded to ICMP_[US][GL]T elsewhere. 150925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHSCC == ICmpInst::ICMP_UGE || LHSCC == ICmpInst::ICMP_ULE || 151025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner RHSCC == ICmpInst::ICMP_UGE || RHSCC == ICmpInst::ICMP_ULE || 151125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner LHSCC == ICmpInst::ICMP_SGE || LHSCC == ICmpInst::ICMP_SLE || 151225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner RHSCC == ICmpInst::ICMP_SGE || RHSCC == ICmpInst::ICMP_SLE) 151325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return 0; 151441a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 151525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // We can't fold (ugt x, C) | (sgt x, C2). 151625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (!PredicatesFoldable(LHSCC, RHSCC)) 151725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return 0; 151841a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 151925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Ensure that the larger constant is on the RHS. 152025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner bool ShouldSwap; 152125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (CmpInst::isSigned(LHSCC) || 152241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper (ICmpInst::isEquality(LHSCC) && 152325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner CmpInst::isSigned(RHSCC))) 152425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ShouldSwap = LHSCst->getValue().sgt(RHSCst->getValue()); 152525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner else 152625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ShouldSwap = LHSCst->getValue().ugt(RHSCst->getValue()); 152741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 152825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ShouldSwap) { 152925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(LHS, RHS); 153025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(LHSCst, RHSCst); 153125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(LHSCC, RHSCC); 153225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 153341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 1534f451cb870efcf9e0302d25ed05f4cac6bb494e42Dan Gohman // At this point, we know we have two icmp instructions 153525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // comparing a value against two constants and or'ing the result 153625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // together. Because of the above check, we know that we only have 153725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ICMP_EQ, ICMP_NE, ICMP_LT, and ICMP_GT here. We also know (from the 153825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // icmp folding check above), that the two constants are not 153925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // equal. 154025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner assert(LHSCst != RHSCst && "Compares not folded above?"); 154125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 154225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (LHSCC) { 154325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: llvm_unreachable("Unknown integer condition code!"); 154425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_EQ: 154525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (RHSCC) { 154625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: llvm_unreachable("Unknown integer condition code!"); 154725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_EQ: 154825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHSCst == SubOne(RHSCst)) { 154925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (X == 13 | X == 14) -> X-13 <u 2 155025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Constant *AddCST = ConstantExpr::getNeg(LHSCst); 155125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Add = Builder->CreateAdd(Val, AddCST, Val->getName()+".off"); 155225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner AddCST = ConstantExpr::getSub(AddOne(RHSCst), LHSCst); 1553f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateICmpULT(Add, AddCST); 155425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 1555d60b8ac64fa161646d50c49d6171cb49e6a2c7eeJakub Staszak 1556d60b8ac64fa161646d50c49d6171cb49e6a2c7eeJakub Staszak if (LHS->getOperand(0) == RHS->getOperand(0)) { 1557b6d9c4181a57a4b57d92a4437761387606f49c2dJakub Staszak // if LHSCst and RHSCst differ only by one bit: 1558d60b8ac64fa161646d50c49d6171cb49e6a2c7eeJakub Staszak // (A == C1 || A == C2) -> (A & ~(C1 ^ C2)) == C1 1559526057921dcb57e0d51d60ddb0f5ce16596c307fJakub Staszak assert(LHSCst->getValue().ule(LHSCst->getValue())); 1560526057921dcb57e0d51d60ddb0f5ce16596c307fJakub Staszak 1561d60b8ac64fa161646d50c49d6171cb49e6a2c7eeJakub Staszak APInt Xor = LHSCst->getValue() ^ RHSCst->getValue(); 1562d60b8ac64fa161646d50c49d6171cb49e6a2c7eeJakub Staszak if (Xor.isPowerOf2()) { 1563d60b8ac64fa161646d50c49d6171cb49e6a2c7eeJakub Staszak Value *NegCst = Builder->getInt(~Xor); 1564d60b8ac64fa161646d50c49d6171cb49e6a2c7eeJakub Staszak Value *And = Builder->CreateAnd(LHS->getOperand(0), NegCst); 1565d60b8ac64fa161646d50c49d6171cb49e6a2c7eeJakub Staszak return Builder->CreateICmp(ICmpInst::ICMP_EQ, And, LHSCst); 1566d60b8ac64fa161646d50c49d6171cb49e6a2c7eeJakub Staszak } 1567d60b8ac64fa161646d50c49d6171cb49e6a2c7eeJakub Staszak } 1568d60b8ac64fa161646d50c49d6171cb49e6a2c7eeJakub Staszak 156925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; // (X == 13 | X == 15) -> no change 157025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_UGT: // (X == 13 | X u> 14) -> no change 157125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SGT: // (X == 13 | X s> 14) -> no change 157225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 157325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_NE: // (X == 13 | X != 15) -> X != 15 157425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_ULT: // (X == 13 | X u< 15) -> X u< 15 157525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SLT: // (X == 13 | X s< 15) -> X s< 15 1576f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return RHS; 157725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 157825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 157925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_NE: 158025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (RHSCC) { 158125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: llvm_unreachable("Unknown integer condition code!"); 158225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_EQ: // (X != 13 | X == 15) -> X != 13 158325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_UGT: // (X != 13 | X u> 15) -> X != 13 158425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SGT: // (X != 13 | X s> 15) -> X != 13 1585f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return LHS; 158625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_NE: // (X != 13 | X != 15) -> true 158725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_ULT: // (X != 13 | X u< 15) -> true 158825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SLT: // (X != 13 | X s< 15) -> true 1589f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return ConstantInt::getTrue(LHS->getContext()); 159025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 159125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_ULT: 159225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (RHSCC) { 159325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: llvm_unreachable("Unknown integer condition code!"); 159425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_EQ: // (X u< 13 | X == 14) -> no change 159525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 159625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_UGT: // (X u< 13 | X u> 15) -> (X-13) u> 2 159725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If RHSCst is [us]MAXINT, it is always false. Not handling 159825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // this can cause overflow. 159925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (RHSCst->isMaxValue(false)) 1600f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return LHS; 1601f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return InsertRangeTest(Val, LHSCst, AddOne(RHSCst), false, false); 160225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SGT: // (X u< 13 | X s> 15) -> no change 160325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 160425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_NE: // (X u< 13 | X != 15) -> X != 15 160525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_ULT: // (X u< 13 | X u< 15) -> X u< 15 1606f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return RHS; 160725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SLT: // (X u< 13 | X s< 15) -> no change 160825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 160925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 161025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 161125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SLT: 161225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (RHSCC) { 161325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: llvm_unreachable("Unknown integer condition code!"); 161425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_EQ: // (X s< 13 | X == 14) -> no change 161525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 161625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SGT: // (X s< 13 | X s> 15) -> (X-13) s> 2 161725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If RHSCst is [us]MAXINT, it is always false. Not handling 161825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // this can cause overflow. 161925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (RHSCst->isMaxValue(true)) 1620f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return LHS; 1621f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return InsertRangeTest(Val, LHSCst, AddOne(RHSCst), true, false); 162225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_UGT: // (X s< 13 | X u> 15) -> no change 162325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 162425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_NE: // (X s< 13 | X != 15) -> X != 15 162525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SLT: // (X s< 13 | X s< 15) -> X s< 15 1626f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return RHS; 162725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_ULT: // (X s< 13 | X u< 15) -> no change 162825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 162925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 163025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 163125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_UGT: 163225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (RHSCC) { 163325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: llvm_unreachable("Unknown integer condition code!"); 163425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_EQ: // (X u> 13 | X == 15) -> X u> 13 163525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_UGT: // (X u> 13 | X u> 15) -> X u> 13 1636f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return LHS; 163725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SGT: // (X u> 13 | X s> 15) -> no change 163825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 163925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_NE: // (X u> 13 | X != 15) -> true 164025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_ULT: // (X u> 13 | X u< 15) -> true 1641f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return ConstantInt::getTrue(LHS->getContext()); 164225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SLT: // (X u> 13 | X s< 15) -> no change 164325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 164425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 164525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 164625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SGT: 164725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (RHSCC) { 164825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: llvm_unreachable("Unknown integer condition code!"); 164925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_EQ: // (X s> 13 | X == 15) -> X > 13 165025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SGT: // (X s> 13 | X s> 15) -> X > 13 1651f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return LHS; 165225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_UGT: // (X s> 13 | X u> 15) -> no change 165325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 165425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_NE: // (X s> 13 | X != 15) -> true 165525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SLT: // (X s> 13 | X s< 15) -> true 1656f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return ConstantInt::getTrue(LHS->getContext()); 165725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_ULT: // (X s> 13 | X u< 15) -> no change 165825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 165925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 166025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 166125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 166225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return 0; 166325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 166425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 1665f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner/// FoldOrOfFCmps - Optimize (fcmp)|(fcmp). NOTE: Unlike the rest of 1666f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner/// instcombine, this returns a Value which should already be inserted into the 1667f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner/// function. 1668f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris LattnerValue *InstCombiner::FoldOrOfFCmps(FCmpInst *LHS, FCmpInst *RHS) { 166925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHS->getPredicate() == FCmpInst::FCMP_UNO && 167041a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper RHS->getPredicate() == FCmpInst::FCMP_UNO && 167125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner LHS->getOperand(0)->getType() == RHS->getOperand(0)->getType()) { 167225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ConstantFP *LHSC = dyn_cast<ConstantFP>(LHS->getOperand(1))) 167325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ConstantFP *RHSC = dyn_cast<ConstantFP>(RHS->getOperand(1))) { 167425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If either of the constants are nans, then the whole thing returns 167525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // true. 167625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHSC->getValueAPF().isNaN() || RHSC->getValueAPF().isNaN()) 1677f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return ConstantInt::getTrue(LHS->getContext()); 167841a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 167925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Otherwise, no need to compare the two constants, compare the 168025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // rest. 1681f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateFCmpUNO(LHS->getOperand(0), RHS->getOperand(0)); 168225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 168341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 168425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Handle vector zeros. This occurs because the canonical form of 168525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // "fcmp uno x,x" is "fcmp uno x, 0". 168625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (isa<ConstantAggregateZero>(LHS->getOperand(1)) && 168725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner isa<ConstantAggregateZero>(RHS->getOperand(1))) 1688f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateFCmpUNO(LHS->getOperand(0), RHS->getOperand(0)); 168941a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 169025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return 0; 169125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 169241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 169325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Op0LHS = LHS->getOperand(0), *Op0RHS = LHS->getOperand(1); 169425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Op1LHS = RHS->getOperand(0), *Op1RHS = RHS->getOperand(1); 169525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner FCmpInst::Predicate Op0CC = LHS->getPredicate(), Op1CC = RHS->getPredicate(); 169641a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 169725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0LHS == Op1RHS && Op0RHS == Op1LHS) { 169825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Swap RHS operands to match LHS. 169925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op1CC = FCmpInst::getSwappedPredicate(Op1CC); 170025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(Op1LHS, Op1RHS); 170125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 170225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0LHS == Op1LHS && Op0RHS == Op1RHS) { 170325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Simplify (fcmp cc0 x, y) | (fcmp cc1 x, y). 170425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0CC == Op1CC) 1705f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateFCmp((FCmpInst::Predicate)Op0CC, Op0LHS, Op0RHS); 170625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0CC == FCmpInst::FCMP_TRUE || Op1CC == FCmpInst::FCMP_TRUE) 1707f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return ConstantInt::get(CmpInst::makeCmpResultType(LHS->getType()), 1); 170825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0CC == FCmpInst::FCMP_FALSE) 1709f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return RHS; 171025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op1CC == FCmpInst::FCMP_FALSE) 1711f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return LHS; 171225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner bool Op0Ordered; 171325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner bool Op1Ordered; 171425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner unsigned Op0Pred = getFCmpCode(Op0CC, Op0Ordered); 171525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner unsigned Op1Pred = getFCmpCode(Op1CC, Op1Ordered); 171625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0Ordered == Op1Ordered) { 171725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If both are ordered or unordered, return a new fcmp with 171825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // or'ed predicates. 1719f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return getFCmpValue(Op0Ordered, Op0Pred|Op1Pred, Op0LHS, Op0RHS, Builder); 172025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 172125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 172225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return 0; 172325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 172425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 172525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// FoldOrWithConstants - This helper function folds: 172625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// 172725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// ((A | B) & C1) | (B & C2) 172825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// 172925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// into: 173041a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper/// 173125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// (A & C1) | B 173225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// 173325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// when the XOR of the two constants is "all ones" (-1). 173425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris LattnerInstruction *InstCombiner::FoldOrWithConstants(BinaryOperator &I, Value *Op, 173525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *A, Value *B, Value *C) { 173625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt *CI1 = dyn_cast<ConstantInt>(C); 173725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (!CI1) return 0; 173825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 173925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *V1 = 0; 174025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt *CI2 = 0; 174125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (!match(Op, m_And(m_Value(V1), m_ConstantInt(CI2)))) return 0; 174225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 174325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner APInt Xor = CI1->getValue() ^ CI2->getValue(); 174425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (!Xor.isAllOnesValue()) return 0; 174525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 174625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (V1 == A || V1 == B) { 174725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NewOp = Builder->CreateAnd((V1 == A) ? B : A, CI1); 174825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateOr(NewOp, V1); 174925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 175025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 175125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return 0; 175225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 175325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 175425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris LattnerInstruction *InstCombiner::visitOr(BinaryOperator &I) { 1755096aa79276b8527a3cbbb3691e40e729dea09523Duncan Sands bool Changed = SimplifyAssociativeOrCommutative(I); 175625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1); 175725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 175825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Value *V = SimplifyOrInst(Op0, Op1, TD)) 175925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return ReplaceInstUsesWith(I, V); 17607d9f2b93a356aa89186522bd61c5c565718ff555Bill Wendling 176137bf92b5238434b00fde79347ba5336e7554e562Duncan Sands // (A&B)|(A&C) -> A&(B|C) etc 176237bf92b5238434b00fde79347ba5336e7554e562Duncan Sands if (Value *V = SimplifyUsingDistributiveLaws(I)) 176337bf92b5238434b00fde79347ba5336e7554e562Duncan Sands return ReplaceInstUsesWith(I, V); 17645057f381418ddc8c96699c40479ead993cd62e7bDuncan Sands 176541a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper // See if we can simplify any instructions used by the instruction whose sole 176625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // purpose is to compute bits we don't care about. 176725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (SimplifyDemandedInstructionBits(I)) 176825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return &I; 176925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 177025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ConstantInt *RHS = dyn_cast<ConstantInt>(Op1)) { 177125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt *C1 = 0; Value *X = 0; 177225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (X & C1) | C2 --> (X | C2) & (C1|C2) 177394c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // iff (C1 & C2) == 0. 177425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (match(Op0, m_And(m_Value(X), m_ConstantInt(C1))) && 17757d9f2b93a356aa89186522bd61c5c565718ff555Bill Wendling (RHS->getValue() & C1->getValue()) != 0 && 177625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op0->hasOneUse()) { 177725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Or = Builder->CreateOr(X, RHS); 177825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Or->takeName(Op0); 177941a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper return BinaryOperator::CreateAnd(Or, 178025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt::get(I.getContext(), 178125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner RHS->getValue() | C1->getValue())); 178225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 178325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 178425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (X ^ C1) | C2 --> (X | C2) ^ (C1&~C2) 178525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (match(Op0, m_Xor(m_Value(X), m_ConstantInt(C1))) && 178625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op0->hasOneUse()) { 178725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Or = Builder->CreateOr(X, RHS); 178825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Or->takeName(Op0); 178925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateXor(Or, 179025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt::get(I.getContext(), 179125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner C1->getValue() & ~RHS->getValue())); 179225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 179325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 179425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Try to fold constant and into select arguments. 179525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (SelectInst *SI = dyn_cast<SelectInst>(Op0)) 179625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Instruction *R = FoldOpIntoSelect(I, SI)) 179725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return R; 17987d9f2b93a356aa89186522bd61c5c565718ff555Bill Wendling 179925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (isa<PHINode>(Op0)) 180025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Instruction *NV = FoldOpIntoPhi(I)) 180125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return NV; 180225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 180325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 180425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *A = 0, *B = 0; 180525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt *C1 = 0, *C2 = 0; 180625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 180725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (A | B) | C and A | (B | C) -> bswap if possible. 180825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (A >> B) | (C << D) and (A << B) | (B >> C) -> bswap if possible. 180925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (match(Op0, m_Or(m_Value(), m_Value())) || 181025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(Op1, m_Or(m_Value(), m_Value())) || 1811aeaf3d484b4d4c35e8794378c4b6cfbbde718dd1Chris Lattner (match(Op0, m_LogicalShift(m_Value(), m_Value())) && 1812aeaf3d484b4d4c35e8794378c4b6cfbbde718dd1Chris Lattner match(Op1, m_LogicalShift(m_Value(), m_Value())))) { 181325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Instruction *BSwap = MatchBSwap(I)) 181425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BSwap; 181525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 181641a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 181794c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // (X^C)|Y -> (X|Y)^C iff Y&C == 0 181825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0->hasOneUse() && 181925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(Op0, m_Xor(m_Value(A), m_ConstantInt(C1))) && 182025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner MaskedValueIsZero(Op1, C1->getValue())) { 182125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NOr = Builder->CreateOr(A, Op1); 182225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner NOr->takeName(Op0); 182325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateXor(NOr, C1); 182425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 182525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 182694c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // Y|(X^C) -> (X|Y)^C iff Y&C == 0 182725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op1->hasOneUse() && 182825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(Op1, m_Xor(m_Value(A), m_ConstantInt(C1))) && 182925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner MaskedValueIsZero(Op0, C1->getValue())) { 183025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NOr = Builder->CreateOr(A, Op0); 183125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner NOr->takeName(Op0); 183225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateXor(NOr, C1); 183325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 183425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 183525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (A & C)|(B & D) 183625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *C = 0, *D = 0; 183725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (match(Op0, m_And(m_Value(A), m_Value(C))) && 183825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(Op1, m_And(m_Value(B), m_Value(D)))) { 18395057f381418ddc8c96699c40479ead993cd62e7bDuncan Sands Value *V1 = 0, *V2 = 0; 184025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner C1 = dyn_cast<ConstantInt>(C); 184125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner C2 = dyn_cast<ConstantInt>(D); 184225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (C1 && C2) { // (A & C1)|(B & C2) 184325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If we have: ((V + N) & C1) | (V & C2) 184425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // .. and C2 = ~C1 and C2 is 0+1+ and (N & C2) == 0 184525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // replace with V+N. 184625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (C1->getValue() == ~C2->getValue()) { 184725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if ((C2->getValue() & (C2->getValue()+1)) == 0 && // C2 == 0+1+ 184825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(A, m_Add(m_Value(V1), m_Value(V2)))) { 184925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Add commutes, try both ways. 185025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (V1 == B && MaskedValueIsZero(V2, C2->getValue())) 185125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return ReplaceInstUsesWith(I, A); 185225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (V2 == B && MaskedValueIsZero(V1, C2->getValue())) 185325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return ReplaceInstUsesWith(I, A); 185425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 185525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Or commutes, try both ways. 185625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if ((C1->getValue() & (C1->getValue()+1)) == 0 && 185725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(B, m_Add(m_Value(V1), m_Value(V2)))) { 185825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Add commutes, try both ways. 185925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (V1 == A && MaskedValueIsZero(V2, C1->getValue())) 186025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return ReplaceInstUsesWith(I, B); 186125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (V2 == A && MaskedValueIsZero(V1, C1->getValue())) 186225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return ReplaceInstUsesWith(I, B); 186325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 186425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 186541a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 186625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if ((C1->getValue() & C2->getValue()) == 0) { 18678e76764de86d7906db5123626b65f593e159d9f3Chris Lattner // ((V | N) & C1) | (V & C2) --> (V|N) & (C1|C2) 186894c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // iff (C1&C2) == 0 and (N&~C1) == 0 186925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (match(A, m_Or(m_Value(V1), m_Value(V2))) && 187025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ((V1 == B && MaskedValueIsZero(V2, ~C1->getValue())) || // (V|N) 187125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner (V2 == B && MaskedValueIsZero(V1, ~C1->getValue())))) // (N|V) 187225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateAnd(A, 187325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt::get(A->getContext(), 187425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner C1->getValue()|C2->getValue())); 187525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Or commutes, try both ways. 187625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (match(B, m_Or(m_Value(V1), m_Value(V2))) && 187725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ((V1 == A && MaskedValueIsZero(V2, ~C2->getValue())) || // (V|N) 187825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner (V2 == A && MaskedValueIsZero(V1, ~C2->getValue())))) // (N|V) 187925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateAnd(B, 188025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt::get(B->getContext(), 188125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner C1->getValue()|C2->getValue())); 188241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 18838e76764de86d7906db5123626b65f593e159d9f3Chris Lattner // ((V|C3)&C1) | ((V|C4)&C2) --> (V|C3|C4)&(C1|C2) 188494c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // iff (C1&C2) == 0 and (C3&~C1) == 0 and (C4&~C2) == 0. 18858e76764de86d7906db5123626b65f593e159d9f3Chris Lattner ConstantInt *C3 = 0, *C4 = 0; 18868e76764de86d7906db5123626b65f593e159d9f3Chris Lattner if (match(A, m_Or(m_Value(V1), m_ConstantInt(C3))) && 18878e76764de86d7906db5123626b65f593e159d9f3Chris Lattner (C3->getValue() & ~C1->getValue()) == 0 && 18888e76764de86d7906db5123626b65f593e159d9f3Chris Lattner match(B, m_Or(m_Specific(V1), m_ConstantInt(C4))) && 18898e76764de86d7906db5123626b65f593e159d9f3Chris Lattner (C4->getValue() & ~C2->getValue()) == 0) { 18908e76764de86d7906db5123626b65f593e159d9f3Chris Lattner V2 = Builder->CreateOr(V1, ConstantExpr::getOr(C3, C4), "bitfield"); 18918e76764de86d7906db5123626b65f593e159d9f3Chris Lattner return BinaryOperator::CreateAnd(V2, 18928e76764de86d7906db5123626b65f593e159d9f3Chris Lattner ConstantInt::get(B->getContext(), 18938e76764de86d7906db5123626b65f593e159d9f3Chris Lattner C1->getValue()|C2->getValue())); 18948e76764de86d7906db5123626b65f593e159d9f3Chris Lattner } 189525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 189625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 189725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 189839ceb471b7ebaf0ebef09f7916419ae2e0f30accChris Lattner // (A & (C0?-1:0)) | (B & ~(C0?-1:0)) -> C0 ? A : B, and commuted variants. 189939ceb471b7ebaf0ebef09f7916419ae2e0f30accChris Lattner // Don't do this for vector select idioms, the code generator doesn't handle 190039ceb471b7ebaf0ebef09f7916419ae2e0f30accChris Lattner // them well yet. 19011df9859c40492511b8aa4321eb76496005d3b75bDuncan Sands if (!I.getType()->isVectorTy()) { 190239ceb471b7ebaf0ebef09f7916419ae2e0f30accChris Lattner if (Instruction *Match = MatchSelectFromAndOr(A, B, C, D)) 190339ceb471b7ebaf0ebef09f7916419ae2e0f30accChris Lattner return Match; 190439ceb471b7ebaf0ebef09f7916419ae2e0f30accChris Lattner if (Instruction *Match = MatchSelectFromAndOr(B, A, D, C)) 190539ceb471b7ebaf0ebef09f7916419ae2e0f30accChris Lattner return Match; 190639ceb471b7ebaf0ebef09f7916419ae2e0f30accChris Lattner if (Instruction *Match = MatchSelectFromAndOr(C, B, A, D)) 190739ceb471b7ebaf0ebef09f7916419ae2e0f30accChris Lattner return Match; 190839ceb471b7ebaf0ebef09f7916419ae2e0f30accChris Lattner if (Instruction *Match = MatchSelectFromAndOr(D, A, B, C)) 190939ceb471b7ebaf0ebef09f7916419ae2e0f30accChris Lattner return Match; 191039ceb471b7ebaf0ebef09f7916419ae2e0f30accChris Lattner } 191125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 191225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ((A&~B)|(~A&B)) -> A^B 191325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if ((match(C, m_Not(m_Specific(D))) && 191425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(B, m_Not(m_Specific(A))))) 191525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateXor(A, D); 191625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ((~B&A)|(~A&B)) -> A^B 191725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if ((match(A, m_Not(m_Specific(D))) && 191825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(B, m_Not(m_Specific(C))))) 191925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateXor(C, D); 192025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ((A&~B)|(B&~A)) -> A^B 192125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if ((match(C, m_Not(m_Specific(B))) && 192225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(D, m_Not(m_Specific(A))))) 192325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateXor(A, B); 192425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ((~B&A)|(B&~A)) -> A^B 192525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if ((match(A, m_Not(m_Specific(B))) && 192625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(D, m_Not(m_Specific(C))))) 192725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateXor(C, B); 1928ad854f0764e6a386b0dc49a2640766b8e9ae0b61Benjamin Kramer 1929ad854f0764e6a386b0dc49a2640766b8e9ae0b61Benjamin Kramer // ((A|B)&1)|(B&-2) -> (A&1) | B 1930ad854f0764e6a386b0dc49a2640766b8e9ae0b61Benjamin Kramer if (match(A, m_Or(m_Value(V1), m_Specific(B))) || 1931ad854f0764e6a386b0dc49a2640766b8e9ae0b61Benjamin Kramer match(A, m_Or(m_Specific(B), m_Value(V1)))) { 1932ad854f0764e6a386b0dc49a2640766b8e9ae0b61Benjamin Kramer Instruction *Ret = FoldOrWithConstants(I, Op1, V1, B, C); 1933ad854f0764e6a386b0dc49a2640766b8e9ae0b61Benjamin Kramer if (Ret) return Ret; 1934ad854f0764e6a386b0dc49a2640766b8e9ae0b61Benjamin Kramer } 1935ad854f0764e6a386b0dc49a2640766b8e9ae0b61Benjamin Kramer // (B&-2)|((A|B)&1) -> (A&1) | B 1936ad854f0764e6a386b0dc49a2640766b8e9ae0b61Benjamin Kramer if (match(B, m_Or(m_Specific(A), m_Value(V1))) || 1937ad854f0764e6a386b0dc49a2640766b8e9ae0b61Benjamin Kramer match(B, m_Or(m_Value(V1), m_Specific(A)))) { 1938ad854f0764e6a386b0dc49a2640766b8e9ae0b61Benjamin Kramer Instruction *Ret = FoldOrWithConstants(I, Op0, A, V1, D); 1939ad854f0764e6a386b0dc49a2640766b8e9ae0b61Benjamin Kramer if (Ret) return Ret; 1940ad854f0764e6a386b0dc49a2640766b8e9ae0b61Benjamin Kramer } 194125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 194241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 194325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (X >> Z) | (Y >> Z) -> (X|Y) >> Z for all shifts. 194425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (BinaryOperator *SI1 = dyn_cast<BinaryOperator>(Op1)) { 194525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (BinaryOperator *SI0 = dyn_cast<BinaryOperator>(Op0)) 194641a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper if (SI0->isShift() && SI0->getOpcode() == SI1->getOpcode() && 194725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner SI0->getOperand(1) == SI1->getOperand(1) && 194825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner (SI0->hasOneUse() || SI1->hasOneUse())) { 194925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NewOp = Builder->CreateOr(SI0->getOperand(0), SI1->getOperand(0), 195025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner SI0->getName()); 195141a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper return BinaryOperator::Create(SI1->getOpcode(), NewOp, 195225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner SI1->getOperand(1)); 195325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 195425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 195525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 195625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (~A | ~B) == (~(A & B)) - De Morgan's Law 195725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Value *Op0NotVal = dyn_castNotVal(Op0)) 195825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Value *Op1NotVal = dyn_castNotVal(Op1)) 195925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0->hasOneUse() && Op1->hasOneUse()) { 196025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *And = Builder->CreateAnd(Op0NotVal, Op1NotVal, 196125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner I.getName()+".demorgan"); 196225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateNot(And); 196325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 196425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 196591e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer // Canonicalize xor to the RHS. 1966e9f15c8a563a745c5cafa7c98b1f12de2dcab070Eli Friedman bool SwappedForXor = false; 1967e9f15c8a563a745c5cafa7c98b1f12de2dcab070Eli Friedman if (match(Op0, m_Xor(m_Value(), m_Value()))) { 196891e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer std::swap(Op0, Op1); 1969e9f15c8a563a745c5cafa7c98b1f12de2dcab070Eli Friedman SwappedForXor = true; 1970e9f15c8a563a745c5cafa7c98b1f12de2dcab070Eli Friedman } 197191e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer 197291e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer // A | ( A ^ B) -> A | B 197391e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer // A | (~A ^ B) -> A | ~B 1974c1fc5e4464788be072509eab7d66a73dc7a5f275Chad Rosier // (A & B) | (A ^ B) 197591e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer if (match(Op1, m_Xor(m_Value(A), m_Value(B)))) { 197691e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer if (Op0 == A || Op0 == B) 197791e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer return BinaryOperator::CreateOr(A, B); 197891e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer 1979c1fc5e4464788be072509eab7d66a73dc7a5f275Chad Rosier if (match(Op0, m_And(m_Specific(A), m_Specific(B))) || 1980c1fc5e4464788be072509eab7d66a73dc7a5f275Chad Rosier match(Op0, m_And(m_Specific(B), m_Specific(A)))) 1981c1fc5e4464788be072509eab7d66a73dc7a5f275Chad Rosier return BinaryOperator::CreateOr(A, B); 1982c1fc5e4464788be072509eab7d66a73dc7a5f275Chad Rosier 198391e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer if (Op1->hasOneUse() && match(A, m_Not(m_Specific(Op0)))) { 198491e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer Value *Not = Builder->CreateNot(B, B->getName()+".not"); 198591e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer return BinaryOperator::CreateOr(Not, Op0); 198691e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer } 198791e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer if (Op1->hasOneUse() && match(B, m_Not(m_Specific(Op0)))) { 198891e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer Value *Not = Builder->CreateNot(A, A->getName()+".not"); 198991e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer return BinaryOperator::CreateOr(Not, Op0); 199091e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer } 199191e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer } 199291e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer 199391e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer // A | ~(A | B) -> A | ~B 199491e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer // A | ~(A ^ B) -> A | ~B 199591e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer if (match(Op1, m_Not(m_Value(A)))) 199691e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer if (BinaryOperator *B = dyn_cast<BinaryOperator>(A)) 199738f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer if ((Op0 == B->getOperand(0) || Op0 == B->getOperand(1)) && 199838f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer Op1->hasOneUse() && (B->getOpcode() == Instruction::Or || 199938f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer B->getOpcode() == Instruction::Xor)) { 200038f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer Value *NotOp = Op0 == B->getOperand(0) ? B->getOperand(1) : 200138f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer B->getOperand(0); 200238f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer Value *Not = Builder->CreateNot(NotOp, NotOp->getName()+".not"); 200338f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer return BinaryOperator::CreateOr(Not, Op0); 200438f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer } 200591e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer 2006e9f15c8a563a745c5cafa7c98b1f12de2dcab070Eli Friedman if (SwappedForXor) 2007e9f15c8a563a745c5cafa7c98b1f12de2dcab070Eli Friedman std::swap(Op0, Op1); 2008e9f15c8a563a745c5cafa7c98b1f12de2dcab070Eli Friedman 200925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ICmpInst *RHS = dyn_cast<ICmpInst>(I.getOperand(1))) 201025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ICmpInst *LHS = dyn_cast<ICmpInst>(I.getOperand(0))) 2011f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner if (Value *Res = FoldOrOfICmps(LHS, RHS)) 2012f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return ReplaceInstUsesWith(I, Res); 201341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 20148c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner // (fcmp uno x, c) | (fcmp uno y, c) -> (fcmp uno x, y) 20158c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner if (FCmpInst *LHS = dyn_cast<FCmpInst>(I.getOperand(0))) 20168c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner if (FCmpInst *RHS = dyn_cast<FCmpInst>(I.getOperand(1))) 2017f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner if (Value *Res = FoldOrOfFCmps(LHS, RHS)) 2018f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return ReplaceInstUsesWith(I, Res); 201941a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 202025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // fold (or (cast A), (cast B)) -> (cast (or A, B)) 202125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (CastInst *Op0C = dyn_cast<CastInst>(Op0)) { 202228621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner CastInst *Op1C = dyn_cast<CastInst>(Op1); 202328621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner if (Op1C && Op0C->getOpcode() == Op1C->getOpcode()) {// same cast kind ? 2024db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *SrcTy = Op0C->getOperand(0)->getType(); 202528621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner if (SrcTy == Op1C->getOperand(0)->getType() && 202628621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner SrcTy->isIntOrIntVectorTy()) { 202728621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner Value *Op0COp = Op0C->getOperand(0), *Op1COp = Op1C->getOperand(0); 202828621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner 202928621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner if ((!isa<ICmpInst>(Op0COp) || !isa<ICmpInst>(Op1COp)) && 203028621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner // Only do this if the casts both really cause code to be 203128621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner // generated. 203228621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner ShouldOptimizeCast(Op0C->getOpcode(), Op0COp, I.getType()) && 203328621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner ShouldOptimizeCast(Op1C->getOpcode(), Op1COp, I.getType())) { 203428621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner Value *NewOp = Builder->CreateOr(Op0COp, Op1COp, I.getName()); 203528621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner return CastInst::Create(Op0C->getOpcode(), NewOp, I.getType()); 203625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 203741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 203828621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner // If this is or(cast(icmp), cast(icmp)), try to fold this even if the 203928621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner // cast is otherwise not optimizable. This happens for vector sexts. 204028621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner if (ICmpInst *RHS = dyn_cast<ICmpInst>(Op1COp)) 204128621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner if (ICmpInst *LHS = dyn_cast<ICmpInst>(Op0COp)) 204228621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner if (Value *Res = FoldOrOfICmps(LHS, RHS)) 204328621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner return CastInst::Create(Op0C->getOpcode(), Res, I.getType()); 204441a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 204528621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner // If this is or(cast(fcmp), cast(fcmp)), try to fold this even if the 204628621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner // cast is otherwise not optimizable. This happens for vector sexts. 204728621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner if (FCmpInst *RHS = dyn_cast<FCmpInst>(Op1COp)) 204828621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner if (FCmpInst *LHS = dyn_cast<FCmpInst>(Op0COp)) 204928621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner if (Value *Res = FoldOrOfFCmps(LHS, RHS)) 205028621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner return CastInst::Create(Op0C->getOpcode(), Res, I.getType()); 205125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 205228621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner } 205325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 20543ec01b7dac769449723a25d8f7d33b49c917ccc9Eli Friedman 20553ec01b7dac769449723a25d8f7d33b49c917ccc9Eli Friedman // or(sext(A), B) -> A ? -1 : B where A is an i1 20563ec01b7dac769449723a25d8f7d33b49c917ccc9Eli Friedman // or(A, sext(B)) -> B ? -1 : A where B is an i1 20573ec01b7dac769449723a25d8f7d33b49c917ccc9Eli Friedman if (match(Op0, m_SExt(m_Value(A))) && A->getType()->isIntegerTy(1)) 20583ec01b7dac769449723a25d8f7d33b49c917ccc9Eli Friedman return SelectInst::Create(A, ConstantInt::getSigned(I.getType(), -1), Op1); 20593ec01b7dac769449723a25d8f7d33b49c917ccc9Eli Friedman if (match(Op1, m_SExt(m_Value(A))) && A->getType()->isIntegerTy(1)) 20603ec01b7dac769449723a25d8f7d33b49c917ccc9Eli Friedman return SelectInst::Create(A, ConstantInt::getSigned(I.getType(), -1), Op0); 20613ec01b7dac769449723a25d8f7d33b49c917ccc9Eli Friedman 20622c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson // Note: If we've gotten to the point of visiting the outer OR, then the 20632c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson // inner one couldn't be simplified. If it was a constant, then it won't 20642c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson // be simplified by a later pass either, so we try swapping the inner/outer 20652c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson // ORs in the hopes that we'll be able to simplify it this way. 20662c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson // (X|C) | V --> (X|V) | C 20672c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson if (Op0->hasOneUse() && !isa<ConstantInt>(Op1) && 20682c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson match(Op0, m_Or(m_Value(A), m_ConstantInt(C1)))) { 20692c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson Value *Inner = Builder->CreateOr(A, Op1); 20702c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson Inner->takeName(Op0); 20712c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson return BinaryOperator::CreateOr(Inner, C1); 20722c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson } 207341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 207425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return Changed ? &I : 0; 207525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 207625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 207725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris LattnerInstruction *InstCombiner::visitXor(BinaryOperator &I) { 2078096aa79276b8527a3cbbb3691e40e729dea09523Duncan Sands bool Changed = SimplifyAssociativeOrCommutative(I); 207925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1); 208025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 20812b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (Value *V = SimplifyXorInst(Op0, Op1, TD)) 20822b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return ReplaceInstUsesWith(I, V); 208325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 208437bf92b5238434b00fde79347ba5336e7554e562Duncan Sands // (A&B)^(A&C) -> A&(B^C) etc 208537bf92b5238434b00fde79347ba5336e7554e562Duncan Sands if (Value *V = SimplifyUsingDistributiveLaws(I)) 208637bf92b5238434b00fde79347ba5336e7554e562Duncan Sands return ReplaceInstUsesWith(I, V); 20875057f381418ddc8c96699c40479ead993cd62e7bDuncan Sands 208841a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper // See if we can simplify any instructions used by the instruction whose sole 208925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // purpose is to compute bits we don't care about. 209025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (SimplifyDemandedInstructionBits(I)) 209125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return &I; 209225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 209325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Is this a ~ operation? 209425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Value *NotOp = dyn_castNotVal(&I)) { 209525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (BinaryOperator *Op0I = dyn_cast<BinaryOperator>(NotOp)) { 209641a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper if (Op0I->getOpcode() == Instruction::And || 209725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op0I->getOpcode() == Instruction::Or) { 209825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ~(~X & Y) --> (X | ~Y) - De Morgan's Law 209925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ~(~X | Y) === (X & ~Y) - De Morgan's Law 210025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (dyn_castNotVal(Op0I->getOperand(1))) 210125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op0I->swapOperands(); 210225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Value *Op0NotVal = dyn_castNotVal(Op0I->getOperand(0))) { 210325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NotY = 210425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Builder->CreateNot(Op0I->getOperand(1), 210525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op0I->getOperand(1)->getName()+".not"); 210625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0I->getOpcode() == Instruction::And) 210725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateOr(Op0NotVal, NotY); 210825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateAnd(Op0NotVal, NotY); 210925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 211041a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 211125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ~(X & Y) --> (~X | ~Y) - De Morgan's Law 211225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ~(X | Y) === (~X & ~Y) - De Morgan's Law 211341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper if (isFreeToInvert(Op0I->getOperand(0)) && 211425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner isFreeToInvert(Op0I->getOperand(1))) { 211525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NotX = 211625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Builder->CreateNot(Op0I->getOperand(0), "notlhs"); 211725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NotY = 211825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Builder->CreateNot(Op0I->getOperand(1), "notrhs"); 211925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0I->getOpcode() == Instruction::And) 212025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateOr(NotX, NotY); 212125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateAnd(NotX, NotY); 212225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 2123c0404b3715151d020dda074740bbdaa794f9328aChris Lattner 2124c0404b3715151d020dda074740bbdaa794f9328aChris Lattner } else if (Op0I->getOpcode() == Instruction::AShr) { 2125c0404b3715151d020dda074740bbdaa794f9328aChris Lattner // ~(~X >>s Y) --> (X >>s Y) 2126c0404b3715151d020dda074740bbdaa794f9328aChris Lattner if (Value *Op0NotVal = dyn_castNotVal(Op0I->getOperand(0))) 2127c0404b3715151d020dda074740bbdaa794f9328aChris Lattner return BinaryOperator::CreateAShr(Op0NotVal, Op0I->getOperand(1)); 212825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 212925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 213025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 213141a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 213241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 213325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ConstantInt *RHS = dyn_cast<ConstantInt>(Op1)) { 21346c3ae655b846ae663ea14000adf3b42e9455ce56Dan Gohman if (RHS->isOne() && Op0->hasOneUse()) 213525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // xor (cmp A, B), true = not (cmp A, B) = !cmp A, B 21366c3ae655b846ae663ea14000adf3b42e9455ce56Dan Gohman if (CmpInst *CI = dyn_cast<CmpInst>(Op0)) 21376c3ae655b846ae663ea14000adf3b42e9455ce56Dan Gohman return CmpInst::Create(CI->getOpcode(), 21386c3ae655b846ae663ea14000adf3b42e9455ce56Dan Gohman CI->getInversePredicate(), 21396c3ae655b846ae663ea14000adf3b42e9455ce56Dan Gohman CI->getOperand(0), CI->getOperand(1)); 214025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 214125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // fold (xor(zext(cmp)), 1) and (xor(sext(cmp)), -1) to ext(!cmp). 214225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (CastInst *Op0C = dyn_cast<CastInst>(Op0)) { 214325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (CmpInst *CI = dyn_cast<CmpInst>(Op0C->getOperand(0))) { 214425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (CI->hasOneUse() && Op0C->hasOneUse()) { 214525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Instruction::CastOps Opcode = Op0C->getOpcode(); 214625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if ((Opcode == Instruction::ZExt || Opcode == Instruction::SExt) && 214741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper (RHS == ConstantExpr::getCast(Opcode, 214825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt::getTrue(I.getContext()), 214925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op0C->getDestTy()))) { 215025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner CI->setPredicate(CI->getInversePredicate()); 215125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return CastInst::Create(Opcode, CI, Op0C->getType()); 215225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 215325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 215425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 215525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 215625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 215725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (BinaryOperator *Op0I = dyn_cast<BinaryOperator>(Op0)) { 215825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ~(c-X) == X-c-1 == X+(-c-1) 215925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0I->getOpcode() == Instruction::Sub && RHS->isAllOnesValue()) 216025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Constant *Op0I0C = dyn_cast<Constant>(Op0I->getOperand(0))) { 216125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Constant *NegOp0I0C = ConstantExpr::getNeg(Op0I0C); 216225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Constant *ConstantRHS = ConstantExpr::getSub(NegOp0I0C, 216325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt::get(I.getType(), 1)); 216425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateAdd(Op0I->getOperand(1), ConstantRHS); 216525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 216641a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 216725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ConstantInt *Op0CI = dyn_cast<ConstantInt>(Op0I->getOperand(1))) { 216825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0I->getOpcode() == Instruction::Add) { 216925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ~(X-c) --> (-c-1)-X 217025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (RHS->isAllOnesValue()) { 217125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Constant *NegOp0CI = ConstantExpr::getNeg(Op0CI); 217225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateSub( 217325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantExpr::getSub(NegOp0CI, 217425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt::get(I.getType(), 1)), 217525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op0I->getOperand(0)); 217625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } else if (RHS->getValue().isSignBit()) { 217725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (X + C) ^ signbit -> (X + C + signbit) 217825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Constant *C = ConstantInt::get(I.getContext(), 217925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner RHS->getValue() + Op0CI->getValue()); 218025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateAdd(Op0I->getOperand(0), C); 218125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 218225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 218325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } else if (Op0I->getOpcode() == Instruction::Or) { 218494c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // (X|C1)^C2 -> X^(C1|C2) iff X&~C1 == 0 218525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (MaskedValueIsZero(Op0I->getOperand(0), Op0CI->getValue())) { 218625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Constant *NewRHS = ConstantExpr::getOr(Op0CI, RHS); 218725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Anything in both C1 and C2 is known to be zero, remove it from 218825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // NewRHS. 218925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Constant *CommonBits = ConstantExpr::getAnd(Op0CI, RHS); 219041a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper NewRHS = ConstantExpr::getAnd(NewRHS, 219125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantExpr::getNot(CommonBits)); 219225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Worklist.Add(Op0I); 219325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner I.setOperand(0, Op0I->getOperand(0)); 219425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner I.setOperand(1, NewRHS); 219525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return &I; 219625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 2197b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang } else if (Op0I->getOpcode() == Instruction::LShr) { 2198b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang // ((X^C1) >> C2) ^ C3 -> (X>>C2) ^ ((C1>>C2)^C3) 2199b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang // E1 = "X ^ C1" 220041a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper BinaryOperator *E1; 2201b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang ConstantInt *C1; 2202b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang if (Op0I->hasOneUse() && 2203b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang (E1 = dyn_cast<BinaryOperator>(Op0I->getOperand(0))) && 2204b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang E1->getOpcode() == Instruction::Xor && 2205b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang (C1 = dyn_cast<ConstantInt>(E1->getOperand(1)))) { 2206b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang // fold (C1 >> C2) ^ C3 2207b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang ConstantInt *C2 = Op0CI, *C3 = RHS; 2208b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang APInt FoldConst = C1->getValue().lshr(C2->getValue()); 2209b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang FoldConst ^= C3->getValue(); 2210b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang // Prepare the two operands. 2211b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang Value *Opnd0 = Builder->CreateLShr(E1->getOperand(0), C2); 2212b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang Opnd0->takeName(Op0I); 2213b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang cast<Instruction>(Opnd0)->setDebugLoc(I.getDebugLoc()); 2214b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang Value *FoldVal = ConstantInt::get(Opnd0->getType(), FoldConst); 2215b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang 2216b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang return BinaryOperator::CreateXor(Opnd0, FoldVal); 2217b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang } 221825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 221925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 222025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 222125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 222225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Try to fold constant and into select arguments. 222325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (SelectInst *SI = dyn_cast<SelectInst>(Op0)) 222425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Instruction *R = FoldOpIntoSelect(I, SI)) 222525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return R; 222625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (isa<PHINode>(Op0)) 222725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Instruction *NV = FoldOpIntoPhi(I)) 222825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return NV; 222925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 223025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 223125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner BinaryOperator *Op1I = dyn_cast<BinaryOperator>(Op1); 223225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op1I) { 223325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *A, *B; 223425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (match(Op1I, m_Or(m_Value(A), m_Value(B)))) { 223525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (A == Op0) { // B^(B|A) == (A|B)^B 223625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op1I->swapOperands(); 223725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner I.swapOperands(); 223825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(Op0, Op1); 223925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } else if (B == Op0) { // B^(A|B) == (A|B)^B 224025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner I.swapOperands(); // Simplified below. 224125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(Op0, Op1); 224225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 224341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper } else if (match(Op1I, m_And(m_Value(A), m_Value(B))) && 224425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op1I->hasOneUse()){ 224525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (A == Op0) { // A^(A&B) -> A^(B&A) 224625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op1I->swapOperands(); 224725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(A, B); 224825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 224925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (B == Op0) { // A^(B&A) -> (B&A)^A 225025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner I.swapOperands(); // Simplified below. 225125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(Op0, Op1); 225225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 225325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 225425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 225541a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 225625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner BinaryOperator *Op0I = dyn_cast<BinaryOperator>(Op0); 225725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0I) { 225825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *A, *B; 225925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (match(Op0I, m_Or(m_Value(A), m_Value(B))) && 226025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op0I->hasOneUse()) { 226125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (A == Op1) // (B|A)^B == (A|B)^B 226225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(A, B); 226325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (B == Op1) // (A|B)^B == A & ~B 2264a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer return BinaryOperator::CreateAnd(A, Builder->CreateNot(Op1)); 226541a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper } else if (match(Op0I, m_And(m_Value(A), m_Value(B))) && 226625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op0I->hasOneUse()){ 226725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (A == Op1) // (A&B)^A -> (B&A)^A 226825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(A, B); 226925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (B == Op1 && // (B&A)^A == ~B & A 227025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner !isa<ConstantInt>(Op1)) { // Canonical form is (B&C)^C 2271a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer return BinaryOperator::CreateAnd(Builder->CreateNot(A), Op1); 227225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 227325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 227425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 227541a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 227625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (X >> Z) ^ (Y >> Z) -> (X^Y) >> Z for all shifts. 227741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper if (Op0I && Op1I && Op0I->isShift() && 227841a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper Op0I->getOpcode() == Op1I->getOpcode() && 227925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op0I->getOperand(1) == Op1I->getOperand(1) && 22807bb9f063be7c1228eb2647364ce3bbc9b31b7dc8Benjamin Kramer (Op0I->hasOneUse() || Op1I->hasOneUse())) { 228125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NewOp = 228225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Builder->CreateXor(Op0I->getOperand(0), Op1I->getOperand(0), 228325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op0I->getName()); 228441a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper return BinaryOperator::Create(Op1I->getOpcode(), NewOp, 228525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op1I->getOperand(1)); 228625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 228741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 228825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0I && Op1I) { 228925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *A, *B, *C, *D; 229025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (A & B)^(A | B) -> A ^ B 229125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (match(Op0I, m_And(m_Value(A), m_Value(B))) && 229225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(Op1I, m_Or(m_Value(C), m_Value(D)))) { 229341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper if ((A == C && B == D) || (A == D && B == C)) 229425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateXor(A, B); 229525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 229625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (A | B)^(A & B) -> A ^ B 229725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (match(Op0I, m_Or(m_Value(A), m_Value(B))) && 229825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(Op1I, m_And(m_Value(C), m_Value(D)))) { 229941a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper if ((A == C && B == D) || (A == D && B == C)) 230025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateXor(A, B); 230125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 230225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 23035057f381418ddc8c96699c40479ead993cd62e7bDuncan Sands 230425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (icmp1 A, B) ^ (icmp2 A, B) --> (icmp3 A, B) 230525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ICmpInst *RHS = dyn_cast<ICmpInst>(I.getOperand(1))) 230625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ICmpInst *LHS = dyn_cast<ICmpInst>(I.getOperand(0))) 230725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (PredicatesFoldable(LHS->getPredicate(), RHS->getPredicate())) { 230825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHS->getOperand(0) == RHS->getOperand(1) && 230925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner LHS->getOperand(1) == RHS->getOperand(0)) 231025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner LHS->swapOperands(); 231125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHS->getOperand(0) == RHS->getOperand(0) && 231225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner LHS->getOperand(1) == RHS->getOperand(1)) { 231325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Op0 = LHS->getOperand(0), *Op1 = LHS->getOperand(1); 231425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner unsigned Code = getICmpCode(LHS) ^ getICmpCode(RHS); 231525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner bool isSigned = LHS->isSigned() || RHS->isSigned(); 231641a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper return ReplaceInstUsesWith(I, 23172e33944c101f2a08ed1d85e807830f2fc089dd06Pete Cooper getNewICmpValue(isSigned, Code, Op0, Op1, 23182e33944c101f2a08ed1d85e807830f2fc089dd06Pete Cooper Builder)); 231925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 232025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 232125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 232225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // fold (xor (cast A), (cast B)) -> (cast (xor A, B)) 232325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (CastInst *Op0C = dyn_cast<CastInst>(Op0)) { 232425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (CastInst *Op1C = dyn_cast<CastInst>(Op1)) 232525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0C->getOpcode() == Op1C->getOpcode()) { // same cast kind? 2326db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *SrcTy = Op0C->getOperand(0)->getType(); 2327b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands if (SrcTy == Op1C->getOperand(0)->getType() && SrcTy->isIntegerTy() && 232825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Only do this if the casts both really cause code to be generated. 232941a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper ShouldOptimizeCast(Op0C->getOpcode(), Op0C->getOperand(0), 23308c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner I.getType()) && 233141a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper ShouldOptimizeCast(Op1C->getOpcode(), Op1C->getOperand(0), 23328c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner I.getType())) { 233325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NewOp = Builder->CreateXor(Op0C->getOperand(0), 233425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op1C->getOperand(0), I.getName()); 233525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return CastInst::Create(Op0C->getOpcode(), NewOp, I.getType()); 233625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 233725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 233825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 233925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 234025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return Changed ? &I : 0; 234125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 2342