InstCombineAndOrXor.cpp revision f2d03d74ffe05d08ac7dccbb81f41d996a1f1d2a
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. 25e629a33d166f55a916f40a1feae47af8ab97feedJakub Staszakstatic Constant *AddOne(ConstantInt *C) { 26e629a33d166f55a916f40a1feae47af8ab97feedJakub Staszak return ConstantInt::get(C->getContext(), C->getValue() + 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)); 212f2d03d74ffe05d08ac7dccbb81f41d996a1f1d2aJakub Staszak ConstantInt *CI = Builder->getInt(AndRHS->getValue() & ShlMask); 21325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 214da1d660aa285b724818bdd547f1b538011cc5459Chris Lattner if (CI->getValue() == ShlMask) 215da1d660aa285b724818bdd547f1b538011cc5459Chris Lattner // Masking out bits that the shift already masks. 21625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return ReplaceInstUsesWith(TheAnd, Op); // No need for the and. 21741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 218da1d660aa285b724818bdd547f1b538011cc5459Chris Lattner if (CI != AndRHS) { // Reducing bits set in and. 21925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner TheAnd.setOperand(1, CI); 22025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return &TheAnd; 22125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 22225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 22325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 22425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case Instruction::LShr: { 22525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // We know that the AND will not produce any of the bits shifted in, so if 22625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // the anded constant includes them, clear them now! This only applies to 22725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // unsigned shifts, because a signed shr may bring in set bits! 22825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // 22925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner uint32_t BitWidth = AndRHS->getType()->getBitWidth(); 23025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner uint32_t OpRHSVal = OpRHS->getLimitedValue(BitWidth); 23125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner APInt ShrMask(APInt::getLowBitsSet(BitWidth, BitWidth - OpRHSVal)); 232f2d03d74ffe05d08ac7dccbb81f41d996a1f1d2aJakub Staszak ConstantInt *CI = Builder->getInt(AndRHS->getValue() & ShrMask); 23325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 234da1d660aa285b724818bdd547f1b538011cc5459Chris Lattner if (CI->getValue() == ShrMask) 235da1d660aa285b724818bdd547f1b538011cc5459Chris Lattner // Masking out bits that the shift already masks. 23625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return ReplaceInstUsesWith(TheAnd, Op); 23741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 238da1d660aa285b724818bdd547f1b538011cc5459Chris Lattner if (CI != AndRHS) { 23925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner TheAnd.setOperand(1, CI); // Reduce bits set in and cst. 24025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return &TheAnd; 24125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 24225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 24325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 24425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case Instruction::AShr: 24525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Signed shr. 24625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // See if this is shifting in some sign extension, then masking it out 24725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // with an and. 24825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op->hasOneUse()) { 24925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner uint32_t BitWidth = AndRHS->getType()->getBitWidth(); 25025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner uint32_t OpRHSVal = OpRHS->getLimitedValue(BitWidth); 25125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner APInt ShrMask(APInt::getLowBitsSet(BitWidth, BitWidth - OpRHSVal)); 252f2d03d74ffe05d08ac7dccbb81f41d996a1f1d2aJakub Staszak Constant *C = Builder->getInt(AndRHS->getValue() & ShrMask); 25325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (C == AndRHS) { // Masking out bits shifted in. 25425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (Val ashr C1) & C2 -> (Val lshr C1) & C2 25525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Make the argument unsigned. 25625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *ShVal = Op->getOperand(0); 25725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ShVal = Builder->CreateLShr(ShVal, OpRHS, Op->getName()); 25825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateAnd(ShVal, AndRHS, TheAnd.getName()); 25925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 26025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 26125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 26225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 26325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return 0; 26425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 26525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 26603fceff6f69a0261a767aab8e62de8aa9301b86cJim Grosbach/// Emit a computation of: (V >= Lo && V < Hi) if Inside is true, otherwise 26703fceff6f69a0261a767aab8e62de8aa9301b86cJim Grosbach/// (V < Lo || V >= Hi). In practice, we emit the more efficient 26845fc0b65e22124333d0545675e18d2dd00ebe967NAKAMURA Takumi/// (V-Lo) \<u Hi-Lo. This method expects that Lo <= Hi. isSigned indicates 26925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// whether to treat the V, Lo and HI as signed or not. IB is the location to 27025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// insert new instructions. 271f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris LattnerValue *InstCombiner::InsertRangeTest(Value *V, Constant *Lo, Constant *Hi, 272f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner bool isSigned, bool Inside) { 27341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper assert(cast<ConstantInt>(ConstantExpr::getICmp((isSigned ? 27425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ICmpInst::ICMP_SLE:ICmpInst::ICMP_ULE), Lo, Hi))->getZExtValue() && 27525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner "Lo is not <= Hi in range emission code!"); 27641a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 27725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Inside) { 27825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Lo == Hi) // Trivially false. 279f2d03d74ffe05d08ac7dccbb81f41d996a1f1d2aJakub Staszak return Builder->getFalse(); 28025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 28125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // V >= Min && V < Hi --> V < Hi 28225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (cast<ConstantInt>(Lo)->isMinValue(isSigned)) { 28341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper ICmpInst::Predicate pred = (isSigned ? 28425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT); 285f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateICmp(pred, V, Hi); 28625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 28725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 28825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Emit V-Lo <u Hi-Lo 28925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Constant *NegLo = ConstantExpr::getNeg(Lo); 29025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Add = Builder->CreateAdd(V, NegLo, V->getName()+".off"); 29125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Constant *UpperBound = ConstantExpr::getAdd(NegLo, Hi); 292f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateICmpULT(Add, UpperBound); 29325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 29425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 29525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Lo == Hi) // Trivially true. 296f2d03d74ffe05d08ac7dccbb81f41d996a1f1d2aJakub Staszak return Builder->getTrue(); 29725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 29825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // V < Min || V >= Hi -> V > Hi-1 29925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Hi = SubOne(cast<ConstantInt>(Hi)); 30025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (cast<ConstantInt>(Lo)->isMinValue(isSigned)) { 30141a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper ICmpInst::Predicate pred = (isSigned ? 30225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT); 303f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateICmp(pred, V, Hi); 30425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 30525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 30625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Emit V-Lo >u Hi-1-Lo 30725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Note that Hi has already had one subtracted from it, above. 30825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt *NegLo = cast<ConstantInt>(ConstantExpr::getNeg(Lo)); 30925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Add = Builder->CreateAdd(V, NegLo, V->getName()+".off"); 31025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Constant *LowerBound = ConstantExpr::getAdd(NegLo, Hi); 311f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateICmpUGT(Add, LowerBound); 31225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 31325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 31494c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru// isRunOfOnes - Returns true iff Val consists of one contiguous run of 1s with 31525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner// any number of 0s on either side. The 1s are allowed to wrap from LSB to 31625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner// MSB, so 0x000FFF0, 0x0000FFFF, and 0xFF0000FF are all runs. 0x0F0F0000 is 31725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner// not, since all 1s are not contiguous. 31825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattnerstatic bool isRunOfOnes(ConstantInt *Val, uint32_t &MB, uint32_t &ME) { 31925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner const APInt& V = Val->getValue(); 32025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner uint32_t BitWidth = Val->getType()->getBitWidth(); 32125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (!APIntOps::isShiftedMask(BitWidth, V)) return false; 32225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 32325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // look for the first zero bit after the run of ones 32425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner MB = BitWidth - ((V - 1) ^ V).countLeadingZeros(); 32525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // look for the first non-zero bit 32641a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper ME = V.getActiveBits(); 32725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return true; 32825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 32925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 33025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// FoldLogicalPlusAnd - This is part of an expression (LHS +/- RHS) & Mask, 33125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// where isSub determines whether the operator is a sub. If we can fold one of 33225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// the following xforms: 33341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper/// 33494c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru/// ((A & N) +/- B) & Mask -> (A +/- B) & Mask iff N&Mask == Mask 33594c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru/// ((A | N) +/- B) & Mask -> (A +/- B) & Mask iff N&Mask == 0 33694c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru/// ((A ^ N) +/- B) & Mask -> (A +/- B) & Mask iff N&Mask == 0 33725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// 33825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// return (A +/- B). 33925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// 34025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris LattnerValue *InstCombiner::FoldLogicalPlusAnd(Value *LHS, Value *RHS, 34125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt *Mask, bool isSub, 34225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Instruction &I) { 34325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Instruction *LHSI = dyn_cast<Instruction>(LHS); 34425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (!LHSI || LHSI->getNumOperands() != 2 || 34525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner !isa<ConstantInt>(LHSI->getOperand(1))) return 0; 34625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 34725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt *N = cast<ConstantInt>(LHSI->getOperand(1)); 34825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 34925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (LHSI->getOpcode()) { 35025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: return 0; 35125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case Instruction::And: 35225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ConstantExpr::getAnd(N, Mask) == Mask) { 35325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If the AndRHS is a power of two minus one (0+1+), this is simple. 35441a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper if ((Mask->getValue().countLeadingZeros() + 35541a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper Mask->getValue().countPopulation()) == 35625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Mask->getValue().getBitWidth()) 35725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 35825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 35925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Otherwise, if Mask is 0+1+0+, and if B is known to have the low 0+ 36025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // part, we don't need any explicit masks to take them out of A. If that 36125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // is all N is, ignore it. 36225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner uint32_t MB = 0, ME = 0; 36325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (isRunOfOnes(Mask, MB, ME)) { // begin/end bit of run, inclusive 36425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner uint32_t BitWidth = cast<IntegerType>(RHS->getType())->getBitWidth(); 36525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner APInt Mask(APInt::getLowBitsSet(BitWidth, MB-1)); 36625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (MaskedValueIsZero(RHS, Mask)) 36725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 36825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 36925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 37025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return 0; 37125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case Instruction::Or: 37225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case Instruction::Xor: 37325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If the AndRHS is a power of two minus one (0+1+), and N&Mask == 0 37441a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper if ((Mask->getValue().countLeadingZeros() + 37525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Mask->getValue().countPopulation()) == Mask->getValue().getBitWidth() 37625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner && ConstantExpr::getAnd(N, Mask)->isNullValue()) 37725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 37825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return 0; 37925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 38041a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 38125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (isSub) 38225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return Builder->CreateSub(LHSI->getOperand(0), RHS, "fold"); 38325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return Builder->CreateAdd(LHSI->getOperand(0), RHS, "fold"); 38425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 38525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 3865c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// enum for classifying (icmp eq (A & B), C) and (icmp ne (A & B), C) 38741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper/// One of A and B is considered the mask, the other the value. This is 38841a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper/// described as the "AMask" or "BMask" part of the enum. If the enum 3895c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// contains only "Mask", then both A and B can be considered masks. 3905c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// If A is the mask, then it was proven, that (A & C) == C. This 3915c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// is trivial if C == A, or C == 0. If both A and C are constants, this 3925c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// proof is also easy. 3935c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// For the following explanations we assume that A is the mask. 39441a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper/// The part "AllOnes" declares, that the comparison is true only 3955c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// if (A & B) == A, or all bits of A are set in B. 3965c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// Example: (icmp eq (A & 3), 3) -> FoldMskICmp_AMask_AllOnes 39741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper/// The part "AllZeroes" declares, that the comparison is true only 3985c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// if (A & B) == 0, or all bits of A are cleared in B. 3995c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// Example: (icmp eq (A & 3), 0) -> FoldMskICmp_Mask_AllZeroes 40041a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper/// The part "Mixed" declares, that (A & B) == C and C might or might not 4015c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// contain any number of one bits and zero bits. 4025c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// Example: (icmp eq (A & 3), 1) -> FoldMskICmp_AMask_Mixed 4035c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// The Part "Not" means, that in above descriptions "==" should be replaced 4045c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// by "!=". 4055c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// Example: (icmp ne (A & 3), 3) -> FoldMskICmp_AMask_NotAllOnes 4065c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// If the mask A contains a single bit, then the following is equivalent: 4075c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// (icmp eq (A & B), A) equals (icmp ne (A & B), 0) 4085c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// (icmp ne (A & B), A) equals (icmp eq (A & B), 0) 4095c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Andersonenum MaskedICmpType { 4105c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_AMask_AllOnes = 1, 4115c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_AMask_NotAllOnes = 2, 4125c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_BMask_AllOnes = 4, 4135c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_BMask_NotAllOnes = 8, 4145c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_Mask_AllZeroes = 16, 4155c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_Mask_NotAllZeroes = 32, 4165c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_AMask_Mixed = 64, 4175c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_AMask_NotMixed = 128, 4185c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_BMask_Mixed = 256, 4195c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_BMask_NotMixed = 512 4205c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson}; 4215c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson 4225c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// return the set of pattern classes (from MaskedICmpType) 4235c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// that (icmp SCC (A & B), C) satisfies 42441a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topperstatic unsigned getTypeOfMaskedICmp(Value* A, Value* B, Value* C, 4255c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson ICmpInst::Predicate SCC) 4265c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson{ 4275c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson ConstantInt *ACst = dyn_cast<ConstantInt>(A); 4285c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson ConstantInt *BCst = dyn_cast<ConstantInt>(B); 4295c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson ConstantInt *CCst = dyn_cast<ConstantInt>(C); 4305c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson bool icmp_eq = (SCC == ICmpInst::ICMP_EQ); 43141a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper bool icmp_abit = (ACst != 0 && !ACst->isZero() && 4325c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson ACst->getValue().isPowerOf2()); 43341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper bool icmp_bbit = (BCst != 0 && !BCst->isZero() && 4345c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson BCst->getValue().isPowerOf2()); 4355c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson unsigned result = 0; 4365c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (CCst != 0 && CCst->isZero()) { 4375c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // if C is zero, then both A and B qualify as mask 4385c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson result |= (icmp_eq ? (FoldMskICmp_Mask_AllZeroes | 4395c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_Mask_AllZeroes | 4405c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_AMask_Mixed | 4415c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_BMask_Mixed) 4425c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson : (FoldMskICmp_Mask_NotAllZeroes | 4435c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_Mask_NotAllZeroes | 4445c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_AMask_NotMixed | 4455c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_BMask_NotMixed)); 4465c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (icmp_abit) 4475c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson result |= (icmp_eq ? (FoldMskICmp_AMask_NotAllOnes | 44841a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper FoldMskICmp_AMask_NotMixed) 4495c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson : (FoldMskICmp_AMask_AllOnes | 4505c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_AMask_Mixed)); 4515c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (icmp_bbit) 4525c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson result |= (icmp_eq ? (FoldMskICmp_BMask_NotAllOnes | 45341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper FoldMskICmp_BMask_NotMixed) 4545c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson : (FoldMskICmp_BMask_AllOnes | 4555c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_BMask_Mixed)); 4565c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson return result; 4575c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson } 4585c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (A == C) { 4595c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson result |= (icmp_eq ? (FoldMskICmp_AMask_AllOnes | 4605c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_AMask_Mixed) 4615c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson : (FoldMskICmp_AMask_NotAllOnes | 4625c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_AMask_NotMixed)); 4635c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (icmp_abit) 4645c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson result |= (icmp_eq ? (FoldMskICmp_Mask_NotAllZeroes | 4655c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_AMask_NotMixed) 4665c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson : (FoldMskICmp_Mask_AllZeroes | 4675c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_AMask_Mixed)); 46800f8102758316cf754668b98c748c2a349f37966Craig Topper } else if (ACst != 0 && CCst != 0 && 46900f8102758316cf754668b98c748c2a349f37966Craig Topper ConstantExpr::getAnd(ACst, CCst) == CCst) { 4705c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson result |= (icmp_eq ? FoldMskICmp_AMask_Mixed 4715c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson : FoldMskICmp_AMask_NotMixed); 4725c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson } 47300f8102758316cf754668b98c748c2a349f37966Craig Topper if (B == C) { 4745c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson result |= (icmp_eq ? (FoldMskICmp_BMask_AllOnes | 4755c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_BMask_Mixed) 4765c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson : (FoldMskICmp_BMask_NotAllOnes | 4775c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_BMask_NotMixed)); 4785c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (icmp_bbit) 4795c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson result |= (icmp_eq ? (FoldMskICmp_Mask_NotAllZeroes | 48041a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper FoldMskICmp_BMask_NotMixed) 4815c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson : (FoldMskICmp_Mask_AllZeroes | 4825c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_BMask_Mixed)); 48300f8102758316cf754668b98c748c2a349f37966Craig Topper } else if (BCst != 0 && CCst != 0 && 48400f8102758316cf754668b98c748c2a349f37966Craig Topper ConstantExpr::getAnd(BCst, CCst) == CCst) { 4855c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson result |= (icmp_eq ? FoldMskICmp_BMask_Mixed 4865c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson : FoldMskICmp_BMask_NotMixed); 4875c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson } 4885c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson return result; 4895c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson} 4905c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson 49147a86077212bb680c3273842b1aba801757836eaBenjamin Kramer/// decomposeBitTestICmp - Decompose an icmp into the form ((X & Y) pred Z) 49247a86077212bb680c3273842b1aba801757836eaBenjamin Kramer/// if possible. The returned predicate is either == or !=. Returns false if 49347a86077212bb680c3273842b1aba801757836eaBenjamin Kramer/// decomposition fails. 49447a86077212bb680c3273842b1aba801757836eaBenjamin Kramerstatic bool decomposeBitTestICmp(const ICmpInst *I, ICmpInst::Predicate &Pred, 49547a86077212bb680c3273842b1aba801757836eaBenjamin Kramer Value *&X, Value *&Y, Value *&Z) { 49647a86077212bb680c3273842b1aba801757836eaBenjamin Kramer // X < 0 is equivalent to (X & SignBit) != 0. 49747a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (I->getPredicate() == ICmpInst::ICMP_SLT) 49847a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (ConstantInt *C = dyn_cast<ConstantInt>(I->getOperand(1))) 49947a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (C->isZero()) { 50047a86077212bb680c3273842b1aba801757836eaBenjamin Kramer X = I->getOperand(0); 50147a86077212bb680c3273842b1aba801757836eaBenjamin Kramer Y = ConstantInt::get(I->getContext(), 50247a86077212bb680c3273842b1aba801757836eaBenjamin Kramer APInt::getSignBit(C->getBitWidth())); 50347a86077212bb680c3273842b1aba801757836eaBenjamin Kramer Pred = ICmpInst::ICMP_NE; 50447a86077212bb680c3273842b1aba801757836eaBenjamin Kramer Z = C; 50547a86077212bb680c3273842b1aba801757836eaBenjamin Kramer return true; 50647a86077212bb680c3273842b1aba801757836eaBenjamin Kramer } 50747a86077212bb680c3273842b1aba801757836eaBenjamin Kramer 50847a86077212bb680c3273842b1aba801757836eaBenjamin Kramer // X > -1 is equivalent to (X & SignBit) == 0. 50947a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (I->getPredicate() == ICmpInst::ICMP_SGT) 51047a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (ConstantInt *C = dyn_cast<ConstantInt>(I->getOperand(1))) 51147a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (C->isAllOnesValue()) { 51247a86077212bb680c3273842b1aba801757836eaBenjamin Kramer X = I->getOperand(0); 51347a86077212bb680c3273842b1aba801757836eaBenjamin Kramer Y = ConstantInt::get(I->getContext(), 51447a86077212bb680c3273842b1aba801757836eaBenjamin Kramer APInt::getSignBit(C->getBitWidth())); 51547a86077212bb680c3273842b1aba801757836eaBenjamin Kramer Pred = ICmpInst::ICMP_EQ; 51647a86077212bb680c3273842b1aba801757836eaBenjamin Kramer Z = ConstantInt::getNullValue(C->getType()); 51747a86077212bb680c3273842b1aba801757836eaBenjamin Kramer return true; 51847a86077212bb680c3273842b1aba801757836eaBenjamin Kramer } 51947a86077212bb680c3273842b1aba801757836eaBenjamin Kramer 52047a86077212bb680c3273842b1aba801757836eaBenjamin Kramer return false; 52147a86077212bb680c3273842b1aba801757836eaBenjamin Kramer} 52247a86077212bb680c3273842b1aba801757836eaBenjamin Kramer 5235c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// foldLogOpOfMaskedICmpsHelper: 5245c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// handle (icmp(A & B) ==/!= C) &/| (icmp(A & D) ==/!= E) 5255c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// return the set of pattern classes (from MaskedICmpType) 5265c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// that both LHS and RHS satisfy 52741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topperstatic unsigned foldLogOpOfMaskedICmpsHelper(Value*& A, 5285c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value*& B, Value*& C, 5295c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value*& D, Value*& E, 53047a86077212bb680c3273842b1aba801757836eaBenjamin Kramer ICmpInst *LHS, ICmpInst *RHS, 53147a86077212bb680c3273842b1aba801757836eaBenjamin Kramer ICmpInst::Predicate &LHSCC, 53247a86077212bb680c3273842b1aba801757836eaBenjamin Kramer ICmpInst::Predicate &RHSCC) { 5335c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (LHS->getOperand(0)->getType() != RHS->getOperand(0)->getType()) return 0; 5345c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // vectors are not (yet?) supported 5355c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (LHS->getOperand(0)->getType()->isVectorTy()) return 0; 5365c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson 5375c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // Here comes the tricky part: 53841a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper // LHS might be of the form L11 & L12 == X, X == L21 & L22, 5395c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // and L11 & L12 == L21 & L22. The same goes for RHS. 5405c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // Now we must find those components L** and R**, that are equal, so 54141a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper // that we can extract the parameters A, B, C, D, and E for the canonical 5425c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // above. 5435c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value *L1 = LHS->getOperand(0); 5445c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value *L2 = LHS->getOperand(1); 5455c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value *L11,*L12,*L21,*L22; 54647a86077212bb680c3273842b1aba801757836eaBenjamin Kramer // Check whether the icmp can be decomposed into a bit test. 54747a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (decomposeBitTestICmp(LHS, LHSCC, L11, L12, L2)) { 54847a86077212bb680c3273842b1aba801757836eaBenjamin Kramer L21 = L22 = L1 = 0; 54947a86077212bb680c3273842b1aba801757836eaBenjamin Kramer } else { 55047a86077212bb680c3273842b1aba801757836eaBenjamin Kramer // Look for ANDs in the LHS icmp. 55147a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (match(L1, m_And(m_Value(L11), m_Value(L12)))) { 55247a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (!match(L2, m_And(m_Value(L21), m_Value(L22)))) 55347a86077212bb680c3273842b1aba801757836eaBenjamin Kramer L21 = L22 = 0; 55447a86077212bb680c3273842b1aba801757836eaBenjamin Kramer } else { 55547a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (!match(L2, m_And(m_Value(L11), m_Value(L12)))) 55647a86077212bb680c3273842b1aba801757836eaBenjamin Kramer return 0; 55747a86077212bb680c3273842b1aba801757836eaBenjamin Kramer std::swap(L1, L2); 5585c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson L21 = L22 = 0; 55947a86077212bb680c3273842b1aba801757836eaBenjamin Kramer } 5605c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson } 5615c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson 56247a86077212bb680c3273842b1aba801757836eaBenjamin Kramer // Bail if LHS was a icmp that can't be decomposed into an equality. 56347a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (!ICmpInst::isEquality(LHSCC)) 56447a86077212bb680c3273842b1aba801757836eaBenjamin Kramer return 0; 56547a86077212bb680c3273842b1aba801757836eaBenjamin Kramer 5665c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value *R1 = RHS->getOperand(0); 5675c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value *R2 = RHS->getOperand(1); 5685c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value *R11,*R12; 5695c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson bool ok = false; 57047a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (decomposeBitTestICmp(RHS, RHSCC, R11, R12, R2)) { 57147a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (R11 == L11 || R11 == L12 || R11 == L21 || R11 == L22) { 57247a86077212bb680c3273842b1aba801757836eaBenjamin Kramer A = R11; D = R12; 57347a86077212bb680c3273842b1aba801757836eaBenjamin Kramer } else if (R12 == L11 || R12 == L12 || R12 == L21 || R12 == L22) { 57447a86077212bb680c3273842b1aba801757836eaBenjamin Kramer A = R12; D = R11; 57547a86077212bb680c3273842b1aba801757836eaBenjamin Kramer } else { 57647a86077212bb680c3273842b1aba801757836eaBenjamin Kramer return 0; 5775c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson } 57847a86077212bb680c3273842b1aba801757836eaBenjamin Kramer E = R2; R1 = 0; ok = true; 57947a86077212bb680c3273842b1aba801757836eaBenjamin Kramer } else if (match(R1, m_And(m_Value(R11), m_Value(R12)))) { 58047a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (R11 == L11 || R11 == L12 || R11 == L21 || R11 == L22) { 58147a86077212bb680c3273842b1aba801757836eaBenjamin Kramer A = R11; D = R12; E = R2; ok = true; 58247a86077212bb680c3273842b1aba801757836eaBenjamin Kramer } else if (R12 == L11 || R12 == L12 || R12 == L21 || R12 == L22) { 5835c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson A = R12; D = R11; E = R2; ok = true; 5845c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson } 5855c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson } 58647a86077212bb680c3273842b1aba801757836eaBenjamin Kramer 58747a86077212bb680c3273842b1aba801757836eaBenjamin Kramer // Bail if RHS was a icmp that can't be decomposed into an equality. 58847a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (!ICmpInst::isEquality(RHSCC)) 58947a86077212bb680c3273842b1aba801757836eaBenjamin Kramer return 0; 59047a86077212bb680c3273842b1aba801757836eaBenjamin Kramer 59147a86077212bb680c3273842b1aba801757836eaBenjamin Kramer // Look for ANDs in on the right side of the RHS icmp. 5925c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (!ok && match(R2, m_And(m_Value(R11), m_Value(R12)))) { 59347a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (R11 == L11 || R11 == L12 || R11 == L21 || R11 == L22) { 59447a86077212bb680c3273842b1aba801757836eaBenjamin Kramer A = R11; D = R12; E = R1; ok = true; 59547a86077212bb680c3273842b1aba801757836eaBenjamin Kramer } else if (R12 == L11 || R12 == L12 || R12 == L21 || R12 == L22) { 5965c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson A = R12; D = R11; E = R1; ok = true; 59747a86077212bb680c3273842b1aba801757836eaBenjamin Kramer } else { 5985c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson return 0; 59947a86077212bb680c3273842b1aba801757836eaBenjamin Kramer } 6005c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson } 6015c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (!ok) 6025c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson return 0; 6035c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson 6045c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (L11 == A) { 6055c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson B = L12; C = L2; 60600f8102758316cf754668b98c748c2a349f37966Craig Topper } else if (L12 == A) { 6075c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson B = L11; C = L2; 60800f8102758316cf754668b98c748c2a349f37966Craig Topper } else if (L21 == A) { 6095c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson B = L22; C = L1; 61000f8102758316cf754668b98c748c2a349f37966Craig Topper } else if (L22 == A) { 6115c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson B = L21; C = L1; 6125c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson } 6135c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson 6145c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson unsigned left_type = getTypeOfMaskedICmp(A, B, C, LHSCC); 6155c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson unsigned right_type = getTypeOfMaskedICmp(A, D, E, RHSCC); 6165c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson return left_type & right_type; 6175c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson} 6185c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// foldLogOpOfMaskedICmps: 6195c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// try to fold (icmp(A & B) ==/!= C) &/| (icmp(A & D) ==/!= E) 6205c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// into a single (icmp(A & X) ==/!= Y) 6215c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Andersonstatic Value* foldLogOpOfMaskedICmps(ICmpInst *LHS, ICmpInst *RHS, 6225c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson ICmpInst::Predicate NEWCC, 6235c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson llvm::InstCombiner::BuilderTy* Builder) { 6245c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value *A = 0, *B = 0, *C = 0, *D = 0, *E = 0; 62547a86077212bb680c3273842b1aba801757836eaBenjamin Kramer ICmpInst::Predicate LHSCC = LHS->getPredicate(), RHSCC = RHS->getPredicate(); 62647a86077212bb680c3273842b1aba801757836eaBenjamin Kramer unsigned mask = foldLogOpOfMaskedICmpsHelper(A, B, C, D, E, LHS, RHS, 62747a86077212bb680c3273842b1aba801757836eaBenjamin Kramer LHSCC, RHSCC); 6287e4ac32a4e674c077317f190e9507ccb26eeaf3fBenjamin Kramer if (mask == 0) return 0; 62947a86077212bb680c3273842b1aba801757836eaBenjamin Kramer assert(ICmpInst::isEquality(LHSCC) && ICmpInst::isEquality(RHSCC) && 63047a86077212bb680c3273842b1aba801757836eaBenjamin Kramer "foldLogOpOfMaskedICmpsHelper must return an equality predicate."); 6315c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson 6325c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (NEWCC == ICmpInst::ICMP_NE) 6335c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson mask >>= 1; // treat "Not"-states as normal states 6345c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson 6355c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (mask & FoldMskICmp_Mask_AllZeroes) { 63641a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper // (icmp eq (A & B), 0) & (icmp eq (A & D), 0) 6375c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // -> (icmp eq (A & (B|D)), 0) 6385c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value* newOr = Builder->CreateOr(B, D); 6395c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value* newAnd = Builder->CreateAnd(A, newOr); 6405c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // we can't use C as zero, because we might actually handle 64141a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper // (icmp ne (A & B), B) & (icmp ne (A & D), D) 6425c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // with B and D, having a single bit set 6435c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value* zero = Constant::getNullValue(A->getType()); 6445c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson return Builder->CreateICmp(NEWCC, newAnd, zero); 6455c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson } 64600f8102758316cf754668b98c748c2a349f37966Craig Topper if (mask & FoldMskICmp_BMask_AllOnes) { 64741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper // (icmp eq (A & B), B) & (icmp eq (A & D), D) 6485c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // -> (icmp eq (A & (B|D)), (B|D)) 6495c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value* newOr = Builder->CreateOr(B, D); 6505c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value* newAnd = Builder->CreateAnd(A, newOr); 6515c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson return Builder->CreateICmp(NEWCC, newAnd, newOr); 65241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper } 65300f8102758316cf754668b98c748c2a349f37966Craig Topper if (mask & FoldMskICmp_AMask_AllOnes) { 65441a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper // (icmp eq (A & B), A) & (icmp eq (A & D), A) 6555c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // -> (icmp eq (A & (B&D)), A) 6565c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value* newAnd1 = Builder->CreateAnd(B, D); 6575c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value* newAnd = Builder->CreateAnd(A, newAnd1); 6585c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson return Builder->CreateICmp(NEWCC, newAnd, A); 6595c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson } 66000f8102758316cf754668b98c748c2a349f37966Craig Topper if (mask & FoldMskICmp_BMask_Mixed) { 66141a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper // (icmp eq (A & B), C) & (icmp eq (A & D), E) 6625c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // We already know that B & C == C && D & E == E. 6635c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // If we can prove that (B & D) & (C ^ E) == 0, that is, the bits of 6645c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // C and E, which are shared by both the mask B and the mask D, don't 6655c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // contradict, then we can transform to 6665c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // -> (icmp eq (A & (B|D)), (C|E)) 6675c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // Currently, we only handle the case of B, C, D, and E being constant. 6685c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson ConstantInt *BCst = dyn_cast<ConstantInt>(B); 6695c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (BCst == 0) return 0; 6705c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson ConstantInt *DCst = dyn_cast<ConstantInt>(D); 6715c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (DCst == 0) return 0; 6725c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // we can't simply use C and E, because we might actually handle 67341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper // (icmp ne (A & B), B) & (icmp eq (A & D), D) 6745c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // with B and D, having a single bit set 6755c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson 6765c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson ConstantInt *CCst = dyn_cast<ConstantInt>(C); 6775c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (CCst == 0) return 0; 67847a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (LHSCC != NEWCC) 6795c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson CCst = dyn_cast<ConstantInt>( ConstantExpr::getXor(BCst, CCst) ); 6805c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson ConstantInt *ECst = dyn_cast<ConstantInt>(E); 6815c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (ECst == 0) return 0; 68247a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (RHSCC != NEWCC) 6835c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson ECst = dyn_cast<ConstantInt>( ConstantExpr::getXor(DCst, ECst) ); 6845c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson ConstantInt* MCst = dyn_cast<ConstantInt>( 6855c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson ConstantExpr::getAnd(ConstantExpr::getAnd(BCst, DCst), 6865c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson ConstantExpr::getXor(CCst, ECst)) ); 6875c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // if there is a conflict we should actually return a false for the 6885c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // whole construct 6895c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (!MCst->isZero()) 6905c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson return 0; 69144cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner Value *newOr1 = Builder->CreateOr(B, D); 69244cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner Value *newOr2 = ConstantExpr::getOr(CCst, ECst); 69344cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner Value *newAnd = Builder->CreateAnd(A, newOr1); 6945c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson return Builder->CreateICmp(NEWCC, newAnd, newOr2); 6955c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson } 6965c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson return 0; 6975c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson} 6985c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson 69925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// FoldAndOfICmps - Fold (icmp)&(icmp) if possible. 700f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris LattnerValue *InstCombiner::FoldAndOfICmps(ICmpInst *LHS, ICmpInst *RHS) { 70125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ICmpInst::Predicate LHSCC = LHS->getPredicate(), RHSCC = RHS->getPredicate(); 70225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 70325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (icmp1 A, B) & (icmp2 A, B) --> (icmp3 A, B) 70425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (PredicatesFoldable(LHSCC, RHSCC)) { 70525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHS->getOperand(0) == RHS->getOperand(1) && 70625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner LHS->getOperand(1) == RHS->getOperand(0)) 70725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner LHS->swapOperands(); 70825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHS->getOperand(0) == RHS->getOperand(0) && 70925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner LHS->getOperand(1) == RHS->getOperand(1)) { 71025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Op0 = LHS->getOperand(0), *Op1 = LHS->getOperand(1); 71125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner unsigned Code = getICmpCode(LHS) & getICmpCode(RHS); 71225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner bool isSigned = LHS->isSigned() || RHS->isSigned(); 7132e33944c101f2a08ed1d85e807830f2fc089dd06Pete Cooper return getNewICmpValue(isSigned, Code, Op0, Op1, Builder); 71425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 71525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 7165c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson 71744cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner // handle (roughly): (icmp eq (A & B), C) & (icmp eq (A & D), E) 71844cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner if (Value *V = foldLogOpOfMaskedICmps(LHS, RHS, ICmpInst::ICMP_EQ, Builder)) 71944cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner return V; 72041a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 72125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // This only handles icmp of constants: (icmp1 A, C1) & (icmp2 B, C2). 72225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Val = LHS->getOperand(0), *Val2 = RHS->getOperand(0); 72325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt *LHSCst = dyn_cast<ConstantInt>(LHS->getOperand(1)); 72425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt *RHSCst = dyn_cast<ConstantInt>(RHS->getOperand(1)); 72525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHSCst == 0 || RHSCst == 0) return 0; 72641a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 72725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHSCst == RHSCst && LHSCC == RHSCC) { 72825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (icmp ult A, C) & (icmp ult B, C) --> (icmp ult (A|B), C) 72925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // where C is a power of 2 73025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHSCC == ICmpInst::ICMP_ULT && 73125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner LHSCst->getValue().isPowerOf2()) { 73225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NewOr = Builder->CreateOr(Val, Val2); 733f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateICmp(LHSCC, NewOr, LHSCst); 73425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 73541a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 73625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (icmp eq A, 0) & (icmp eq B, 0) --> (icmp eq (A|B), 0) 73725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHSCC == ICmpInst::ICMP_EQ && LHSCst->isZero()) { 73825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NewOr = Builder->CreateOr(Val, Val2); 739f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateICmp(LHSCC, NewOr, LHSCst); 74025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 74125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 742264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer 743e12d58362176a7ea7ead7afa157194c18359499fBenjamin Kramer // (trunc x) == C1 & (and x, CA) == C2 -> (and x, CA|CMAX) == C1|C2 744264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer // where CMAX is the all ones value for the truncated type, 74594c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // iff the lower bits of C2 and CA are zero. 746e1b66f11459c7f1523939fb6ac1dfdc93e1d26efBill Wendling if (LHSCC == ICmpInst::ICMP_EQ && LHSCC == RHSCC && 747264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer LHS->hasOneUse() && RHS->hasOneUse()) { 748264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer Value *V; 749264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer ConstantInt *AndCst, *SmallCst = 0, *BigCst = 0; 750264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer 751264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer // (trunc x) == C1 & (and x, CA) == C2 75200f8102758316cf754668b98c748c2a349f37966Craig Topper // (and x, CA) == C2 & (trunc x) == C1 753264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer if (match(Val2, m_Trunc(m_Value(V))) && 754264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer match(Val, m_And(m_Specific(V), m_ConstantInt(AndCst)))) { 755264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer SmallCst = RHSCst; 756264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer BigCst = LHSCst; 75700f8102758316cf754668b98c748c2a349f37966Craig Topper } else if (match(Val, m_Trunc(m_Value(V))) && 75800f8102758316cf754668b98c748c2a349f37966Craig Topper match(Val2, m_And(m_Specific(V), m_ConstantInt(AndCst)))) { 759264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer SmallCst = LHSCst; 760264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer BigCst = RHSCst; 761264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer } 762264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer 763264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer if (SmallCst && BigCst) { 764264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer unsigned BigBitSize = BigCst->getType()->getBitWidth(); 765264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer unsigned SmallBitSize = SmallCst->getType()->getBitWidth(); 766264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer 767264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer // Check that the low bits are zero. 768264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer APInt Low = APInt::getLowBitsSet(BigBitSize, SmallBitSize); 769b0884f3f13ca6e5d83e3232d8390a4d58739d57cBenjamin Kramer if ((Low & AndCst->getValue()) == 0 && (Low & BigCst->getValue()) == 0) { 770264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer Value *NewAnd = Builder->CreateAnd(V, Low | AndCst->getValue()); 771264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer APInt N = SmallCst->getValue().zext(BigBitSize) | BigCst->getValue(); 772264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer Value *NewVal = ConstantInt::get(AndCst->getType()->getContext(), N); 773264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer return Builder->CreateICmp(LHSCC, NewAnd, NewVal); 774264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer } 775264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer } 776264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer } 777dfb806f6ba53b792171b928b57def9d0182d2f5fBenjamin Kramer 77825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // From here on, we only handle: 77925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (icmp1 A, C1) & (icmp2 A, C2) --> something simpler. 78025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Val != Val2) return 0; 78141a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 78225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ICMP_[US][GL]E X, CST is folded to ICMP_[US][GL]T elsewhere. 78325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHSCC == ICmpInst::ICMP_UGE || LHSCC == ICmpInst::ICMP_ULE || 78425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner RHSCC == ICmpInst::ICMP_UGE || RHSCC == ICmpInst::ICMP_ULE || 78525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner LHSCC == ICmpInst::ICMP_SGE || LHSCC == ICmpInst::ICMP_SLE || 78625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner RHSCC == ICmpInst::ICMP_SGE || RHSCC == ICmpInst::ICMP_SLE) 78725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return 0; 788d70be0b2c199183077626a9e756ecd14b807dd56Anders Carlsson 789d70be0b2c199183077626a9e756ecd14b807dd56Anders Carlsson // Make a constant range that's the intersection of the two icmp ranges. 790d70be0b2c199183077626a9e756ecd14b807dd56Anders Carlsson // If the intersection is empty, we know that the result is false. 79141a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper ConstantRange LHSRange = 792d70be0b2c199183077626a9e756ecd14b807dd56Anders Carlsson ConstantRange::makeICmpRegion(LHSCC, LHSCst->getValue()); 79341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper ConstantRange RHSRange = 794d70be0b2c199183077626a9e756ecd14b807dd56Anders Carlsson ConstantRange::makeICmpRegion(RHSCC, RHSCst->getValue()); 795d70be0b2c199183077626a9e756ecd14b807dd56Anders Carlsson 796d70be0b2c199183077626a9e756ecd14b807dd56Anders Carlsson if (LHSRange.intersectWith(RHSRange).isEmptySet()) 797d70be0b2c199183077626a9e756ecd14b807dd56Anders Carlsson return ConstantInt::get(CmpInst::makeCmpResultType(LHS->getType()), 0); 798d70be0b2c199183077626a9e756ecd14b807dd56Anders Carlsson 79925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // We can't fold (ugt x, C) & (sgt x, C2). 80025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (!PredicatesFoldable(LHSCC, RHSCC)) 80125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return 0; 80241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 80325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Ensure that the larger constant is on the RHS. 80425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner bool ShouldSwap; 80525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (CmpInst::isSigned(LHSCC) || 80641a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper (ICmpInst::isEquality(LHSCC) && 80725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner CmpInst::isSigned(RHSCC))) 80825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ShouldSwap = LHSCst->getValue().sgt(RHSCst->getValue()); 80925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner else 81025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ShouldSwap = LHSCst->getValue().ugt(RHSCst->getValue()); 81141a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 81225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ShouldSwap) { 81325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(LHS, RHS); 81425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(LHSCst, RHSCst); 81525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(LHSCC, RHSCC); 81625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 81725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 818f451cb870efcf9e0302d25ed05f4cac6bb494e42Dan Gohman // At this point, we know we have two icmp instructions 81925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // comparing a value against two constants and and'ing the result 82025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // together. Because of the above check, we know that we only have 82141a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper // icmp eq, icmp ne, icmp [su]lt, and icmp [SU]gt here. We also know 82241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper // (from the icmp folding check above), that the two constants 82325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // are not equal and that the larger constant is on the RHS 82425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner assert(LHSCst != RHSCst && "Compares not folded above?"); 82525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 82625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (LHSCC) { 82725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: llvm_unreachable("Unknown integer condition code!"); 82825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_EQ: 82925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (RHSCC) { 83025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: llvm_unreachable("Unknown integer condition code!"); 83125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_NE: // (X == 13 & X != 15) -> X == 13 83225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_ULT: // (X == 13 & X < 15) -> X == 13 83325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SLT: // (X == 13 & X < 15) -> X == 13 834f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return LHS; 83525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 83625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_NE: 83725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (RHSCC) { 83825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: llvm_unreachable("Unknown integer condition code!"); 83925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_ULT: 84025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHSCst == SubOne(RHSCst)) // (X != 13 & X u< 14) -> X < 13 841f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateICmpULT(Val, LHSCst); 84225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; // (X != 13 & X u< 15) -> no change 84325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SLT: 84425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHSCst == SubOne(RHSCst)) // (X != 13 & X s< 14) -> X < 13 845f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateICmpSLT(Val, LHSCst); 84625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; // (X != 13 & X s< 15) -> no change 84725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_EQ: // (X != 13 & X == 15) -> X == 15 84825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_UGT: // (X != 13 & X u> 15) -> X u> 15 84925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SGT: // (X != 13 & X s> 15) -> X s> 15 850f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return RHS; 85125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_NE: 85225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHSCst == SubOne(RHSCst)){// (X != 13 & X != 14) -> X-13 >u 1 85325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Constant *AddCST = ConstantExpr::getNeg(LHSCst); 85425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Add = Builder->CreateAdd(Val, AddCST, Val->getName()+".off"); 855f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateICmpUGT(Add, ConstantInt::get(Add->getType(), 1)); 85625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 85725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; // (X != 13 & X != 15) -> no change 85825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 85925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 86025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_ULT: 86125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (RHSCC) { 86225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: llvm_unreachable("Unknown integer condition code!"); 86325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_EQ: // (X u< 13 & X == 15) -> false 86425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_UGT: // (X u< 13 & X u> 15) -> false 865f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return ConstantInt::get(CmpInst::makeCmpResultType(LHS->getType()), 0); 86625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SGT: // (X u< 13 & X s> 15) -> no change 86725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 86825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_NE: // (X u< 13 & X != 15) -> X u< 13 86925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_ULT: // (X u< 13 & X u< 15) -> X u< 13 870f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return LHS; 87125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SLT: // (X u< 13 & X s< 15) -> no change 87225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 87325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 87425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 87525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SLT: 87625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (RHSCC) { 87725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: llvm_unreachable("Unknown integer condition code!"); 87825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_UGT: // (X s< 13 & X u> 15) -> no change 87925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 88025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_NE: // (X s< 13 & X != 15) -> X < 13 88125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SLT: // (X s< 13 & X s< 15) -> X < 13 882f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return LHS; 88325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_ULT: // (X s< 13 & X u< 15) -> no change 88425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 88525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 88625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 88725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_UGT: 88825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (RHSCC) { 88925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: llvm_unreachable("Unknown integer condition code!"); 89025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_EQ: // (X u> 13 & X == 15) -> X == 15 89125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_UGT: // (X u> 13 & X u> 15) -> X u> 15 892f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return RHS; 89325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SGT: // (X u> 13 & X s> 15) -> no change 89425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 89525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_NE: 89625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (RHSCst == AddOne(LHSCst)) // (X u> 13 & X != 14) -> X u> 14 897f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateICmp(LHSCC, Val, RHSCst); 89825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; // (X u> 13 & X != 15) -> no change 89925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_ULT: // (X u> 13 & X u< 15) -> (X-14) <u 1 900f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return InsertRangeTest(Val, AddOne(LHSCst), RHSCst, false, true); 90125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SLT: // (X u> 13 & X s< 15) -> no change 90225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 90325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 90425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 90525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SGT: 90625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (RHSCC) { 90725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: llvm_unreachable("Unknown integer condition code!"); 90825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_EQ: // (X s> 13 & X == 15) -> X == 15 90925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SGT: // (X s> 13 & X s> 15) -> X s> 15 910f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return RHS; 91125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_UGT: // (X s> 13 & X u> 15) -> no change 91225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 91325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_NE: 91425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (RHSCst == AddOne(LHSCst)) // (X s> 13 & X != 14) -> X s> 14 915f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateICmp(LHSCC, Val, RHSCst); 91625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; // (X s> 13 & X != 15) -> no change 91725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SLT: // (X s> 13 & X s< 15) -> (X-14) s< 1 918f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return InsertRangeTest(Val, AddOne(LHSCst), RHSCst, true, true); 91925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_ULT: // (X s> 13 & X u< 15) -> no change 92025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 92125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 92225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 92325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 92441a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 92525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return 0; 92625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 92725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 928f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner/// FoldAndOfFCmps - Optimize (fcmp)&(fcmp). NOTE: Unlike the rest of 929f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner/// instcombine, this returns a Value which should already be inserted into the 930f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner/// function. 931f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris LattnerValue *InstCombiner::FoldAndOfFCmps(FCmpInst *LHS, FCmpInst *RHS) { 93225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHS->getPredicate() == FCmpInst::FCMP_ORD && 93325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner RHS->getPredicate() == FCmpInst::FCMP_ORD) { 9346ac927860610d134f2a35119abff6eb2d81846a1Benjamin Kramer if (LHS->getOperand(0)->getType() != RHS->getOperand(0)->getType()) 9356ac927860610d134f2a35119abff6eb2d81846a1Benjamin Kramer return 0; 9366ac927860610d134f2a35119abff6eb2d81846a1Benjamin Kramer 93725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (fcmp ord x, c) & (fcmp ord y, c) -> (fcmp ord x, y) 93825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ConstantFP *LHSC = dyn_cast<ConstantFP>(LHS->getOperand(1))) 93925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ConstantFP *RHSC = dyn_cast<ConstantFP>(RHS->getOperand(1))) { 94025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If either of the constants are nans, then the whole thing returns 94125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // false. 94225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHSC->getValueAPF().isNaN() || RHSC->getValueAPF().isNaN()) 943f2d03d74ffe05d08ac7dccbb81f41d996a1f1d2aJakub Staszak return Builder->getFalse(); 944f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateFCmpORD(LHS->getOperand(0), RHS->getOperand(0)); 94525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 94641a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 94725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Handle vector zeros. This occurs because the canonical form of 94825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // "fcmp ord x,x" is "fcmp ord x, 0". 94925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (isa<ConstantAggregateZero>(LHS->getOperand(1)) && 95025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner isa<ConstantAggregateZero>(RHS->getOperand(1))) 951f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateFCmpORD(LHS->getOperand(0), RHS->getOperand(0)); 95225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return 0; 95325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 95441a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 95525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Op0LHS = LHS->getOperand(0), *Op0RHS = LHS->getOperand(1); 95625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Op1LHS = RHS->getOperand(0), *Op1RHS = RHS->getOperand(1); 95725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner FCmpInst::Predicate Op0CC = LHS->getPredicate(), Op1CC = RHS->getPredicate(); 95841a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 95941a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 96025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0LHS == Op1RHS && Op0RHS == Op1LHS) { 96125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Swap RHS operands to match LHS. 96225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op1CC = FCmpInst::getSwappedPredicate(Op1CC); 96325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(Op1LHS, Op1RHS); 96425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 96541a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 96625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0LHS == Op1LHS && Op0RHS == Op1RHS) { 96725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Simplify (fcmp cc0 x, y) & (fcmp cc1 x, y). 96825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0CC == Op1CC) 969f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateFCmp((FCmpInst::Predicate)Op0CC, Op0LHS, Op0RHS); 97025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0CC == FCmpInst::FCMP_FALSE || Op1CC == FCmpInst::FCMP_FALSE) 971f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return ConstantInt::get(CmpInst::makeCmpResultType(LHS->getType()), 0); 97225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0CC == FCmpInst::FCMP_TRUE) 973f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return RHS; 97425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op1CC == FCmpInst::FCMP_TRUE) 975f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return LHS; 97641a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 97725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner bool Op0Ordered; 97825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner bool Op1Ordered; 97925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner unsigned Op0Pred = getFCmpCode(Op0CC, Op0Ordered); 98025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner unsigned Op1Pred = getFCmpCode(Op1CC, Op1Ordered); 9818b421c8eb2c41ee66cd1023bc7c262bdfaea481dChad Rosier // uno && ord -> false 9828b421c8eb2c41ee66cd1023bc7c262bdfaea481dChad Rosier if (Op0Pred == 0 && Op1Pred == 0 && Op0Ordered != Op1Ordered) 9838b421c8eb2c41ee66cd1023bc7c262bdfaea481dChad Rosier return ConstantInt::get(CmpInst::makeCmpResultType(LHS->getType()), 0); 98425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op1Pred == 0) { 98525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(LHS, RHS); 98625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(Op0Pred, Op1Pred); 98725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(Op0Ordered, Op1Ordered); 98825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 98925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0Pred == 0) { 9907a0575b9a8ca291c33495623eae171394f33b58fManman Ren // uno && ueq -> uno && (uno || eq) -> uno 99125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ord && olt -> ord && (ord && lt) -> olt 9927a0575b9a8ca291c33495623eae171394f33b58fManman Ren if (!Op0Ordered && (Op0Ordered == Op1Ordered)) 9937a0575b9a8ca291c33495623eae171394f33b58fManman Ren return LHS; 9947a0575b9a8ca291c33495623eae171394f33b58fManman Ren if (Op0Ordered && (Op0Ordered == Op1Ordered)) 995f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return RHS; 99641a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 99725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // uno && oeq -> uno && (ord && eq) -> false 99825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (!Op0Ordered) 999f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return ConstantInt::get(CmpInst::makeCmpResultType(LHS->getType()), 0); 100025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ord && ueq -> ord && (uno || eq) -> oeq 1001f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return getFCmpValue(true, Op1Pred, Op0LHS, Op0RHS, Builder); 100225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 100325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 100425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 100525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return 0; 100625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 100725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 100825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 100925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris LattnerInstruction *InstCombiner::visitAnd(BinaryOperator &I) { 1010096aa79276b8527a3cbbb3691e40e729dea09523Duncan Sands bool Changed = SimplifyAssociativeOrCommutative(I); 101125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1); 101225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 101325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Value *V = SimplifyAndInst(Op0, Op1, TD)) 101425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return ReplaceInstUsesWith(I, V); 101525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 101637bf92b5238434b00fde79347ba5336e7554e562Duncan Sands // (A|B)&(A|C) -> A|(B&C) etc 101737bf92b5238434b00fde79347ba5336e7554e562Duncan Sands if (Value *V = SimplifyUsingDistributiveLaws(I)) 101837bf92b5238434b00fde79347ba5336e7554e562Duncan Sands return ReplaceInstUsesWith(I, V); 10195057f381418ddc8c96699c40479ead993cd62e7bDuncan Sands 102041a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper // See if we can simplify any instructions used by the instruction whose sole 102125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // purpose is to compute bits we don't care about. 102225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (SimplifyDemandedInstructionBits(I)) 102341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper return &I; 102425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 102525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ConstantInt *AndRHS = dyn_cast<ConstantInt>(Op1)) { 102625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner const APInt &AndRHSMask = AndRHS->getValue(); 102725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 102825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Optimize a variety of ((val OP C1) & C2) combinations... 102925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (BinaryOperator *Op0I = dyn_cast<BinaryOperator>(Op0)) { 103025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Op0LHS = Op0I->getOperand(0); 103125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Op0RHS = Op0I->getOperand(1); 103225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (Op0I->getOpcode()) { 103325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: break; 103425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case Instruction::Xor: 103544cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner case Instruction::Or: { 103625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If the mask is only needed on one incoming arm, push it up. 103725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (!Op0I->hasOneUse()) break; 103841a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 103944cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner APInt NotAndRHS(~AndRHSMask); 104025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (MaskedValueIsZero(Op0LHS, NotAndRHS)) { 104125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Not masking anything out for the LHS, move to RHS. 104225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NewRHS = Builder->CreateAnd(Op0RHS, AndRHS, 104325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op0RHS->getName()+".masked"); 104425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::Create(Op0I->getOpcode(), Op0LHS, NewRHS); 104525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 104625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (!isa<Constant>(Op0RHS) && 104725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner MaskedValueIsZero(Op0RHS, NotAndRHS)) { 104825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Not masking anything out for the RHS, move to LHS. 104925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NewLHS = Builder->CreateAnd(Op0LHS, AndRHS, 105025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op0LHS->getName()+".masked"); 105125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::Create(Op0I->getOpcode(), NewLHS, Op0RHS); 105225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 105325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 105425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 105544cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner } 105625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case Instruction::Add: 105794c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // ((A & N) + B) & AndRHS -> (A + B) & AndRHS iff N&AndRHS == AndRHS. 105894c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // ((A | N) + B) & AndRHS -> (A + B) & AndRHS iff N&AndRHS == 0 105994c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // ((A ^ N) + B) & AndRHS -> (A + B) & AndRHS iff N&AndRHS == 0 106025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Value *V = FoldLogicalPlusAnd(Op0LHS, Op0RHS, AndRHS, false, I)) 106125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateAnd(V, AndRHS); 106225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Value *V = FoldLogicalPlusAnd(Op0RHS, Op0LHS, AndRHS, false, I)) 106325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateAnd(V, AndRHS); // Add commutes 106425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 106525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 106625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case Instruction::Sub: 106794c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // ((A & N) - B) & AndRHS -> (A - B) & AndRHS iff N&AndRHS == AndRHS. 106894c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // ((A | N) - B) & AndRHS -> (A - B) & AndRHS iff N&AndRHS == 0 106994c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // ((A ^ N) - B) & AndRHS -> (A - B) & AndRHS iff N&AndRHS == 0 107025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Value *V = FoldLogicalPlusAnd(Op0LHS, Op0RHS, AndRHS, true, I)) 107125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateAnd(V, AndRHS); 107225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 107394c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // (A - N) & AndRHS -> -N & AndRHS iff A&AndRHS==0 and AndRHS 107425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // has 1's for all bits that the subtraction with A might affect. 107544cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner if (Op0I->hasOneUse() && !match(Op0LHS, m_Zero())) { 107625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner uint32_t BitWidth = AndRHSMask.getBitWidth(); 107725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner uint32_t Zeros = AndRHSMask.countLeadingZeros(); 107825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner APInt Mask = APInt::getLowBitsSet(BitWidth, BitWidth - Zeros); 107925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 108044cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner if (MaskedValueIsZero(Op0LHS, Mask)) { 108125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NewNeg = Builder->CreateNeg(Op0RHS); 108225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateAnd(NewNeg, AndRHS); 108325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 108425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 108525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 108625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 108725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case Instruction::Shl: 108825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case Instruction::LShr: 108925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (1 << x) & 1 --> zext(x == 0) 109025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (1 >> x) & 1 --> zext(x == 0) 109125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (AndRHSMask == 1 && Op0LHS == AndRHS) { 109225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NewICmp = 109325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Builder->CreateICmpEQ(Op0RHS, Constant::getNullValue(I.getType())); 109425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return new ZExtInst(NewICmp, I.getType()); 109525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 109625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 109725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 109841a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 109925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ConstantInt *Op0CI = dyn_cast<ConstantInt>(Op0I->getOperand(1))) 110025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Instruction *Res = OptAndOp(Op0I, Op0CI, AndRHS, I)) 110125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return Res; 110244cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner } 110341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 110444cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner // If this is an integer truncation, and if the source is an 'and' with 110544cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner // immediate, transform it. This frequently occurs for bitfield accesses. 110644cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner { 110744cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner Value *X = 0; ConstantInt *YC = 0; 110844cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner if (match(Op0, m_Trunc(m_And(m_Value(X), m_ConstantInt(YC))))) { 110944cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner // Change: and (trunc (and X, YC) to T), C2 111044cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner // into : and (trunc X to T), trunc(YC) & C2 111141a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper // This will fold the two constants together, which may allow 111244cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner // other simplifications. 111344cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner Value *NewCast = Builder->CreateTrunc(X, I.getType(), "and.shrunk"); 111444cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner Constant *C3 = ConstantExpr::getTrunc(YC, I.getType()); 111544cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner C3 = ConstantExpr::getAnd(C3, AndRHS); 111644cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner return BinaryOperator::CreateAnd(NewCast, C3); 111725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 111825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 111925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 112025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Try to fold constant and into select arguments. 112125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (SelectInst *SI = dyn_cast<SelectInst>(Op0)) 112225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Instruction *R = FoldOpIntoSelect(I, SI)) 112325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return R; 112425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (isa<PHINode>(Op0)) 112525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Instruction *NV = FoldOpIntoPhi(I)) 112625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return NV; 112725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 112825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 112925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 113025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (~A & ~B) == (~(A | B)) - De Morgan's Law 113125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Value *Op0NotVal = dyn_castNotVal(Op0)) 113225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Value *Op1NotVal = dyn_castNotVal(Op1)) 113325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0->hasOneUse() && Op1->hasOneUse()) { 113425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Or = Builder->CreateOr(Op0NotVal, Op1NotVal, 113525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner I.getName()+".demorgan"); 113625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateNot(Or); 113725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 113841a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 113925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner { 114025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *A = 0, *B = 0, *C = 0, *D = 0; 114125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (A|B) & ~(A&B) -> A^B 114225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (match(Op0, m_Or(m_Value(A), m_Value(B))) && 114325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(Op1, m_Not(m_And(m_Value(C), m_Value(D)))) && 114425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ((A == C && B == D) || (A == D && B == C))) 114525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateXor(A, B); 114641a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 114725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ~(A&B) & (A|B) -> A^B 114825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (match(Op1, m_Or(m_Value(A), m_Value(B))) && 114925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(Op0, m_Not(m_And(m_Value(C), m_Value(D)))) && 115025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ((A == C && B == D) || (A == D && B == C))) 115125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateXor(A, B); 115241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 1153c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman // A&(A^B) => A & ~B 1154c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman { 1155c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman Value *tmpOp0 = Op0; 1156c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman Value *tmpOp1 = Op1; 1157c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman if (Op0->hasOneUse() && 1158c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman match(Op0, m_Xor(m_Value(A), m_Value(B)))) { 1159c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman if (A == Op1 || B == Op1 ) { 1160c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman tmpOp1 = Op0; 1161c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman tmpOp0 = Op1; 1162c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman // Simplify below 1163c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman } 116425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 116525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 1166c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman if (tmpOp1->hasOneUse() && 1167c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman match(tmpOp1, m_Xor(m_Value(A), m_Value(B)))) { 1168c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman if (B == tmpOp0) { 1169c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman std::swap(A, B); 1170c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman } 1171c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman // Notice that the patten (A&(~B)) is actually (A&(-1^B)), so if 1172c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman // A is originally -1 (or a vector of -1 and undefs), then we enter 1173c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman // an endless loop. By checking that A is non-constant we ensure that 1174c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman // we will never get to the loop. 1175c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman if (A == tmpOp0 && !isa<Constant>(A)) // A&(A^B) -> A & ~B 1176a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer return BinaryOperator::CreateAnd(A, Builder->CreateNot(B)); 117725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 117825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 117925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 118025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (A&((~A)|B)) -> A&B 118125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (match(Op0, m_Or(m_Not(m_Specific(Op1)), m_Value(A))) || 118225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(Op0, m_Or(m_Value(A), m_Not(m_Specific(Op1))))) 118325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateAnd(A, Op1); 118425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (match(Op1, m_Or(m_Not(m_Specific(Op0)), m_Value(A))) || 118525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(Op1, m_Or(m_Value(A), m_Not(m_Specific(Op0))))) 118625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateAnd(A, Op0); 118725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 118841a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 118925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ICmpInst *RHS = dyn_cast<ICmpInst>(Op1)) 119025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ICmpInst *LHS = dyn_cast<ICmpInst>(Op0)) 1191f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner if (Value *Res = FoldAndOfICmps(LHS, RHS)) 1192f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return ReplaceInstUsesWith(I, Res); 119341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 11948c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner // If and'ing two fcmp, try combine them into one. 11958c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner if (FCmpInst *LHS = dyn_cast<FCmpInst>(I.getOperand(0))) 11968c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner if (FCmpInst *RHS = dyn_cast<FCmpInst>(I.getOperand(1))) 1197f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner if (Value *Res = FoldAndOfFCmps(LHS, RHS)) 1198f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return ReplaceInstUsesWith(I, Res); 119941a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 120041a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 120125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // fold (and (cast A), (cast B)) -> (cast (and A, B)) 120225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (CastInst *Op0C = dyn_cast<CastInst>(Op0)) 12038c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner if (CastInst *Op1C = dyn_cast<CastInst>(Op1)) { 1204db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *SrcTy = Op0C->getOperand(0)->getType(); 12058c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner if (Op0C->getOpcode() == Op1C->getOpcode() && // same cast kind ? 12068c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner SrcTy == Op1C->getOperand(0)->getType() && 1207b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands SrcTy->isIntOrIntVectorTy()) { 12088c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner Value *Op0COp = Op0C->getOperand(0), *Op1COp = Op1C->getOperand(0); 120941a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 12108c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner // Only do this if the casts both really cause code to be generated. 12118c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner if (ShouldOptimizeCast(Op0C->getOpcode(), Op0COp, I.getType()) && 12128c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner ShouldOptimizeCast(Op1C->getOpcode(), Op1COp, I.getType())) { 12138c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner Value *NewOp = Builder->CreateAnd(Op0COp, Op1COp, I.getName()); 121425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return CastInst::Create(Op0C->getOpcode(), NewOp, I.getType()); 121525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 121641a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 12178c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner // If this is and(cast(icmp), cast(icmp)), try to fold this even if the 12188c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner // cast is otherwise not optimizable. This happens for vector sexts. 12198c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner if (ICmpInst *RHS = dyn_cast<ICmpInst>(Op1COp)) 12208c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner if (ICmpInst *LHS = dyn_cast<ICmpInst>(Op0COp)) 1221f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner if (Value *Res = FoldAndOfICmps(LHS, RHS)) 12228c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner return CastInst::Create(Op0C->getOpcode(), Res, I.getType()); 122341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 12248c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner // If this is and(cast(fcmp), cast(fcmp)), try to fold this even if the 12258c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner // cast is otherwise not optimizable. This happens for vector sexts. 12268c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner if (FCmpInst *RHS = dyn_cast<FCmpInst>(Op1COp)) 12278c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner if (FCmpInst *LHS = dyn_cast<FCmpInst>(Op0COp)) 1228f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner if (Value *Res = FoldAndOfFCmps(LHS, RHS)) 12298c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner return CastInst::Create(Op0C->getOpcode(), Res, I.getType()); 123025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 12318c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner } 123241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 123325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (X >> Z) & (Y >> Z) -> (X&Y) >> Z for all shifts. 123425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (BinaryOperator *SI1 = dyn_cast<BinaryOperator>(Op1)) { 123525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (BinaryOperator *SI0 = dyn_cast<BinaryOperator>(Op0)) 123641a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper if (SI0->isShift() && SI0->getOpcode() == SI1->getOpcode() && 123725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner SI0->getOperand(1) == SI1->getOperand(1) && 123825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner (SI0->hasOneUse() || SI1->hasOneUse())) { 123925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NewOp = 124025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Builder->CreateAnd(SI0->getOperand(0), SI1->getOperand(0), 124125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner SI0->getName()); 124241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper return BinaryOperator::Create(SI1->getOpcode(), NewOp, 124325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner SI1->getOperand(1)); 124425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 124525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 124625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 1247cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem { 1248cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem Value *X = 0; 1249cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem bool OpsSwapped = false; 1250cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem // Canonicalize SExt or Not to the LHS 1251cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem if (match(Op1, m_SExt(m_Value())) || 1252cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem match(Op1, m_Not(m_Value()))) { 1253cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem std::swap(Op0, Op1); 1254cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem OpsSwapped = true; 1255cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem } 1256cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem 1257cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem // Fold (and (sext bool to A), B) --> (select bool, B, 0) 1258cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem if (match(Op0, m_SExt(m_Value(X))) && 1259cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem X->getType()->getScalarType()->isIntegerTy(1)) { 1260cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem Value *Zero = Constant::getNullValue(Op1->getType()); 1261cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem return SelectInst::Create(X, Op1, Zero); 1262cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem } 1263cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem 1264cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem // Fold (and ~(sext bool to A), B) --> (select bool, 0, B) 1265cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem if (match(Op0, m_Not(m_SExt(m_Value(X)))) && 1266cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem X->getType()->getScalarType()->isIntegerTy(1)) { 1267cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem Value *Zero = Constant::getNullValue(Op0->getType()); 1268cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem return SelectInst::Create(X, Zero, Op1); 1269cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem } 1270cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem 1271cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem if (OpsSwapped) 1272cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem std::swap(Op0, Op1); 1273cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem } 1274cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem 127525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return Changed ? &I : 0; 127625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 127725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 127825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// CollectBSwapParts - Analyze the specified subexpression and see if it is 127925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// capable of providing pieces of a bswap. The subexpression provides pieces 128025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// of a bswap if it is proven that each of the non-zero bytes in the output of 128125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// the expression came from the corresponding "byte swapped" byte in some other 128225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// value. For example, if the current subexpression is "(shl i32 %X, 24)" then 128325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// we know that the expression deposits the low byte of %X into the high byte 128425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// of the bswap result and that all other bytes are zero. This expression is 128525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// accepted, the high byte of ByteValues is set to X to indicate a correct 128625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// match. 128725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// 128825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// This function returns true if the match was unsuccessful and false if so. 128925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// On entry to the function the "OverallLeftShift" is a signed integer value 129025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// indicating the number of bytes that the subexpression is later shifted. For 129125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// example, if the expression is later right shifted by 16 bits, the 129225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// OverallLeftShift value would be -2 on entry. This is used to specify which 129325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// byte of ByteValues is actually being set. 129425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// 129525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// Similarly, ByteMask is a bitmask where a bit is clear if its corresponding 129625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// byte is masked to zero by a user. For example, in (X & 255), X will be 129725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// processed with a bytemask of 1. Because bytemask is 32-bits, this limits 129825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// this function to working on up to 32-byte (256 bit) values. ByteMask is 129925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// always in the local (OverallLeftShift) coordinate space. 130025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// 130125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattnerstatic bool CollectBSwapParts(Value *V, int OverallLeftShift, uint32_t ByteMask, 130225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner SmallVector<Value*, 8> &ByteValues) { 130325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Instruction *I = dyn_cast<Instruction>(V)) { 130425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If this is an or instruction, it may be an inner node of the bswap. 130525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (I->getOpcode() == Instruction::Or) { 130625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return CollectBSwapParts(I->getOperand(0), OverallLeftShift, ByteMask, 130725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ByteValues) || 130825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner CollectBSwapParts(I->getOperand(1), OverallLeftShift, ByteMask, 130925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ByteValues); 131025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 131141a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 131225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If this is a logical shift by a constant multiple of 8, recurse with 131325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // OverallLeftShift and ByteMask adjusted. 131425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (I->isLogicalShift() && isa<ConstantInt>(I->getOperand(1))) { 131541a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper unsigned ShAmt = 131625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner cast<ConstantInt>(I->getOperand(1))->getLimitedValue(~0U); 131725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Ensure the shift amount is defined and of a byte value. 131825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if ((ShAmt & 7) || (ShAmt > 8*ByteValues.size())) 131925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return true; 132025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 132125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner unsigned ByteShift = ShAmt >> 3; 132225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (I->getOpcode() == Instruction::Shl) { 132325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // X << 2 -> collect(X, +2) 132425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner OverallLeftShift += ByteShift; 132525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ByteMask >>= ByteShift; 132625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } else { 132725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // X >>u 2 -> collect(X, -2) 132825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner OverallLeftShift -= ByteShift; 132925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ByteMask <<= ByteShift; 133025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ByteMask &= (~0U >> (32-ByteValues.size())); 133125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 133225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 133325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (OverallLeftShift >= (int)ByteValues.size()) return true; 133425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (OverallLeftShift <= -(int)ByteValues.size()) return true; 133525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 133641a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper return CollectBSwapParts(I->getOperand(0), OverallLeftShift, ByteMask, 133725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ByteValues); 133825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 133925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 134025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If this is a logical 'and' with a mask that clears bytes, clear the 134125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // corresponding bytes in ByteMask. 134225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (I->getOpcode() == Instruction::And && 134325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner isa<ConstantInt>(I->getOperand(1))) { 134425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Scan every byte of the and mask, seeing if the byte is either 0 or 255. 134525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner unsigned NumBytes = ByteValues.size(); 134625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner APInt Byte(I->getType()->getPrimitiveSizeInBits(), 255); 134725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner const APInt &AndMask = cast<ConstantInt>(I->getOperand(1))->getValue(); 134841a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 134925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner for (unsigned i = 0; i != NumBytes; ++i, Byte <<= 8) { 135025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If this byte is masked out by a later operation, we don't care what 135125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // the and mask is. 135225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if ((ByteMask & (1 << i)) == 0) 135325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner continue; 135441a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 135525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If the AndMask is all zeros for this byte, clear the bit. 135625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner APInt MaskB = AndMask & Byte; 135725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (MaskB == 0) { 135825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ByteMask &= ~(1U << i); 135925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner continue; 136025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 136141a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 136225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If the AndMask is not all ones for this byte, it's not a bytezap. 136325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (MaskB != Byte) 136425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return true; 136525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 136625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Otherwise, this byte is kept. 136725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 136825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 136941a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper return CollectBSwapParts(I->getOperand(0), OverallLeftShift, ByteMask, 137025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ByteValues); 137125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 137225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 137341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 137425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Okay, we got to something that isn't a shift, 'or' or 'and'. This must be 137525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // the input value to the bswap. Some observations: 1) if more than one byte 137625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // is demanded from this input, then it could not be successfully assembled 137725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // into a byteswap. At least one of the two bytes would not be aligned with 137825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // their ultimate destination. 137925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (!isPowerOf2_32(ByteMask)) return true; 1380c6af2432c802d241c8fffbe0371c023e6c58844eMichael J. Spencer unsigned InputByteNo = countTrailingZeros(ByteMask); 138141a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 138225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // 2) The input and ultimate destinations must line up: if byte 3 of an i32 138325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // is demanded, it needs to go into byte 0 of the result. This means that the 138425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // byte needs to be shifted until it lands in the right byte bucket. The 138525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // shift amount depends on the position: if the byte is coming from the high 138625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // part of the value (e.g. byte 3) then it must be shifted right. If from the 138725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // low part, it must be shifted left. 138825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner unsigned DestByteNo = InputByteNo + OverallLeftShift; 1389de813b7108de64829ab006e6b998a7b38d119eccChris Lattner if (ByteValues.size()-1-DestByteNo != InputByteNo) 1390de813b7108de64829ab006e6b998a7b38d119eccChris Lattner return true; 139141a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 139225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If the destination byte value is already defined, the values are or'd 139325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // together, which isn't a bswap (unless it's an or of the same bits). 139425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ByteValues[DestByteNo] && ByteValues[DestByteNo] != V) 139525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return true; 139625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ByteValues[DestByteNo] = V; 139725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return false; 139825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 139925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 140025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// MatchBSwap - Given an OR instruction, check to see if this is a bswap idiom. 140125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// If so, insert the new bswap intrinsic and return it. 140225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris LattnerInstruction *InstCombiner::MatchBSwap(BinaryOperator &I) { 14035fdd6c8793462549e3593890ec61573da06e3346Jay Foad IntegerType *ITy = dyn_cast<IntegerType>(I.getType()); 140441a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper if (!ITy || ITy->getBitWidth() % 16 || 140525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ByteMask only allows up to 32-byte values. 140641a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper ITy->getBitWidth() > 32*8) 140725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return 0; // Can only bswap pairs of bytes. Can't do vectors. 140841a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 140925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner /// ByteValues - For each byte of the result, we keep track of which value 141025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner /// defines each byte. 141125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner SmallVector<Value*, 8> ByteValues; 141225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ByteValues.resize(ITy->getBitWidth()/8); 141341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 141425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Try to find all the pieces corresponding to the bswap. 141525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner uint32_t ByteMask = ~0U >> (32-ByteValues.size()); 141625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (CollectBSwapParts(&I, 0, ByteMask, ByteValues)) 141725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return 0; 141841a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 141925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Check to see if all of the bytes come from the same value. 142025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *V = ByteValues[0]; 142125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (V == 0) return 0; // Didn't find a byte? Must be zero. 142241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 142325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Check to make sure that all of the bytes come from the same value. 142425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner for (unsigned i = 1, e = ByteValues.size(); i != e; ++i) 142525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ByteValues[i] != V) 142625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return 0; 142725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Module *M = I.getParent()->getParent()->getParent(); 1428eb9a85f09e18b3fe88499710404b38d3a9128f62Benjamin Kramer Function *F = Intrinsic::getDeclaration(M, Intrinsic::bswap, ITy); 142925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return CallInst::Create(F, V); 143025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 143125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 143225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// MatchSelectFromAndOr - We have an expression of the form (A&C)|(B&D). Check 143325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// If A is (cond?-1:0) and either B or D is ~(cond?-1,0) or (cond?0,-1), then 143425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// we can simplify this expression to "cond ? C : D or B". 143525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattnerstatic Instruction *MatchSelectFromAndOr(Value *A, Value *B, 143625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *C, Value *D) { 143725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If A is not a select of -1/0, this cannot match. 143825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Cond = 0; 1439e538db4fb0ec30500da721a2a698946fa36db1a8Chris Lattner if (!match(A, m_SExt(m_Value(Cond))) || 1440b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands !Cond->getType()->isIntegerTy(1)) 144125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return 0; 144225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 144325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ((cond?-1:0)&C) | (B&(cond?0:-1)) -> cond ? C : B. 1444e576f292ee5f7af40489a68fa626d53a14e46a10Chris Lattner if (match(D, m_Not(m_SExt(m_Specific(Cond))))) 144525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return SelectInst::Create(Cond, C, B); 1446e576f292ee5f7af40489a68fa626d53a14e46a10Chris Lattner if (match(D, m_SExt(m_Not(m_Specific(Cond))))) 144774529826a70546d71c6558e9a3917244a87acfe9Chris Lattner return SelectInst::Create(Cond, C, B); 144841a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 144925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ((cond?-1:0)&C) | ((cond?0:-1)&D) -> cond ? C : D. 1450e576f292ee5f7af40489a68fa626d53a14e46a10Chris Lattner if (match(B, m_Not(m_SExt(m_Specific(Cond))))) 145174529826a70546d71c6558e9a3917244a87acfe9Chris Lattner return SelectInst::Create(Cond, C, D); 1452e576f292ee5f7af40489a68fa626d53a14e46a10Chris Lattner if (match(B, m_SExt(m_Not(m_Specific(Cond))))) 145325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return SelectInst::Create(Cond, C, D); 145425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return 0; 145525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 145625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 1457f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner/// FoldOrOfICmps - Fold (icmp)|(icmp) if possible. 1458f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris LattnerValue *InstCombiner::FoldOrOfICmps(ICmpInst *LHS, ICmpInst *RHS) { 145925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ICmpInst::Predicate LHSCC = LHS->getPredicate(), RHSCC = RHS->getPredicate(); 146025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 146125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (icmp1 A, B) | (icmp2 A, B) --> (icmp3 A, B) 146225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (PredicatesFoldable(LHSCC, RHSCC)) { 146325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHS->getOperand(0) == RHS->getOperand(1) && 146425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner LHS->getOperand(1) == RHS->getOperand(0)) 146525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner LHS->swapOperands(); 146625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHS->getOperand(0) == RHS->getOperand(0) && 146725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner LHS->getOperand(1) == RHS->getOperand(1)) { 146825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Op0 = LHS->getOperand(0), *Op1 = LHS->getOperand(1); 146925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner unsigned Code = getICmpCode(LHS) | getICmpCode(RHS); 147025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner bool isSigned = LHS->isSigned() || RHS->isSigned(); 14712e33944c101f2a08ed1d85e807830f2fc089dd06Pete Cooper return getNewICmpValue(isSigned, Code, Op0, Op1, Builder); 147225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 147325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 14744dc1ac094714a5866b9d32c6bbf2ecaa672fde48Benjamin Kramer 14754dc1ac094714a5866b9d32c6bbf2ecaa672fde48Benjamin Kramer // handle (roughly): 14764dc1ac094714a5866b9d32c6bbf2ecaa672fde48Benjamin Kramer // (icmp ne (A & B), C) | (icmp ne (A & D), E) 14774dc1ac094714a5866b9d32c6bbf2ecaa672fde48Benjamin Kramer if (Value *V = foldLogOpOfMaskedICmps(LHS, RHS, ICmpInst::ICMP_NE, Builder)) 14784dc1ac094714a5866b9d32c6bbf2ecaa672fde48Benjamin Kramer return V; 14795c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson 148025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // This only handles icmp of constants: (icmp1 A, C1) | (icmp2 B, C2). 148125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Val = LHS->getOperand(0), *Val2 = RHS->getOperand(0); 148225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt *LHSCst = dyn_cast<ConstantInt>(LHS->getOperand(1)); 148325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt *RHSCst = dyn_cast<ConstantInt>(RHS->getOperand(1)); 148425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHSCst == 0 || RHSCst == 0) return 0; 148525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 148661378363b76ad84dc7effff506d7c3e991225743Owen Anderson if (LHSCst == RHSCst && LHSCC == RHSCC) { 148761378363b76ad84dc7effff506d7c3e991225743Owen Anderson // (icmp ne A, 0) | (icmp ne B, 0) --> (icmp ne (A|B), 0) 148861378363b76ad84dc7effff506d7c3e991225743Owen Anderson if (LHSCC == ICmpInst::ICMP_NE && LHSCst->isZero()) { 148961378363b76ad84dc7effff506d7c3e991225743Owen Anderson Value *NewOr = Builder->CreateOr(Val, Val2); 149061378363b76ad84dc7effff506d7c3e991225743Owen Anderson return Builder->CreateICmp(LHSCC, NewOr, LHSCst); 149161378363b76ad84dc7effff506d7c3e991225743Owen Anderson } 1492dfb806f6ba53b792171b928b57def9d0182d2f5fBenjamin Kramer } 1493dfb806f6ba53b792171b928b57def9d0182d2f5fBenjamin Kramer 1494b0de244f23c2e11505cab729f198dfaaa2028532Benjamin Kramer // (icmp ult (X + CA), C1) | (icmp eq X, C2) -> (icmp ule (X + CA), C1) 149594c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // iff C2 + CA == C1. 1496b0de244f23c2e11505cab729f198dfaaa2028532Benjamin Kramer if (LHSCC == ICmpInst::ICMP_ULT && RHSCC == ICmpInst::ICMP_EQ) { 14975337f20c1516296edcea6bc3da6cdc74329142aeBenjamin Kramer ConstantInt *AddCst; 14985337f20c1516296edcea6bc3da6cdc74329142aeBenjamin Kramer if (match(Val, m_Add(m_Specific(Val2), m_ConstantInt(AddCst)))) 14995337f20c1516296edcea6bc3da6cdc74329142aeBenjamin Kramer if (RHSCst->getValue() + AddCst->getValue() == LHSCst->getValue()) 1500b0de244f23c2e11505cab729f198dfaaa2028532Benjamin Kramer return Builder->CreateICmpULE(Val, LHSCst); 15015337f20c1516296edcea6bc3da6cdc74329142aeBenjamin Kramer } 15025337f20c1516296edcea6bc3da6cdc74329142aeBenjamin Kramer 150325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // From here on, we only handle: 150425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (icmp1 A, C1) | (icmp2 A, C2) --> something simpler. 150525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Val != Val2) return 0; 150641a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 150725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ICMP_[US][GL]E X, CST is folded to ICMP_[US][GL]T elsewhere. 150825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHSCC == ICmpInst::ICMP_UGE || LHSCC == ICmpInst::ICMP_ULE || 150925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner RHSCC == ICmpInst::ICMP_UGE || RHSCC == ICmpInst::ICMP_ULE || 151025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner LHSCC == ICmpInst::ICMP_SGE || LHSCC == ICmpInst::ICMP_SLE || 151125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner RHSCC == ICmpInst::ICMP_SGE || RHSCC == ICmpInst::ICMP_SLE) 151225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return 0; 151341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 151425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // We can't fold (ugt x, C) | (sgt x, C2). 151525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (!PredicatesFoldable(LHSCC, RHSCC)) 151625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return 0; 151741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 151825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Ensure that the larger constant is on the RHS. 151925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner bool ShouldSwap; 152025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (CmpInst::isSigned(LHSCC) || 152141a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper (ICmpInst::isEquality(LHSCC) && 152225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner CmpInst::isSigned(RHSCC))) 152325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ShouldSwap = LHSCst->getValue().sgt(RHSCst->getValue()); 152425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner else 152525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ShouldSwap = LHSCst->getValue().ugt(RHSCst->getValue()); 152641a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 152725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ShouldSwap) { 152825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(LHS, RHS); 152925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(LHSCst, RHSCst); 153025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(LHSCC, RHSCC); 153125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 153241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 1533f451cb870efcf9e0302d25ed05f4cac6bb494e42Dan Gohman // At this point, we know we have two icmp instructions 153425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // comparing a value against two constants and or'ing the result 153525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // together. Because of the above check, we know that we only have 153625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ICMP_EQ, ICMP_NE, ICMP_LT, and ICMP_GT here. We also know (from the 153725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // icmp folding check above), that the two constants are not 153825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // equal. 153925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner assert(LHSCst != RHSCst && "Compares not folded above?"); 154025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 154125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (LHSCC) { 154225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: llvm_unreachable("Unknown integer condition code!"); 154325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_EQ: 154425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (RHSCC) { 154525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: llvm_unreachable("Unknown integer condition code!"); 154625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_EQ: 1547d60b8ac64fa161646d50c49d6171cb49e6a2c7eeJakub Staszak if (LHS->getOperand(0) == RHS->getOperand(0)) { 1548b6d9c4181a57a4b57d92a4437761387606f49c2dJakub Staszak // if LHSCst and RHSCst differ only by one bit: 1549d60b8ac64fa161646d50c49d6171cb49e6a2c7eeJakub Staszak // (A == C1 || A == C2) -> (A & ~(C1 ^ C2)) == C1 1550526057921dcb57e0d51d60ddb0f5ce16596c307fJakub Staszak assert(LHSCst->getValue().ule(LHSCst->getValue())); 1551526057921dcb57e0d51d60ddb0f5ce16596c307fJakub Staszak 1552d60b8ac64fa161646d50c49d6171cb49e6a2c7eeJakub Staszak APInt Xor = LHSCst->getValue() ^ RHSCst->getValue(); 1553d60b8ac64fa161646d50c49d6171cb49e6a2c7eeJakub Staszak if (Xor.isPowerOf2()) { 1554d60b8ac64fa161646d50c49d6171cb49e6a2c7eeJakub Staszak Value *NegCst = Builder->getInt(~Xor); 1555d60b8ac64fa161646d50c49d6171cb49e6a2c7eeJakub Staszak Value *And = Builder->CreateAnd(LHS->getOperand(0), NegCst); 1556d60b8ac64fa161646d50c49d6171cb49e6a2c7eeJakub Staszak return Builder->CreateICmp(ICmpInst::ICMP_EQ, And, LHSCst); 1557d60b8ac64fa161646d50c49d6171cb49e6a2c7eeJakub Staszak } 1558d60b8ac64fa161646d50c49d6171cb49e6a2c7eeJakub Staszak } 1559d60b8ac64fa161646d50c49d6171cb49e6a2c7eeJakub Staszak 1560024d943bca85ee0b6bc1b9e5f13ec5276f16c13dDavid Majnemer if (LHSCst == SubOne(RHSCst)) { 1561024d943bca85ee0b6bc1b9e5f13ec5276f16c13dDavid Majnemer // (X == 13 | X == 14) -> X-13 <u 2 1562024d943bca85ee0b6bc1b9e5f13ec5276f16c13dDavid Majnemer Constant *AddCST = ConstantExpr::getNeg(LHSCst); 1563024d943bca85ee0b6bc1b9e5f13ec5276f16c13dDavid Majnemer Value *Add = Builder->CreateAdd(Val, AddCST, Val->getName()+".off"); 1564024d943bca85ee0b6bc1b9e5f13ec5276f16c13dDavid Majnemer AddCST = ConstantExpr::getSub(AddOne(RHSCst), LHSCst); 1565024d943bca85ee0b6bc1b9e5f13ec5276f16c13dDavid Majnemer return Builder->CreateICmpULT(Add, AddCST); 1566024d943bca85ee0b6bc1b9e5f13ec5276f16c13dDavid Majnemer } 1567024d943bca85ee0b6bc1b9e5f13ec5276f16c13dDavid Majnemer 156825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; // (X == 13 | X == 15) -> no change 156925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_UGT: // (X == 13 | X u> 14) -> no change 157025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SGT: // (X == 13 | X s> 14) -> no change 157125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 157225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_NE: // (X == 13 | X != 15) -> X != 15 157325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_ULT: // (X == 13 | X u< 15) -> X u< 15 157425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SLT: // (X == 13 | X s< 15) -> X s< 15 1575f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return RHS; 157625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 157725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 157825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_NE: 157925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (RHSCC) { 158025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: llvm_unreachable("Unknown integer condition code!"); 158125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_EQ: // (X != 13 | X == 15) -> X != 13 158225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_UGT: // (X != 13 | X u> 15) -> X != 13 158325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SGT: // (X != 13 | X s> 15) -> X != 13 1584f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return LHS; 158525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_NE: // (X != 13 | X != 15) -> true 158625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_ULT: // (X != 13 | X u< 15) -> true 158725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SLT: // (X != 13 | X s< 15) -> true 1588f2d03d74ffe05d08ac7dccbb81f41d996a1f1d2aJakub Staszak return Builder->getTrue(); 158925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 159025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_ULT: 159125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (RHSCC) { 159225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: llvm_unreachable("Unknown integer condition code!"); 159325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_EQ: // (X u< 13 | X == 14) -> no change 159425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 159525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_UGT: // (X u< 13 | X u> 15) -> (X-13) u> 2 159625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If RHSCst is [us]MAXINT, it is always false. Not handling 159725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // this can cause overflow. 159825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (RHSCst->isMaxValue(false)) 1599f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return LHS; 1600f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return InsertRangeTest(Val, LHSCst, AddOne(RHSCst), false, false); 160125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SGT: // (X u< 13 | X s> 15) -> no change 160225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 160325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_NE: // (X u< 13 | X != 15) -> X != 15 160425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_ULT: // (X u< 13 | X u< 15) -> X u< 15 1605f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return RHS; 160625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SLT: // (X u< 13 | X s< 15) -> no change 160725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 160825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 160925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 161025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SLT: 161125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (RHSCC) { 161225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: llvm_unreachable("Unknown integer condition code!"); 161325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_EQ: // (X s< 13 | X == 14) -> no change 161425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 161525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SGT: // (X s< 13 | X s> 15) -> (X-13) s> 2 161625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If RHSCst is [us]MAXINT, it is always false. Not handling 161725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // this can cause overflow. 161825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (RHSCst->isMaxValue(true)) 1619f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return LHS; 1620f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return InsertRangeTest(Val, LHSCst, AddOne(RHSCst), true, false); 162125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_UGT: // (X s< 13 | X u> 15) -> no change 162225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 162325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_NE: // (X s< 13 | X != 15) -> X != 15 162425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SLT: // (X s< 13 | X s< 15) -> X s< 15 1625f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return RHS; 162625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_ULT: // (X s< 13 | X u< 15) -> no change 162725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 162825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 162925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 163025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_UGT: 163125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (RHSCC) { 163225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: llvm_unreachable("Unknown integer condition code!"); 163325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_EQ: // (X u> 13 | X == 15) -> X u> 13 163425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_UGT: // (X u> 13 | X u> 15) -> X u> 13 1635f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return LHS; 163625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SGT: // (X u> 13 | X s> 15) -> no change 163725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 163825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_NE: // (X u> 13 | X != 15) -> true 163925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_ULT: // (X u> 13 | X u< 15) -> true 1640f2d03d74ffe05d08ac7dccbb81f41d996a1f1d2aJakub Staszak return Builder->getTrue(); 164125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SLT: // (X u> 13 | X s< 15) -> no change 164225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 164325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 164425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 164525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SGT: 164625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (RHSCC) { 164725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: llvm_unreachable("Unknown integer condition code!"); 164825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_EQ: // (X s> 13 | X == 15) -> X > 13 164925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SGT: // (X s> 13 | X s> 15) -> X > 13 1650f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return LHS; 165125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_UGT: // (X s> 13 | X u> 15) -> no change 165225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 165325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_NE: // (X s> 13 | X != 15) -> true 165425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SLT: // (X s> 13 | X s< 15) -> true 1655f2d03d74ffe05d08ac7dccbb81f41d996a1f1d2aJakub Staszak return Builder->getTrue(); 165625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_ULT: // (X s> 13 | X u< 15) -> no change 165725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 165825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 165925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 166025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 166125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return 0; 166225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 166325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 1664f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner/// FoldOrOfFCmps - Optimize (fcmp)|(fcmp). NOTE: Unlike the rest of 1665f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner/// instcombine, this returns a Value which should already be inserted into the 1666f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner/// function. 1667f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris LattnerValue *InstCombiner::FoldOrOfFCmps(FCmpInst *LHS, FCmpInst *RHS) { 166825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHS->getPredicate() == FCmpInst::FCMP_UNO && 166941a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper RHS->getPredicate() == FCmpInst::FCMP_UNO && 167025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner LHS->getOperand(0)->getType() == RHS->getOperand(0)->getType()) { 167125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ConstantFP *LHSC = dyn_cast<ConstantFP>(LHS->getOperand(1))) 167225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ConstantFP *RHSC = dyn_cast<ConstantFP>(RHS->getOperand(1))) { 167325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If either of the constants are nans, then the whole thing returns 167425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // true. 167525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHSC->getValueAPF().isNaN() || RHSC->getValueAPF().isNaN()) 1676f2d03d74ffe05d08ac7dccbb81f41d996a1f1d2aJakub Staszak return Builder->getTrue(); 167741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 167825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Otherwise, no need to compare the two constants, compare the 167925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // rest. 1680f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateFCmpUNO(LHS->getOperand(0), RHS->getOperand(0)); 168125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 168241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 168325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Handle vector zeros. This occurs because the canonical form of 168425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // "fcmp uno x,x" is "fcmp uno x, 0". 168525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (isa<ConstantAggregateZero>(LHS->getOperand(1)) && 168625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner isa<ConstantAggregateZero>(RHS->getOperand(1))) 1687f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateFCmpUNO(LHS->getOperand(0), RHS->getOperand(0)); 168841a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 168925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return 0; 169025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 169141a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 169225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Op0LHS = LHS->getOperand(0), *Op0RHS = LHS->getOperand(1); 169325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Op1LHS = RHS->getOperand(0), *Op1RHS = RHS->getOperand(1); 169425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner FCmpInst::Predicate Op0CC = LHS->getPredicate(), Op1CC = RHS->getPredicate(); 169541a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 169625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0LHS == Op1RHS && Op0RHS == Op1LHS) { 169725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Swap RHS operands to match LHS. 169825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op1CC = FCmpInst::getSwappedPredicate(Op1CC); 169925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(Op1LHS, Op1RHS); 170025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 170125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0LHS == Op1LHS && Op0RHS == Op1RHS) { 170225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Simplify (fcmp cc0 x, y) | (fcmp cc1 x, y). 170325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0CC == Op1CC) 1704f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateFCmp((FCmpInst::Predicate)Op0CC, Op0LHS, Op0RHS); 170525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0CC == FCmpInst::FCMP_TRUE || Op1CC == FCmpInst::FCMP_TRUE) 1706f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return ConstantInt::get(CmpInst::makeCmpResultType(LHS->getType()), 1); 170725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0CC == FCmpInst::FCMP_FALSE) 1708f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return RHS; 170925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op1CC == FCmpInst::FCMP_FALSE) 1710f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return LHS; 171125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner bool Op0Ordered; 171225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner bool Op1Ordered; 171325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner unsigned Op0Pred = getFCmpCode(Op0CC, Op0Ordered); 171425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner unsigned Op1Pred = getFCmpCode(Op1CC, Op1Ordered); 171525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0Ordered == Op1Ordered) { 171625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If both are ordered or unordered, return a new fcmp with 171725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // or'ed predicates. 1718f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return getFCmpValue(Op0Ordered, Op0Pred|Op1Pred, Op0LHS, Op0RHS, Builder); 171925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 172025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 172125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return 0; 172225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 172325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 172425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// FoldOrWithConstants - This helper function folds: 172525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// 172625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// ((A | B) & C1) | (B & C2) 172725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// 172825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// into: 172941a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper/// 173025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// (A & C1) | B 173125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// 173225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// when the XOR of the two constants is "all ones" (-1). 173325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris LattnerInstruction *InstCombiner::FoldOrWithConstants(BinaryOperator &I, Value *Op, 173425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *A, Value *B, Value *C) { 173525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt *CI1 = dyn_cast<ConstantInt>(C); 173625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (!CI1) return 0; 173725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 173825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *V1 = 0; 173925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt *CI2 = 0; 174025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (!match(Op, m_And(m_Value(V1), m_ConstantInt(CI2)))) return 0; 174125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 174225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner APInt Xor = CI1->getValue() ^ CI2->getValue(); 174325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (!Xor.isAllOnesValue()) return 0; 174425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 174525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (V1 == A || V1 == B) { 174625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NewOp = Builder->CreateAnd((V1 == A) ? B : A, CI1); 174725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateOr(NewOp, V1); 174825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 174925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 175025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return 0; 175125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 175225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 175325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris LattnerInstruction *InstCombiner::visitOr(BinaryOperator &I) { 1754096aa79276b8527a3cbbb3691e40e729dea09523Duncan Sands bool Changed = SimplifyAssociativeOrCommutative(I); 175525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1); 175625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 175725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Value *V = SimplifyOrInst(Op0, Op1, TD)) 175825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return ReplaceInstUsesWith(I, V); 17597d9f2b93a356aa89186522bd61c5c565718ff555Bill Wendling 176037bf92b5238434b00fde79347ba5336e7554e562Duncan Sands // (A&B)|(A&C) -> A&(B|C) etc 176137bf92b5238434b00fde79347ba5336e7554e562Duncan Sands if (Value *V = SimplifyUsingDistributiveLaws(I)) 176237bf92b5238434b00fde79347ba5336e7554e562Duncan Sands return ReplaceInstUsesWith(I, V); 17635057f381418ddc8c96699c40479ead993cd62e7bDuncan Sands 176441a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper // See if we can simplify any instructions used by the instruction whose sole 176525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // purpose is to compute bits we don't care about. 176625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (SimplifyDemandedInstructionBits(I)) 176725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return &I; 176825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 176925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ConstantInt *RHS = dyn_cast<ConstantInt>(Op1)) { 177025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt *C1 = 0; Value *X = 0; 177125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (X & C1) | C2 --> (X | C2) & (C1|C2) 177294c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // iff (C1 & C2) == 0. 177325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (match(Op0, m_And(m_Value(X), m_ConstantInt(C1))) && 17747d9f2b93a356aa89186522bd61c5c565718ff555Bill Wendling (RHS->getValue() & C1->getValue()) != 0 && 177525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op0->hasOneUse()) { 177625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Or = Builder->CreateOr(X, RHS); 177725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Or->takeName(Op0); 177841a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper return BinaryOperator::CreateAnd(Or, 1779f2d03d74ffe05d08ac7dccbb81f41d996a1f1d2aJakub Staszak Builder->getInt(RHS->getValue() | C1->getValue())); 178025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 178125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 178225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (X ^ C1) | C2 --> (X | C2) ^ (C1&~C2) 178325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (match(Op0, m_Xor(m_Value(X), m_ConstantInt(C1))) && 178425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op0->hasOneUse()) { 178525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Or = Builder->CreateOr(X, RHS); 178625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Or->takeName(Op0); 178725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateXor(Or, 1788f2d03d74ffe05d08ac7dccbb81f41d996a1f1d2aJakub Staszak Builder->getInt(C1->getValue() & ~RHS->getValue())); 178925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 179025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 179125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Try to fold constant and into select arguments. 179225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (SelectInst *SI = dyn_cast<SelectInst>(Op0)) 179325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Instruction *R = FoldOpIntoSelect(I, SI)) 179425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return R; 17957d9f2b93a356aa89186522bd61c5c565718ff555Bill Wendling 179625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (isa<PHINode>(Op0)) 179725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Instruction *NV = FoldOpIntoPhi(I)) 179825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return NV; 179925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 180025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 180125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *A = 0, *B = 0; 180225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt *C1 = 0, *C2 = 0; 180325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 180425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (A | B) | C and A | (B | C) -> bswap if possible. 180525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (A >> B) | (C << D) and (A << B) | (B >> C) -> bswap if possible. 180625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (match(Op0, m_Or(m_Value(), m_Value())) || 180725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(Op1, m_Or(m_Value(), m_Value())) || 1808aeaf3d484b4d4c35e8794378c4b6cfbbde718dd1Chris Lattner (match(Op0, m_LogicalShift(m_Value(), m_Value())) && 1809aeaf3d484b4d4c35e8794378c4b6cfbbde718dd1Chris Lattner match(Op1, m_LogicalShift(m_Value(), m_Value())))) { 181025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Instruction *BSwap = MatchBSwap(I)) 181125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BSwap; 181225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 181341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 181494c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // (X^C)|Y -> (X|Y)^C iff Y&C == 0 181525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0->hasOneUse() && 181625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(Op0, m_Xor(m_Value(A), m_ConstantInt(C1))) && 181725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner MaskedValueIsZero(Op1, C1->getValue())) { 181825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NOr = Builder->CreateOr(A, Op1); 181925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner NOr->takeName(Op0); 182025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateXor(NOr, C1); 182125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 182225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 182394c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // Y|(X^C) -> (X|Y)^C iff Y&C == 0 182425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op1->hasOneUse() && 182525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(Op1, m_Xor(m_Value(A), m_ConstantInt(C1))) && 182625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner MaskedValueIsZero(Op0, C1->getValue())) { 182725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NOr = Builder->CreateOr(A, Op0); 182825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner NOr->takeName(Op0); 182925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateXor(NOr, C1); 183025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 183125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 183225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (A & C)|(B & D) 183325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *C = 0, *D = 0; 183425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (match(Op0, m_And(m_Value(A), m_Value(C))) && 183525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(Op1, m_And(m_Value(B), m_Value(D)))) { 18365057f381418ddc8c96699c40479ead993cd62e7bDuncan Sands Value *V1 = 0, *V2 = 0; 183725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner C1 = dyn_cast<ConstantInt>(C); 183825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner C2 = dyn_cast<ConstantInt>(D); 183925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (C1 && C2) { // (A & C1)|(B & C2) 184025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If we have: ((V + N) & C1) | (V & C2) 184125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // .. and C2 = ~C1 and C2 is 0+1+ and (N & C2) == 0 184225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // replace with V+N. 184325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (C1->getValue() == ~C2->getValue()) { 184425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if ((C2->getValue() & (C2->getValue()+1)) == 0 && // C2 == 0+1+ 184525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(A, m_Add(m_Value(V1), m_Value(V2)))) { 184625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Add commutes, try both ways. 184725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (V1 == B && MaskedValueIsZero(V2, C2->getValue())) 184825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return ReplaceInstUsesWith(I, A); 184925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (V2 == B && MaskedValueIsZero(V1, C2->getValue())) 185025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return ReplaceInstUsesWith(I, A); 185125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 185225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Or commutes, try both ways. 185325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if ((C1->getValue() & (C1->getValue()+1)) == 0 && 185425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(B, m_Add(m_Value(V1), m_Value(V2)))) { 185525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Add commutes, try both ways. 185625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (V1 == A && MaskedValueIsZero(V2, C1->getValue())) 185725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return ReplaceInstUsesWith(I, B); 185825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (V2 == A && MaskedValueIsZero(V1, C1->getValue())) 185925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return ReplaceInstUsesWith(I, B); 186025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 186125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 186241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 186325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if ((C1->getValue() & C2->getValue()) == 0) { 18648e76764de86d7906db5123626b65f593e159d9f3Chris Lattner // ((V | N) & C1) | (V & C2) --> (V|N) & (C1|C2) 186594c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // iff (C1&C2) == 0 and (N&~C1) == 0 186625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (match(A, m_Or(m_Value(V1), m_Value(V2))) && 186725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ((V1 == B && MaskedValueIsZero(V2, ~C1->getValue())) || // (V|N) 186825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner (V2 == B && MaskedValueIsZero(V1, ~C1->getValue())))) // (N|V) 186925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateAnd(A, 1870f2d03d74ffe05d08ac7dccbb81f41d996a1f1d2aJakub Staszak Builder->getInt(C1->getValue()|C2->getValue())); 187125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Or commutes, try both ways. 187225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (match(B, m_Or(m_Value(V1), m_Value(V2))) && 187325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ((V1 == A && MaskedValueIsZero(V2, ~C2->getValue())) || // (V|N) 187425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner (V2 == A && MaskedValueIsZero(V1, ~C2->getValue())))) // (N|V) 187525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateAnd(B, 1876f2d03d74ffe05d08ac7dccbb81f41d996a1f1d2aJakub Staszak Builder->getInt(C1->getValue()|C2->getValue())); 187741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 18788e76764de86d7906db5123626b65f593e159d9f3Chris Lattner // ((V|C3)&C1) | ((V|C4)&C2) --> (V|C3|C4)&(C1|C2) 187994c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // iff (C1&C2) == 0 and (C3&~C1) == 0 and (C4&~C2) == 0. 18808e76764de86d7906db5123626b65f593e159d9f3Chris Lattner ConstantInt *C3 = 0, *C4 = 0; 18818e76764de86d7906db5123626b65f593e159d9f3Chris Lattner if (match(A, m_Or(m_Value(V1), m_ConstantInt(C3))) && 18828e76764de86d7906db5123626b65f593e159d9f3Chris Lattner (C3->getValue() & ~C1->getValue()) == 0 && 18838e76764de86d7906db5123626b65f593e159d9f3Chris Lattner match(B, m_Or(m_Specific(V1), m_ConstantInt(C4))) && 18848e76764de86d7906db5123626b65f593e159d9f3Chris Lattner (C4->getValue() & ~C2->getValue()) == 0) { 18858e76764de86d7906db5123626b65f593e159d9f3Chris Lattner V2 = Builder->CreateOr(V1, ConstantExpr::getOr(C3, C4), "bitfield"); 18868e76764de86d7906db5123626b65f593e159d9f3Chris Lattner return BinaryOperator::CreateAnd(V2, 1887f2d03d74ffe05d08ac7dccbb81f41d996a1f1d2aJakub Staszak Builder->getInt(C1->getValue()|C2->getValue())); 18888e76764de86d7906db5123626b65f593e159d9f3Chris Lattner } 188925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 189025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 189125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 189239ceb471b7ebaf0ebef09f7916419ae2e0f30accChris Lattner // (A & (C0?-1:0)) | (B & ~(C0?-1:0)) -> C0 ? A : B, and commuted variants. 189339ceb471b7ebaf0ebef09f7916419ae2e0f30accChris Lattner // Don't do this for vector select idioms, the code generator doesn't handle 189439ceb471b7ebaf0ebef09f7916419ae2e0f30accChris Lattner // them well yet. 18951df9859c40492511b8aa4321eb76496005d3b75bDuncan Sands if (!I.getType()->isVectorTy()) { 189639ceb471b7ebaf0ebef09f7916419ae2e0f30accChris Lattner if (Instruction *Match = MatchSelectFromAndOr(A, B, C, D)) 189739ceb471b7ebaf0ebef09f7916419ae2e0f30accChris Lattner return Match; 189839ceb471b7ebaf0ebef09f7916419ae2e0f30accChris Lattner if (Instruction *Match = MatchSelectFromAndOr(B, A, D, C)) 189939ceb471b7ebaf0ebef09f7916419ae2e0f30accChris Lattner return Match; 190039ceb471b7ebaf0ebef09f7916419ae2e0f30accChris Lattner if (Instruction *Match = MatchSelectFromAndOr(C, B, A, D)) 190139ceb471b7ebaf0ebef09f7916419ae2e0f30accChris Lattner return Match; 190239ceb471b7ebaf0ebef09f7916419ae2e0f30accChris Lattner if (Instruction *Match = MatchSelectFromAndOr(D, A, B, C)) 190339ceb471b7ebaf0ebef09f7916419ae2e0f30accChris Lattner return Match; 190439ceb471b7ebaf0ebef09f7916419ae2e0f30accChris Lattner } 190525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 190625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ((A&~B)|(~A&B)) -> A^B 190725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if ((match(C, m_Not(m_Specific(D))) && 190825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(B, m_Not(m_Specific(A))))) 190925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateXor(A, D); 191025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ((~B&A)|(~A&B)) -> A^B 191125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if ((match(A, m_Not(m_Specific(D))) && 191225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(B, m_Not(m_Specific(C))))) 191325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateXor(C, D); 191425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ((A&~B)|(B&~A)) -> A^B 191525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if ((match(C, m_Not(m_Specific(B))) && 191625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(D, m_Not(m_Specific(A))))) 191725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateXor(A, B); 191825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ((~B&A)|(B&~A)) -> A^B 191925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if ((match(A, m_Not(m_Specific(B))) && 192025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(D, m_Not(m_Specific(C))))) 192125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateXor(C, B); 1922ad854f0764e6a386b0dc49a2640766b8e9ae0b61Benjamin Kramer 1923ad854f0764e6a386b0dc49a2640766b8e9ae0b61Benjamin Kramer // ((A|B)&1)|(B&-2) -> (A&1) | B 1924ad854f0764e6a386b0dc49a2640766b8e9ae0b61Benjamin Kramer if (match(A, m_Or(m_Value(V1), m_Specific(B))) || 1925ad854f0764e6a386b0dc49a2640766b8e9ae0b61Benjamin Kramer match(A, m_Or(m_Specific(B), m_Value(V1)))) { 1926ad854f0764e6a386b0dc49a2640766b8e9ae0b61Benjamin Kramer Instruction *Ret = FoldOrWithConstants(I, Op1, V1, B, C); 1927ad854f0764e6a386b0dc49a2640766b8e9ae0b61Benjamin Kramer if (Ret) return Ret; 1928ad854f0764e6a386b0dc49a2640766b8e9ae0b61Benjamin Kramer } 1929ad854f0764e6a386b0dc49a2640766b8e9ae0b61Benjamin Kramer // (B&-2)|((A|B)&1) -> (A&1) | B 1930ad854f0764e6a386b0dc49a2640766b8e9ae0b61Benjamin Kramer if (match(B, m_Or(m_Specific(A), m_Value(V1))) || 1931ad854f0764e6a386b0dc49a2640766b8e9ae0b61Benjamin Kramer match(B, m_Or(m_Value(V1), m_Specific(A)))) { 1932ad854f0764e6a386b0dc49a2640766b8e9ae0b61Benjamin Kramer Instruction *Ret = FoldOrWithConstants(I, Op0, A, V1, D); 1933ad854f0764e6a386b0dc49a2640766b8e9ae0b61Benjamin Kramer if (Ret) return Ret; 1934ad854f0764e6a386b0dc49a2640766b8e9ae0b61Benjamin Kramer } 193525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 193641a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 193725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (X >> Z) | (Y >> Z) -> (X|Y) >> Z for all shifts. 193825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (BinaryOperator *SI1 = dyn_cast<BinaryOperator>(Op1)) { 193925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (BinaryOperator *SI0 = dyn_cast<BinaryOperator>(Op0)) 194041a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper if (SI0->isShift() && SI0->getOpcode() == SI1->getOpcode() && 194125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner SI0->getOperand(1) == SI1->getOperand(1) && 194225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner (SI0->hasOneUse() || SI1->hasOneUse())) { 194325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NewOp = Builder->CreateOr(SI0->getOperand(0), SI1->getOperand(0), 194425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner SI0->getName()); 194541a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper return BinaryOperator::Create(SI1->getOpcode(), NewOp, 194625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner SI1->getOperand(1)); 194725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 194825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 194925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 195025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (~A | ~B) == (~(A & B)) - De Morgan's Law 195125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Value *Op0NotVal = dyn_castNotVal(Op0)) 195225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Value *Op1NotVal = dyn_castNotVal(Op1)) 195325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0->hasOneUse() && Op1->hasOneUse()) { 195425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *And = Builder->CreateAnd(Op0NotVal, Op1NotVal, 195525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner I.getName()+".demorgan"); 195625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateNot(And); 195725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 195825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 195991e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer // Canonicalize xor to the RHS. 1960e9f15c8a563a745c5cafa7c98b1f12de2dcab070Eli Friedman bool SwappedForXor = false; 1961e9f15c8a563a745c5cafa7c98b1f12de2dcab070Eli Friedman if (match(Op0, m_Xor(m_Value(), m_Value()))) { 196291e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer std::swap(Op0, Op1); 1963e9f15c8a563a745c5cafa7c98b1f12de2dcab070Eli Friedman SwappedForXor = true; 1964e9f15c8a563a745c5cafa7c98b1f12de2dcab070Eli Friedman } 196591e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer 196691e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer // A | ( A ^ B) -> A | B 196791e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer // A | (~A ^ B) -> A | ~B 1968c1fc5e4464788be072509eab7d66a73dc7a5f275Chad Rosier // (A & B) | (A ^ B) 196991e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer if (match(Op1, m_Xor(m_Value(A), m_Value(B)))) { 197091e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer if (Op0 == A || Op0 == B) 197191e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer return BinaryOperator::CreateOr(A, B); 197291e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer 1973c1fc5e4464788be072509eab7d66a73dc7a5f275Chad Rosier if (match(Op0, m_And(m_Specific(A), m_Specific(B))) || 1974c1fc5e4464788be072509eab7d66a73dc7a5f275Chad Rosier match(Op0, m_And(m_Specific(B), m_Specific(A)))) 1975c1fc5e4464788be072509eab7d66a73dc7a5f275Chad Rosier return BinaryOperator::CreateOr(A, B); 1976c1fc5e4464788be072509eab7d66a73dc7a5f275Chad Rosier 197791e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer if (Op1->hasOneUse() && match(A, m_Not(m_Specific(Op0)))) { 197891e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer Value *Not = Builder->CreateNot(B, B->getName()+".not"); 197991e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer return BinaryOperator::CreateOr(Not, Op0); 198091e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer } 198191e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer if (Op1->hasOneUse() && match(B, m_Not(m_Specific(Op0)))) { 198291e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer Value *Not = Builder->CreateNot(A, A->getName()+".not"); 198391e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer return BinaryOperator::CreateOr(Not, Op0); 198491e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer } 198591e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer } 198691e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer 198791e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer // A | ~(A | B) -> A | ~B 198891e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer // A | ~(A ^ B) -> A | ~B 198991e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer if (match(Op1, m_Not(m_Value(A)))) 199091e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer if (BinaryOperator *B = dyn_cast<BinaryOperator>(A)) 199138f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer if ((Op0 == B->getOperand(0) || Op0 == B->getOperand(1)) && 199238f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer Op1->hasOneUse() && (B->getOpcode() == Instruction::Or || 199338f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer B->getOpcode() == Instruction::Xor)) { 199438f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer Value *NotOp = Op0 == B->getOperand(0) ? B->getOperand(1) : 199538f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer B->getOperand(0); 199638f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer Value *Not = Builder->CreateNot(NotOp, NotOp->getName()+".not"); 199738f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer return BinaryOperator::CreateOr(Not, Op0); 199838f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer } 199991e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer 2000e9f15c8a563a745c5cafa7c98b1f12de2dcab070Eli Friedman if (SwappedForXor) 2001e9f15c8a563a745c5cafa7c98b1f12de2dcab070Eli Friedman std::swap(Op0, Op1); 2002e9f15c8a563a745c5cafa7c98b1f12de2dcab070Eli Friedman 200325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ICmpInst *RHS = dyn_cast<ICmpInst>(I.getOperand(1))) 200425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ICmpInst *LHS = dyn_cast<ICmpInst>(I.getOperand(0))) 2005f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner if (Value *Res = FoldOrOfICmps(LHS, RHS)) 2006f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return ReplaceInstUsesWith(I, Res); 200741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 20088c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner // (fcmp uno x, c) | (fcmp uno y, c) -> (fcmp uno x, y) 20098c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner if (FCmpInst *LHS = dyn_cast<FCmpInst>(I.getOperand(0))) 20108c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner if (FCmpInst *RHS = dyn_cast<FCmpInst>(I.getOperand(1))) 2011f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner if (Value *Res = FoldOrOfFCmps(LHS, RHS)) 2012f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return ReplaceInstUsesWith(I, Res); 201341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 201425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // fold (or (cast A), (cast B)) -> (cast (or A, B)) 201525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (CastInst *Op0C = dyn_cast<CastInst>(Op0)) { 201628621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner CastInst *Op1C = dyn_cast<CastInst>(Op1); 201728621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner if (Op1C && Op0C->getOpcode() == Op1C->getOpcode()) {// same cast kind ? 2018db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *SrcTy = Op0C->getOperand(0)->getType(); 201928621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner if (SrcTy == Op1C->getOperand(0)->getType() && 202028621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner SrcTy->isIntOrIntVectorTy()) { 202128621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner Value *Op0COp = Op0C->getOperand(0), *Op1COp = Op1C->getOperand(0); 202228621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner 202328621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner if ((!isa<ICmpInst>(Op0COp) || !isa<ICmpInst>(Op1COp)) && 202428621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner // Only do this if the casts both really cause code to be 202528621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner // generated. 202628621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner ShouldOptimizeCast(Op0C->getOpcode(), Op0COp, I.getType()) && 202728621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner ShouldOptimizeCast(Op1C->getOpcode(), Op1COp, I.getType())) { 202828621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner Value *NewOp = Builder->CreateOr(Op0COp, Op1COp, I.getName()); 202928621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner return CastInst::Create(Op0C->getOpcode(), NewOp, I.getType()); 203025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 203141a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 203228621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner // If this is or(cast(icmp), cast(icmp)), try to fold this even if the 203328621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner // cast is otherwise not optimizable. This happens for vector sexts. 203428621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner if (ICmpInst *RHS = dyn_cast<ICmpInst>(Op1COp)) 203528621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner if (ICmpInst *LHS = dyn_cast<ICmpInst>(Op0COp)) 203628621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner if (Value *Res = FoldOrOfICmps(LHS, RHS)) 203728621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner return CastInst::Create(Op0C->getOpcode(), Res, I.getType()); 203841a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 203928621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner // If this is or(cast(fcmp), cast(fcmp)), try to fold this even if the 204028621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner // cast is otherwise not optimizable. This happens for vector sexts. 204128621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner if (FCmpInst *RHS = dyn_cast<FCmpInst>(Op1COp)) 204228621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner if (FCmpInst *LHS = dyn_cast<FCmpInst>(Op0COp)) 204328621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner if (Value *Res = FoldOrOfFCmps(LHS, RHS)) 204428621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner return CastInst::Create(Op0C->getOpcode(), Res, I.getType()); 204525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 204628621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner } 204725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 20483ec01b7dac769449723a25d8f7d33b49c917ccc9Eli Friedman 20493ec01b7dac769449723a25d8f7d33b49c917ccc9Eli Friedman // or(sext(A), B) -> A ? -1 : B where A is an i1 20503ec01b7dac769449723a25d8f7d33b49c917ccc9Eli Friedman // or(A, sext(B)) -> B ? -1 : A where B is an i1 20513ec01b7dac769449723a25d8f7d33b49c917ccc9Eli Friedman if (match(Op0, m_SExt(m_Value(A))) && A->getType()->isIntegerTy(1)) 20523ec01b7dac769449723a25d8f7d33b49c917ccc9Eli Friedman return SelectInst::Create(A, ConstantInt::getSigned(I.getType(), -1), Op1); 20533ec01b7dac769449723a25d8f7d33b49c917ccc9Eli Friedman if (match(Op1, m_SExt(m_Value(A))) && A->getType()->isIntegerTy(1)) 20543ec01b7dac769449723a25d8f7d33b49c917ccc9Eli Friedman return SelectInst::Create(A, ConstantInt::getSigned(I.getType(), -1), Op0); 20553ec01b7dac769449723a25d8f7d33b49c917ccc9Eli Friedman 20562c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson // Note: If we've gotten to the point of visiting the outer OR, then the 20572c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson // inner one couldn't be simplified. If it was a constant, then it won't 20582c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson // be simplified by a later pass either, so we try swapping the inner/outer 20592c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson // ORs in the hopes that we'll be able to simplify it this way. 20602c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson // (X|C) | V --> (X|V) | C 20612c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson if (Op0->hasOneUse() && !isa<ConstantInt>(Op1) && 20622c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson match(Op0, m_Or(m_Value(A), m_ConstantInt(C1)))) { 20632c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson Value *Inner = Builder->CreateOr(A, Op1); 20642c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson Inner->takeName(Op0); 20652c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson return BinaryOperator::CreateOr(Inner, C1); 20662c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson } 206741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 2068cc54889cd58322b8766525f43cc1f7cb52e4692eBill Wendling // Change (or (bool?A:B),(bool?C:D)) --> (bool?(or A,C):(or B,D)) 2069cc54889cd58322b8766525f43cc1f7cb52e4692eBill Wendling // Since this OR statement hasn't been optimized further yet, we hope 2070cc54889cd58322b8766525f43cc1f7cb52e4692eBill Wendling // that this transformation will allow the new ORs to be optimized. 2071cc54889cd58322b8766525f43cc1f7cb52e4692eBill Wendling { 2072cc54889cd58322b8766525f43cc1f7cb52e4692eBill Wendling Value *X = 0, *Y = 0; 2073cc54889cd58322b8766525f43cc1f7cb52e4692eBill Wendling if (Op0->hasOneUse() && Op1->hasOneUse() && 2074cc54889cd58322b8766525f43cc1f7cb52e4692eBill Wendling match(Op0, m_Select(m_Value(X), m_Value(A), m_Value(B))) && 2075cc54889cd58322b8766525f43cc1f7cb52e4692eBill Wendling match(Op1, m_Select(m_Value(Y), m_Value(C), m_Value(D))) && X == Y) { 2076cc54889cd58322b8766525f43cc1f7cb52e4692eBill Wendling Value *orTrue = Builder->CreateOr(A, C); 2077cc54889cd58322b8766525f43cc1f7cb52e4692eBill Wendling Value *orFalse = Builder->CreateOr(B, D); 2078cc54889cd58322b8766525f43cc1f7cb52e4692eBill Wendling return SelectInst::Create(X, orTrue, orFalse); 2079cc54889cd58322b8766525f43cc1f7cb52e4692eBill Wendling } 2080cc54889cd58322b8766525f43cc1f7cb52e4692eBill Wendling } 2081cc54889cd58322b8766525f43cc1f7cb52e4692eBill Wendling 208225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return Changed ? &I : 0; 208325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 208425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 208525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris LattnerInstruction *InstCombiner::visitXor(BinaryOperator &I) { 2086096aa79276b8527a3cbbb3691e40e729dea09523Duncan Sands bool Changed = SimplifyAssociativeOrCommutative(I); 208725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1); 208825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 20892b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands if (Value *V = SimplifyXorInst(Op0, Op1, TD)) 20902b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return ReplaceInstUsesWith(I, V); 209125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 209237bf92b5238434b00fde79347ba5336e7554e562Duncan Sands // (A&B)^(A&C) -> A&(B^C) etc 209337bf92b5238434b00fde79347ba5336e7554e562Duncan Sands if (Value *V = SimplifyUsingDistributiveLaws(I)) 209437bf92b5238434b00fde79347ba5336e7554e562Duncan Sands return ReplaceInstUsesWith(I, V); 20955057f381418ddc8c96699c40479ead993cd62e7bDuncan Sands 209641a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper // See if we can simplify any instructions used by the instruction whose sole 209725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // purpose is to compute bits we don't care about. 209825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (SimplifyDemandedInstructionBits(I)) 209925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return &I; 210025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 210125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Is this a ~ operation? 210225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Value *NotOp = dyn_castNotVal(&I)) { 210325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (BinaryOperator *Op0I = dyn_cast<BinaryOperator>(NotOp)) { 210441a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper if (Op0I->getOpcode() == Instruction::And || 210525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op0I->getOpcode() == Instruction::Or) { 210625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ~(~X & Y) --> (X | ~Y) - De Morgan's Law 210725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ~(~X | Y) === (X & ~Y) - De Morgan's Law 210825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (dyn_castNotVal(Op0I->getOperand(1))) 210925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op0I->swapOperands(); 211025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Value *Op0NotVal = dyn_castNotVal(Op0I->getOperand(0))) { 211125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NotY = 211225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Builder->CreateNot(Op0I->getOperand(1), 211325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op0I->getOperand(1)->getName()+".not"); 211425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0I->getOpcode() == Instruction::And) 211525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateOr(Op0NotVal, NotY); 211625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateAnd(Op0NotVal, NotY); 211725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 211841a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 211925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ~(X & Y) --> (~X | ~Y) - De Morgan's Law 212025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ~(X | Y) === (~X & ~Y) - De Morgan's Law 212141a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper if (isFreeToInvert(Op0I->getOperand(0)) && 212225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner isFreeToInvert(Op0I->getOperand(1))) { 212325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NotX = 212425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Builder->CreateNot(Op0I->getOperand(0), "notlhs"); 212525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NotY = 212625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Builder->CreateNot(Op0I->getOperand(1), "notrhs"); 212725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0I->getOpcode() == Instruction::And) 212825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateOr(NotX, NotY); 212925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateAnd(NotX, NotY); 213025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 2131c0404b3715151d020dda074740bbdaa794f9328aChris Lattner 2132c0404b3715151d020dda074740bbdaa794f9328aChris Lattner } else if (Op0I->getOpcode() == Instruction::AShr) { 2133c0404b3715151d020dda074740bbdaa794f9328aChris Lattner // ~(~X >>s Y) --> (X >>s Y) 2134c0404b3715151d020dda074740bbdaa794f9328aChris Lattner if (Value *Op0NotVal = dyn_castNotVal(Op0I->getOperand(0))) 2135c0404b3715151d020dda074740bbdaa794f9328aChris Lattner return BinaryOperator::CreateAShr(Op0NotVal, Op0I->getOperand(1)); 213625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 213725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 213825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 213941a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 214041a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 214125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ConstantInt *RHS = dyn_cast<ConstantInt>(Op1)) { 21426c3ae655b846ae663ea14000adf3b42e9455ce56Dan Gohman if (RHS->isOne() && Op0->hasOneUse()) 214325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // xor (cmp A, B), true = not (cmp A, B) = !cmp A, B 21446c3ae655b846ae663ea14000adf3b42e9455ce56Dan Gohman if (CmpInst *CI = dyn_cast<CmpInst>(Op0)) 21456c3ae655b846ae663ea14000adf3b42e9455ce56Dan Gohman return CmpInst::Create(CI->getOpcode(), 21466c3ae655b846ae663ea14000adf3b42e9455ce56Dan Gohman CI->getInversePredicate(), 21476c3ae655b846ae663ea14000adf3b42e9455ce56Dan Gohman CI->getOperand(0), CI->getOperand(1)); 214825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 214925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // fold (xor(zext(cmp)), 1) and (xor(sext(cmp)), -1) to ext(!cmp). 215025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (CastInst *Op0C = dyn_cast<CastInst>(Op0)) { 215125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (CmpInst *CI = dyn_cast<CmpInst>(Op0C->getOperand(0))) { 215225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (CI->hasOneUse() && Op0C->hasOneUse()) { 215325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Instruction::CastOps Opcode = Op0C->getOpcode(); 215425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if ((Opcode == Instruction::ZExt || Opcode == Instruction::SExt) && 2155f2d03d74ffe05d08ac7dccbb81f41d996a1f1d2aJakub Staszak (RHS == ConstantExpr::getCast(Opcode, Builder->getTrue(), 215625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op0C->getDestTy()))) { 215725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner CI->setPredicate(CI->getInversePredicate()); 215825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return CastInst::Create(Opcode, CI, Op0C->getType()); 215925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 216025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 216125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 216225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 216325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 216425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (BinaryOperator *Op0I = dyn_cast<BinaryOperator>(Op0)) { 216525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ~(c-X) == X-c-1 == X+(-c-1) 216625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0I->getOpcode() == Instruction::Sub && RHS->isAllOnesValue()) 216725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Constant *Op0I0C = dyn_cast<Constant>(Op0I->getOperand(0))) { 216825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Constant *NegOp0I0C = ConstantExpr::getNeg(Op0I0C); 216925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Constant *ConstantRHS = ConstantExpr::getSub(NegOp0I0C, 217025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt::get(I.getType(), 1)); 217125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateAdd(Op0I->getOperand(1), ConstantRHS); 217225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 217341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 217425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ConstantInt *Op0CI = dyn_cast<ConstantInt>(Op0I->getOperand(1))) { 217525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0I->getOpcode() == Instruction::Add) { 217625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ~(X-c) --> (-c-1)-X 217725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (RHS->isAllOnesValue()) { 217825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Constant *NegOp0CI = ConstantExpr::getNeg(Op0CI); 217925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateSub( 218025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantExpr::getSub(NegOp0CI, 218125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt::get(I.getType(), 1)), 218225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op0I->getOperand(0)); 218325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } else if (RHS->getValue().isSignBit()) { 218425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (X + C) ^ signbit -> (X + C + signbit) 2185f2d03d74ffe05d08ac7dccbb81f41d996a1f1d2aJakub Staszak Constant *C = Builder->getInt(RHS->getValue() + Op0CI->getValue()); 218625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateAdd(Op0I->getOperand(0), C); 218725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 218825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 218925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } else if (Op0I->getOpcode() == Instruction::Or) { 219094c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // (X|C1)^C2 -> X^(C1|C2) iff X&~C1 == 0 219125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (MaskedValueIsZero(Op0I->getOperand(0), Op0CI->getValue())) { 219225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Constant *NewRHS = ConstantExpr::getOr(Op0CI, RHS); 219325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Anything in both C1 and C2 is known to be zero, remove it from 219425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // NewRHS. 219525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Constant *CommonBits = ConstantExpr::getAnd(Op0CI, RHS); 219641a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper NewRHS = ConstantExpr::getAnd(NewRHS, 219725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantExpr::getNot(CommonBits)); 219825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Worklist.Add(Op0I); 219925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner I.setOperand(0, Op0I->getOperand(0)); 220025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner I.setOperand(1, NewRHS); 220125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return &I; 220225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 2203b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang } else if (Op0I->getOpcode() == Instruction::LShr) { 2204b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang // ((X^C1) >> C2) ^ C3 -> (X>>C2) ^ ((C1>>C2)^C3) 2205b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang // E1 = "X ^ C1" 220641a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper BinaryOperator *E1; 2207b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang ConstantInt *C1; 2208b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang if (Op0I->hasOneUse() && 2209b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang (E1 = dyn_cast<BinaryOperator>(Op0I->getOperand(0))) && 2210b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang E1->getOpcode() == Instruction::Xor && 2211b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang (C1 = dyn_cast<ConstantInt>(E1->getOperand(1)))) { 2212b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang // fold (C1 >> C2) ^ C3 2213b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang ConstantInt *C2 = Op0CI, *C3 = RHS; 2214b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang APInt FoldConst = C1->getValue().lshr(C2->getValue()); 2215b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang FoldConst ^= C3->getValue(); 2216b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang // Prepare the two operands. 2217b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang Value *Opnd0 = Builder->CreateLShr(E1->getOperand(0), C2); 2218b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang Opnd0->takeName(Op0I); 2219b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang cast<Instruction>(Opnd0)->setDebugLoc(I.getDebugLoc()); 2220b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang Value *FoldVal = ConstantInt::get(Opnd0->getType(), FoldConst); 2221b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang 2222b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang return BinaryOperator::CreateXor(Opnd0, FoldVal); 2223b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang } 222425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 222525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 222625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 222725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 222825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Try to fold constant and into select arguments. 222925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (SelectInst *SI = dyn_cast<SelectInst>(Op0)) 223025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Instruction *R = FoldOpIntoSelect(I, SI)) 223125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return R; 223225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (isa<PHINode>(Op0)) 223325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Instruction *NV = FoldOpIntoPhi(I)) 223425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return NV; 223525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 223625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 223725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner BinaryOperator *Op1I = dyn_cast<BinaryOperator>(Op1); 223825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op1I) { 223925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *A, *B; 224025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (match(Op1I, m_Or(m_Value(A), m_Value(B)))) { 224125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (A == Op0) { // B^(B|A) == (A|B)^B 224225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op1I->swapOperands(); 224325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner I.swapOperands(); 224425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(Op0, Op1); 224525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } else if (B == Op0) { // B^(A|B) == (A|B)^B 224625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner I.swapOperands(); // Simplified below. 224725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(Op0, Op1); 224825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 224941a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper } else if (match(Op1I, m_And(m_Value(A), m_Value(B))) && 225025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op1I->hasOneUse()){ 225125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (A == Op0) { // A^(A&B) -> A^(B&A) 225225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op1I->swapOperands(); 225325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(A, B); 225425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 225525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (B == Op0) { // A^(B&A) -> (B&A)^A 225625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner I.swapOperands(); // Simplified below. 225725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(Op0, Op1); 225825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 225925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 226025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 226141a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 226225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner BinaryOperator *Op0I = dyn_cast<BinaryOperator>(Op0); 226325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0I) { 226425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *A, *B; 226525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (match(Op0I, m_Or(m_Value(A), m_Value(B))) && 226625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op0I->hasOneUse()) { 226725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (A == Op1) // (B|A)^B == (A|B)^B 226825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(A, B); 226925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (B == Op1) // (A|B)^B == A & ~B 2270a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer return BinaryOperator::CreateAnd(A, Builder->CreateNot(Op1)); 227141a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper } else if (match(Op0I, m_And(m_Value(A), m_Value(B))) && 227225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op0I->hasOneUse()){ 227325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (A == Op1) // (A&B)^A -> (B&A)^A 227425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(A, B); 227525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (B == Op1 && // (B&A)^A == ~B & A 227625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner !isa<ConstantInt>(Op1)) { // Canonical form is (B&C)^C 2277a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer return BinaryOperator::CreateAnd(Builder->CreateNot(A), Op1); 227825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 227925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 228025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 228141a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 228225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (X >> Z) ^ (Y >> Z) -> (X^Y) >> Z for all shifts. 228341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper if (Op0I && Op1I && Op0I->isShift() && 228441a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper Op0I->getOpcode() == Op1I->getOpcode() && 228525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op0I->getOperand(1) == Op1I->getOperand(1) && 22867bb9f063be7c1228eb2647364ce3bbc9b31b7dc8Benjamin Kramer (Op0I->hasOneUse() || Op1I->hasOneUse())) { 228725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NewOp = 228825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Builder->CreateXor(Op0I->getOperand(0), Op1I->getOperand(0), 228925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op0I->getName()); 229041a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper return BinaryOperator::Create(Op1I->getOpcode(), NewOp, 229125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op1I->getOperand(1)); 229225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 229341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 229425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0I && Op1I) { 229525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *A, *B, *C, *D; 229625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (A & B)^(A | B) -> A ^ B 229725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (match(Op0I, m_And(m_Value(A), m_Value(B))) && 229825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(Op1I, m_Or(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 // (A | B)^(A & B) -> A ^ B 230325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (match(Op0I, m_Or(m_Value(A), m_Value(B))) && 230425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(Op1I, m_And(m_Value(C), m_Value(D)))) { 230541a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper if ((A == C && B == D) || (A == D && B == C)) 230625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateXor(A, B); 230725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 230825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 23095057f381418ddc8c96699c40479ead993cd62e7bDuncan Sands 231025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (icmp1 A, B) ^ (icmp2 A, B) --> (icmp3 A, B) 231125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ICmpInst *RHS = dyn_cast<ICmpInst>(I.getOperand(1))) 231225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ICmpInst *LHS = dyn_cast<ICmpInst>(I.getOperand(0))) 231325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (PredicatesFoldable(LHS->getPredicate(), RHS->getPredicate())) { 231425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHS->getOperand(0) == RHS->getOperand(1) && 231525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner LHS->getOperand(1) == RHS->getOperand(0)) 231625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner LHS->swapOperands(); 231725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHS->getOperand(0) == RHS->getOperand(0) && 231825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner LHS->getOperand(1) == RHS->getOperand(1)) { 231925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Op0 = LHS->getOperand(0), *Op1 = LHS->getOperand(1); 232025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner unsigned Code = getICmpCode(LHS) ^ getICmpCode(RHS); 232125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner bool isSigned = LHS->isSigned() || RHS->isSigned(); 232241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper return ReplaceInstUsesWith(I, 23232e33944c101f2a08ed1d85e807830f2fc089dd06Pete Cooper getNewICmpValue(isSigned, Code, Op0, Op1, 23242e33944c101f2a08ed1d85e807830f2fc089dd06Pete Cooper Builder)); 232525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 232625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 232725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 232825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // fold (xor (cast A), (cast B)) -> (cast (xor A, B)) 232925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (CastInst *Op0C = dyn_cast<CastInst>(Op0)) { 233025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (CastInst *Op1C = dyn_cast<CastInst>(Op1)) 233125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0C->getOpcode() == Op1C->getOpcode()) { // same cast kind? 2332db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *SrcTy = Op0C->getOperand(0)->getType(); 2333b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands if (SrcTy == Op1C->getOperand(0)->getType() && SrcTy->isIntegerTy() && 233425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Only do this if the casts both really cause code to be generated. 233541a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper ShouldOptimizeCast(Op0C->getOpcode(), Op0C->getOperand(0), 23368c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner I.getType()) && 233741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper ShouldOptimizeCast(Op1C->getOpcode(), Op1C->getOperand(0), 23388c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner I.getType())) { 233925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NewOp = Builder->CreateXor(Op0C->getOperand(0), 234025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op1C->getOperand(0), I.getName()); 234125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return CastInst::Create(Op0C->getOpcode(), NewOp, I.getType()); 234225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 234325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 234425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 234525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 234625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return Changed ? &I : 0; 234725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 2348