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" 1636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines#include "llvm/IR/ConstantRange.h" 170b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Intrinsics.h" 1836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines#include "llvm/IR/PatternMatch.h" 19d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Transforms/Utils/CmpInstAnalysis.h" 2025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattnerusing namespace llvm; 2125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattnerusing namespace PatternMatch; 2225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 23dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines#define DEBUG_TYPE "instcombine" 24dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 2525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// isFreeToInvert - Return true if the specified value is free to invert (apply 2625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// ~ to). This happens in cases where the ~ can be eliminated. 2725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattnerstatic inline bool isFreeToInvert(Value *V) { 2825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ~(~(X)) -> X. 2925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (BinaryOperator::isNot(V)) 3025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return true; 3141a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 3225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Constants can be considered to be not'ed values. 3325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (isa<ConstantInt>(V)) 3425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return true; 3541a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 3625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Compares can be inverted if they have a single use. 3725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (CmpInst *CI = dyn_cast<CmpInst>(V)) 3825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return CI->hasOneUse(); 3941a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 4025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return false; 4125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 4225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 4325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattnerstatic inline Value *dyn_castNotVal(Value *V) { 4425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If this is not(not(x)) don't return that this is a not: we want the two 4525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // not's to be folded first. 4625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (BinaryOperator::isNot(V)) { 4725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Operand = BinaryOperator::getNotArgument(V); 4825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (!isFreeToInvert(Operand)) 4925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return Operand; 5025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 5141a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 5225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Constants can be considered to be not'ed values... 5325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ConstantInt *C = dyn_cast<ConstantInt>(V)) 5425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return ConstantInt::get(C->getType(), ~C->getValue()); 55dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 5625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 5725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 5825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// getFCmpCode - Similar to getICmpCode but for FCmpInst. This encodes a fcmp 5925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// predicate into a three bit mask. It also returns whether it is an ordered 6025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// predicate by reference. 6125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattnerstatic unsigned getFCmpCode(FCmpInst::Predicate CC, bool &isOrdered) { 6225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner isOrdered = false; 6325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (CC) { 6425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case FCmpInst::FCMP_ORD: isOrdered = true; return 0; // 000 6525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case FCmpInst::FCMP_UNO: return 0; // 000 6625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case FCmpInst::FCMP_OGT: isOrdered = true; return 1; // 001 6725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case FCmpInst::FCMP_UGT: return 1; // 001 6825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case FCmpInst::FCMP_OEQ: isOrdered = true; return 2; // 010 6925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case FCmpInst::FCMP_UEQ: return 2; // 010 7025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case FCmpInst::FCMP_OGE: isOrdered = true; return 3; // 011 7125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case FCmpInst::FCMP_UGE: return 3; // 011 7225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case FCmpInst::FCMP_OLT: isOrdered = true; return 4; // 100 7325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case FCmpInst::FCMP_ULT: return 4; // 100 7425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case FCmpInst::FCMP_ONE: isOrdered = true; return 5; // 101 7525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case FCmpInst::FCMP_UNE: return 5; // 101 7625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case FCmpInst::FCMP_OLE: isOrdered = true; return 6; // 110 7725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case FCmpInst::FCMP_ULE: return 6; // 110 7825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // True -> 7 7925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: 8025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Not expecting FCMP_FALSE and FCMP_TRUE; 8125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner llvm_unreachable("Unexpected FCmp predicate!"); 8225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 8325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 8425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 857ba962fe4ac04acd12db803cbc255b0c00a6e4eaBenjamin Kramer/// getNewICmpValue - This is the complement of getICmpCode, which turns an 8641a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper/// opcode and two operands into either a constant true or false, or a brand 8725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// new ICmp instruction. The sign is passed in to determine which kind 8825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// of predicate to use in the new icmp instruction. 897ba962fe4ac04acd12db803cbc255b0c00a6e4eaBenjamin Kramerstatic Value *getNewICmpValue(bool Sign, unsigned Code, Value *LHS, Value *RHS, 907ba962fe4ac04acd12db803cbc255b0c00a6e4eaBenjamin Kramer InstCombiner::BuilderTy *Builder) { 912e33944c101f2a08ed1d85e807830f2fc089dd06Pete Cooper ICmpInst::Predicate NewPred; 922e33944c101f2a08ed1d85e807830f2fc089dd06Pete Cooper if (Value *NewConstant = getICmpValue(Sign, Code, LHS, RHS, NewPred)) 932e33944c101f2a08ed1d85e807830f2fc089dd06Pete Cooper return NewConstant; 942e33944c101f2a08ed1d85e807830f2fc089dd06Pete Cooper return Builder->CreateICmp(NewPred, LHS, RHS); 9525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 9625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 9725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// getFCmpValue - This is the complement of getFCmpCode, which turns an 9825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// opcode and two operands into either a FCmp instruction. isordered is passed 9925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// in to determine which kind of predicate to use in the new fcmp instruction. 10025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattnerstatic Value *getFCmpValue(bool isordered, unsigned code, 101f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner Value *LHS, Value *RHS, 102f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner InstCombiner::BuilderTy *Builder) { 103d6f645ac09a28b5b45f390b2597444514be8a70eChris Lattner CmpInst::Predicate Pred; 10425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (code) { 105858143816d43e58b17bfd11cb1b57afbd7f0f893Craig Topper default: llvm_unreachable("Illegal FCmp code!"); 106d6f645ac09a28b5b45f390b2597444514be8a70eChris Lattner case 0: Pred = isordered ? FCmpInst::FCMP_ORD : FCmpInst::FCMP_UNO; break; 107d6f645ac09a28b5b45f390b2597444514be8a70eChris Lattner case 1: Pred = isordered ? FCmpInst::FCMP_OGT : FCmpInst::FCMP_UGT; break; 108d6f645ac09a28b5b45f390b2597444514be8a70eChris Lattner case 2: Pred = isordered ? FCmpInst::FCMP_OEQ : FCmpInst::FCMP_UEQ; break; 109d6f645ac09a28b5b45f390b2597444514be8a70eChris Lattner case 3: Pred = isordered ? FCmpInst::FCMP_OGE : FCmpInst::FCMP_UGE; break; 110d6f645ac09a28b5b45f390b2597444514be8a70eChris Lattner case 4: Pred = isordered ? FCmpInst::FCMP_OLT : FCmpInst::FCMP_ULT; break; 111d6f645ac09a28b5b45f390b2597444514be8a70eChris Lattner case 5: Pred = isordered ? FCmpInst::FCMP_ONE : FCmpInst::FCMP_UNE; break; 112d6f645ac09a28b5b45f390b2597444514be8a70eChris Lattner case 6: Pred = isordered ? FCmpInst::FCMP_OLE : FCmpInst::FCMP_ULE; break; 11341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper case 7: 1145d2e1889622cc20ada6146041e6d862a6588194fOwen Anderson if (!isordered) return ConstantInt::getTrue(LHS->getContext()); 1155d2e1889622cc20ada6146041e6d862a6588194fOwen Anderson Pred = FCmpInst::FCMP_ORD; break; 11625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 117f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateFCmp(Pred, LHS, RHS); 11825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 11925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 12025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner// OptAndOp - This handles expressions of the form ((val OP C1) & C2). Where 12125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner// the Op parameter is 'OP', OpRHS is 'C1', and AndRHS is 'C2'. Op is 12225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner// guaranteed to be a binary operator. 12325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris LattnerInstruction *InstCombiner::OptAndOp(Instruction *Op, 12425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt *OpRHS, 12525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt *AndRHS, 12625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner BinaryOperator &TheAnd) { 12725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *X = Op->getOperand(0); 128dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Constant *Together = nullptr; 12925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (!Op->isShift()) 13025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Together = ConstantExpr::getAnd(AndRHS, OpRHS); 13125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 13225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (Op->getOpcode()) { 13325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case Instruction::Xor: 13425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op->hasOneUse()) { 13525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (X ^ C1) & C2 --> (X & C2) ^ (C1&C2) 13625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *And = Builder->CreateAnd(X, AndRHS); 13725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner And->takeName(Op); 13825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateXor(And, Together); 13925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 14025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 14125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case Instruction::Or: 1422c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson if (Op->hasOneUse()){ 1432c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson if (Together != OpRHS) { 1442c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson // (X | C1) & C2 --> (X | (C1&C2)) & C2 1452c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson Value *Or = Builder->CreateOr(X, Together); 1462c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson Or->takeName(Op); 1472c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson return BinaryOperator::CreateAnd(Or, AndRHS); 1482c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson } 14941a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 1502c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson ConstantInt *TogetherCI = dyn_cast<ConstantInt>(Together); 1512c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson if (TogetherCI && !TogetherCI->isZero()){ 1522c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson // (X | C1) & C2 --> (X & (C2^(C1&C2))) | C1 1532c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson // NOTE: This reduces the number of bits set in the & mask, which 1542c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson // can expose opportunities for store narrowing. 1552c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson Together = ConstantExpr::getXor(AndRHS, Together); 1562c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson Value *And = Builder->CreateAnd(X, Together); 1572c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson And->takeName(Op); 1582c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson return BinaryOperator::CreateOr(And, OpRHS); 1592c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson } 16025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 16141a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 16225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 16325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case Instruction::Add: 16425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op->hasOneUse()) { 16525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Adding a one to a single bit bit-field should be turned into an XOR 16625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // of the bit. First thing to check is to see if this AND is with a 16725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // single bit constant. 168c6e2ab3a573af4d3b486eb9164cce8e6760ef8ddJakub Staszak const APInt &AndRHSV = AndRHS->getValue(); 16925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 17025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If there is only one bit set. 17125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (AndRHSV.isPowerOf2()) { 17225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Ok, at this point, we know that we are masking the result of the 17325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ADD down to exactly one bit. If the constant we are adding has 17425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // no bits set below this bit, then we can eliminate the ADD. 175c6e2ab3a573af4d3b486eb9164cce8e6760ef8ddJakub Staszak const APInt& AddRHS = OpRHS->getValue(); 17625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 17725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Check to see if any bits below the one bit set in AndRHSV are set. 17825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if ((AddRHS & (AndRHSV-1)) == 0) { 17925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If not, the only thing that can effect the output of the AND is 18025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // the bit specified by AndRHSV. If that bit is set, the effect of 18125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // the XOR is to toggle the bit. If it is clear, then the ADD has 18225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // no effect. 18325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if ((AddRHS & AndRHSV) == 0) { // Bit is not set, noop 18425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner TheAnd.setOperand(0, X); 18525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return &TheAnd; 18625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } else { 18725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Pull the XOR out of the AND. 18825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NewAnd = Builder->CreateAnd(X, AndRHS); 18925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner NewAnd->takeName(Op); 19025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateXor(NewAnd, AndRHS); 19125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 19225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 19325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 19425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 19525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 19625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 19725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case Instruction::Shl: { 19825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // We know that the AND will not produce any of the bits shifted in, so if 19925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // the anded constant includes them, clear them now! 20025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // 20125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner uint32_t BitWidth = AndRHS->getType()->getBitWidth(); 20225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner uint32_t OpRHSVal = OpRHS->getLimitedValue(BitWidth); 20325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner APInt ShlMask(APInt::getHighBitsSet(BitWidth, BitWidth-OpRHSVal)); 204f2d03d74ffe05d08ac7dccbb81f41d996a1f1d2aJakub Staszak ConstantInt *CI = Builder->getInt(AndRHS->getValue() & ShlMask); 20525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 206da1d660aa285b724818bdd547f1b538011cc5459Chris Lattner if (CI->getValue() == ShlMask) 207da1d660aa285b724818bdd547f1b538011cc5459Chris Lattner // Masking out bits that the shift already masks. 20825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return ReplaceInstUsesWith(TheAnd, Op); // No need for the and. 20941a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 210da1d660aa285b724818bdd547f1b538011cc5459Chris Lattner if (CI != AndRHS) { // Reducing bits set in and. 21125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner TheAnd.setOperand(1, CI); 21225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return &TheAnd; 21325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 21425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 21525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 21625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case Instruction::LShr: { 21725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // We know that the AND will not produce any of the bits shifted in, so if 21825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // the anded constant includes them, clear them now! This only applies to 21925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // unsigned shifts, because a signed shr may bring in set bits! 22025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // 22125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner uint32_t BitWidth = AndRHS->getType()->getBitWidth(); 22225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner uint32_t OpRHSVal = OpRHS->getLimitedValue(BitWidth); 22325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner APInt ShrMask(APInt::getLowBitsSet(BitWidth, BitWidth - OpRHSVal)); 224f2d03d74ffe05d08ac7dccbb81f41d996a1f1d2aJakub Staszak ConstantInt *CI = Builder->getInt(AndRHS->getValue() & ShrMask); 22525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 226da1d660aa285b724818bdd547f1b538011cc5459Chris Lattner if (CI->getValue() == ShrMask) 227da1d660aa285b724818bdd547f1b538011cc5459Chris Lattner // Masking out bits that the shift already masks. 22825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return ReplaceInstUsesWith(TheAnd, Op); 22941a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 230da1d660aa285b724818bdd547f1b538011cc5459Chris Lattner if (CI != AndRHS) { 23125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner TheAnd.setOperand(1, CI); // Reduce bits set in and cst. 23225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return &TheAnd; 23325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 23425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 23525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 23625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case Instruction::AShr: 23725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Signed shr. 23825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // See if this is shifting in some sign extension, then masking it out 23925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // with an and. 24025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op->hasOneUse()) { 24125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner uint32_t BitWidth = AndRHS->getType()->getBitWidth(); 24225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner uint32_t OpRHSVal = OpRHS->getLimitedValue(BitWidth); 24325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner APInt ShrMask(APInt::getLowBitsSet(BitWidth, BitWidth - OpRHSVal)); 244f2d03d74ffe05d08ac7dccbb81f41d996a1f1d2aJakub Staszak Constant *C = Builder->getInt(AndRHS->getValue() & ShrMask); 24525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (C == AndRHS) { // Masking out bits shifted in. 24625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (Val ashr C1) & C2 -> (Val lshr C1) & C2 24725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Make the argument unsigned. 24825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *ShVal = Op->getOperand(0); 24925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ShVal = Builder->CreateLShr(ShVal, OpRHS, Op->getName()); 25025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateAnd(ShVal, AndRHS, TheAnd.getName()); 25125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 25225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 25325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 25425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 255dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 25625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 25725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 25803fceff6f69a0261a767aab8e62de8aa9301b86cJim Grosbach/// Emit a computation of: (V >= Lo && V < Hi) if Inside is true, otherwise 25903fceff6f69a0261a767aab8e62de8aa9301b86cJim Grosbach/// (V < Lo || V >= Hi). In practice, we emit the more efficient 26045fc0b65e22124333d0545675e18d2dd00ebe967NAKAMURA Takumi/// (V-Lo) \<u Hi-Lo. This method expects that Lo <= Hi. isSigned indicates 26125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// whether to treat the V, Lo and HI as signed or not. IB is the location to 26225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// insert new instructions. 263f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris LattnerValue *InstCombiner::InsertRangeTest(Value *V, Constant *Lo, Constant *Hi, 264f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner bool isSigned, bool Inside) { 26541a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper assert(cast<ConstantInt>(ConstantExpr::getICmp((isSigned ? 26625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ICmpInst::ICMP_SLE:ICmpInst::ICMP_ULE), Lo, Hi))->getZExtValue() && 26725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner "Lo is not <= Hi in range emission code!"); 26841a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 26925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Inside) { 27025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Lo == Hi) // Trivially false. 271f2d03d74ffe05d08ac7dccbb81f41d996a1f1d2aJakub Staszak return Builder->getFalse(); 27225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 27325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // V >= Min && V < Hi --> V < Hi 27425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (cast<ConstantInt>(Lo)->isMinValue(isSigned)) { 27541a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper ICmpInst::Predicate pred = (isSigned ? 27625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ICmpInst::ICMP_SLT : ICmpInst::ICMP_ULT); 277f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateICmp(pred, V, Hi); 27825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 27925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 28025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Emit V-Lo <u Hi-Lo 28125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Constant *NegLo = ConstantExpr::getNeg(Lo); 28225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Add = Builder->CreateAdd(V, NegLo, V->getName()+".off"); 28325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Constant *UpperBound = ConstantExpr::getAdd(NegLo, Hi); 284f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateICmpULT(Add, UpperBound); 28525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 28625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 28725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Lo == Hi) // Trivially true. 288f2d03d74ffe05d08ac7dccbb81f41d996a1f1d2aJakub Staszak return Builder->getTrue(); 28925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 29025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // V < Min || V >= Hi -> V > Hi-1 29125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Hi = SubOne(cast<ConstantInt>(Hi)); 29225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (cast<ConstantInt>(Lo)->isMinValue(isSigned)) { 29341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper ICmpInst::Predicate pred = (isSigned ? 29425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ICmpInst::ICMP_SGT : ICmpInst::ICMP_UGT); 295f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateICmp(pred, V, Hi); 29625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 29725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 29825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Emit V-Lo >u Hi-1-Lo 29925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Note that Hi has already had one subtracted from it, above. 30025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt *NegLo = cast<ConstantInt>(ConstantExpr::getNeg(Lo)); 30125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Add = Builder->CreateAdd(V, NegLo, V->getName()+".off"); 30225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Constant *LowerBound = ConstantExpr::getAdd(NegLo, Hi); 303f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateICmpUGT(Add, LowerBound); 30425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 30525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 30694c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru// isRunOfOnes - Returns true iff Val consists of one contiguous run of 1s with 30725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner// any number of 0s on either side. The 1s are allowed to wrap from LSB to 30825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner// MSB, so 0x000FFF0, 0x0000FFFF, and 0xFF0000FF are all runs. 0x0F0F0000 is 30925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner// not, since all 1s are not contiguous. 31025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattnerstatic bool isRunOfOnes(ConstantInt *Val, uint32_t &MB, uint32_t &ME) { 31125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner const APInt& V = Val->getValue(); 31225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner uint32_t BitWidth = Val->getType()->getBitWidth(); 31325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (!APIntOps::isShiftedMask(BitWidth, V)) return false; 31425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 31525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // look for the first zero bit after the run of ones 31625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner MB = BitWidth - ((V - 1) ^ V).countLeadingZeros(); 31725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // look for the first non-zero bit 31841a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper ME = V.getActiveBits(); 31925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return true; 32025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 32125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 32225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// FoldLogicalPlusAnd - This is part of an expression (LHS +/- RHS) & Mask, 32325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// where isSub determines whether the operator is a sub. If we can fold one of 32425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// the following xforms: 32541a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper/// 32694c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru/// ((A & N) +/- B) & Mask -> (A +/- B) & Mask iff N&Mask == Mask 32794c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru/// ((A | N) +/- B) & Mask -> (A +/- B) & Mask iff N&Mask == 0 32894c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru/// ((A ^ N) +/- B) & Mask -> (A +/- B) & Mask iff N&Mask == 0 32925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// 33025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// return (A +/- B). 33125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// 33225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris LattnerValue *InstCombiner::FoldLogicalPlusAnd(Value *LHS, Value *RHS, 33325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt *Mask, bool isSub, 33425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Instruction &I) { 33525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Instruction *LHSI = dyn_cast<Instruction>(LHS); 33625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (!LHSI || LHSI->getNumOperands() != 2 || 337dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines !isa<ConstantInt>(LHSI->getOperand(1))) return nullptr; 33825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 33925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt *N = cast<ConstantInt>(LHSI->getOperand(1)); 34025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 34125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (LHSI->getOpcode()) { 342dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines default: return nullptr; 34325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case Instruction::And: 34425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ConstantExpr::getAnd(N, Mask) == Mask) { 34525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If the AndRHS is a power of two minus one (0+1+), this is simple. 34641a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper if ((Mask->getValue().countLeadingZeros() + 34741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper Mask->getValue().countPopulation()) == 34825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Mask->getValue().getBitWidth()) 34925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 35025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 35125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Otherwise, if Mask is 0+1+0+, and if B is known to have the low 0+ 35225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // part, we don't need any explicit masks to take them out of A. If that 35325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // is all N is, ignore it. 35425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner uint32_t MB = 0, ME = 0; 35525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (isRunOfOnes(Mask, MB, ME)) { // begin/end bit of run, inclusive 35625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner uint32_t BitWidth = cast<IntegerType>(RHS->getType())->getBitWidth(); 35725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner APInt Mask(APInt::getLowBitsSet(BitWidth, MB-1)); 35825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (MaskedValueIsZero(RHS, Mask)) 35925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 36025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 36125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 362dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 36325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case Instruction::Or: 36425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case Instruction::Xor: 36525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If the AndRHS is a power of two minus one (0+1+), and N&Mask == 0 36641a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper if ((Mask->getValue().countLeadingZeros() + 36725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Mask->getValue().countPopulation()) == Mask->getValue().getBitWidth() 36825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner && ConstantExpr::getAnd(N, Mask)->isNullValue()) 36925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 370dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 37125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 37241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 37325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (isSub) 37425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return Builder->CreateSub(LHSI->getOperand(0), RHS, "fold"); 37525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return Builder->CreateAdd(LHSI->getOperand(0), RHS, "fold"); 37625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 37725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 3785c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// enum for classifying (icmp eq (A & B), C) and (icmp ne (A & B), C) 37941a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper/// One of A and B is considered the mask, the other the value. This is 38041a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper/// described as the "AMask" or "BMask" part of the enum. If the enum 3815c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// contains only "Mask", then both A and B can be considered masks. 3825c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// If A is the mask, then it was proven, that (A & C) == C. This 3835c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// is trivial if C == A, or C == 0. If both A and C are constants, this 3845c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// proof is also easy. 3855c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// For the following explanations we assume that A is the mask. 38641a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper/// The part "AllOnes" declares, that the comparison is true only 3875c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// if (A & B) == A, or all bits of A are set in B. 3885c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// Example: (icmp eq (A & 3), 3) -> FoldMskICmp_AMask_AllOnes 38941a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper/// The part "AllZeroes" declares, that the comparison is true only 3905c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// if (A & B) == 0, or all bits of A are cleared in B. 3915c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// Example: (icmp eq (A & 3), 0) -> FoldMskICmp_Mask_AllZeroes 39241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper/// The part "Mixed" declares, that (A & B) == C and C might or might not 3935c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// contain any number of one bits and zero bits. 3945c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// Example: (icmp eq (A & 3), 1) -> FoldMskICmp_AMask_Mixed 3955c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// The Part "Not" means, that in above descriptions "==" should be replaced 3965c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// by "!=". 3975c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// Example: (icmp ne (A & 3), 3) -> FoldMskICmp_AMask_NotAllOnes 3985c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// If the mask A contains a single bit, then the following is equivalent: 3995c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// (icmp eq (A & B), A) equals (icmp ne (A & B), 0) 4005c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// (icmp ne (A & B), A) equals (icmp eq (A & B), 0) 4015c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Andersonenum MaskedICmpType { 4025c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_AMask_AllOnes = 1, 4035c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_AMask_NotAllOnes = 2, 4045c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_BMask_AllOnes = 4, 4055c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_BMask_NotAllOnes = 8, 4065c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_Mask_AllZeroes = 16, 4075c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_Mask_NotAllZeroes = 32, 4085c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_AMask_Mixed = 64, 4095c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_AMask_NotMixed = 128, 4105c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_BMask_Mixed = 256, 4115c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_BMask_NotMixed = 512 4125c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson}; 4135c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson 4145c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// return the set of pattern classes (from MaskedICmpType) 4155c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// that (icmp SCC (A & B), C) satisfies 41641a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topperstatic unsigned getTypeOfMaskedICmp(Value* A, Value* B, Value* C, 4175c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson ICmpInst::Predicate SCC) 4185c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson{ 4195c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson ConstantInt *ACst = dyn_cast<ConstantInt>(A); 4205c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson ConstantInt *BCst = dyn_cast<ConstantInt>(B); 4215c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson ConstantInt *CCst = dyn_cast<ConstantInt>(C); 4225c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson bool icmp_eq = (SCC == ICmpInst::ICMP_EQ); 423dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines bool icmp_abit = (ACst && !ACst->isZero() && 4245c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson ACst->getValue().isPowerOf2()); 425dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines bool icmp_bbit = (BCst && !BCst->isZero() && 4265c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson BCst->getValue().isPowerOf2()); 4275c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson unsigned result = 0; 428dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (CCst && CCst->isZero()) { 4295c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // if C is zero, then both A and B qualify as mask 4305c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson result |= (icmp_eq ? (FoldMskICmp_Mask_AllZeroes | 4315c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_Mask_AllZeroes | 4325c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_AMask_Mixed | 4335c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_BMask_Mixed) 4345c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson : (FoldMskICmp_Mask_NotAllZeroes | 4355c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_Mask_NotAllZeroes | 4365c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_AMask_NotMixed | 4375c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_BMask_NotMixed)); 4385c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (icmp_abit) 4395c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson result |= (icmp_eq ? (FoldMskICmp_AMask_NotAllOnes | 44041a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper FoldMskICmp_AMask_NotMixed) 4415c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson : (FoldMskICmp_AMask_AllOnes | 4425c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_AMask_Mixed)); 4435c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (icmp_bbit) 4445c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson result |= (icmp_eq ? (FoldMskICmp_BMask_NotAllOnes | 44541a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper FoldMskICmp_BMask_NotMixed) 4465c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson : (FoldMskICmp_BMask_AllOnes | 4475c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_BMask_Mixed)); 4485c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson return result; 4495c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson } 4505c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (A == C) { 4515c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson result |= (icmp_eq ? (FoldMskICmp_AMask_AllOnes | 4525c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_AMask_Mixed) 4535c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson : (FoldMskICmp_AMask_NotAllOnes | 4545c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_AMask_NotMixed)); 4555c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (icmp_abit) 4565c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson result |= (icmp_eq ? (FoldMskICmp_Mask_NotAllZeroes | 4575c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_AMask_NotMixed) 4585c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson : (FoldMskICmp_Mask_AllZeroes | 4595c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_AMask_Mixed)); 460dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines } else if (ACst && CCst && 46100f8102758316cf754668b98c748c2a349f37966Craig Topper ConstantExpr::getAnd(ACst, CCst) == CCst) { 4625c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson result |= (icmp_eq ? FoldMskICmp_AMask_Mixed 4635c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson : FoldMskICmp_AMask_NotMixed); 4645c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson } 46500f8102758316cf754668b98c748c2a349f37966Craig Topper if (B == C) { 4665c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson result |= (icmp_eq ? (FoldMskICmp_BMask_AllOnes | 4675c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_BMask_Mixed) 4685c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson : (FoldMskICmp_BMask_NotAllOnes | 4695c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_BMask_NotMixed)); 4705c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (icmp_bbit) 4715c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson result |= (icmp_eq ? (FoldMskICmp_Mask_NotAllZeroes | 47241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper FoldMskICmp_BMask_NotMixed) 4735c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson : (FoldMskICmp_Mask_AllZeroes | 4745c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson FoldMskICmp_BMask_Mixed)); 475dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines } else if (BCst && CCst && 47600f8102758316cf754668b98c748c2a349f37966Craig Topper ConstantExpr::getAnd(BCst, CCst) == CCst) { 4775c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson result |= (icmp_eq ? FoldMskICmp_BMask_Mixed 4785c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson : FoldMskICmp_BMask_NotMixed); 4795c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson } 4805c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson return result; 4815c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson} 4825c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson 4837bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover/// Convert an analysis of a masked ICmp into its equivalent if all boolean 4847bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover/// operations had the opposite sense. Since each "NotXXX" flag (recording !=) 4857bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover/// is adjacent to the corresponding normal flag (recording ==), this just 4867bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover/// involves swapping those bits over. 4877bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northoverstatic unsigned conjugateICmpMask(unsigned Mask) { 4887bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover unsigned NewMask; 4897bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover NewMask = (Mask & (FoldMskICmp_AMask_AllOnes | FoldMskICmp_BMask_AllOnes | 4907bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover FoldMskICmp_Mask_AllZeroes | FoldMskICmp_AMask_Mixed | 4917bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover FoldMskICmp_BMask_Mixed)) 4927bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover << 1; 4937bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover 4947bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover NewMask |= 4957bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover (Mask & (FoldMskICmp_AMask_NotAllOnes | FoldMskICmp_BMask_NotAllOnes | 4967bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover FoldMskICmp_Mask_NotAllZeroes | FoldMskICmp_AMask_NotMixed | 4977bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover FoldMskICmp_BMask_NotMixed)) 4987bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover >> 1; 4997bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover 5007bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover return NewMask; 5017bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover} 5027bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover 50347a86077212bb680c3273842b1aba801757836eaBenjamin Kramer/// decomposeBitTestICmp - Decompose an icmp into the form ((X & Y) pred Z) 50447a86077212bb680c3273842b1aba801757836eaBenjamin Kramer/// if possible. The returned predicate is either == or !=. Returns false if 50547a86077212bb680c3273842b1aba801757836eaBenjamin Kramer/// decomposition fails. 50647a86077212bb680c3273842b1aba801757836eaBenjamin Kramerstatic bool decomposeBitTestICmp(const ICmpInst *I, ICmpInst::Predicate &Pred, 50747a86077212bb680c3273842b1aba801757836eaBenjamin Kramer Value *&X, Value *&Y, Value *&Z) { 50836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines ConstantInt *C = dyn_cast<ConstantInt>(I->getOperand(1)); 50936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (!C) 51036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return false; 51147a86077212bb680c3273842b1aba801757836eaBenjamin Kramer 51236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines switch (I->getPredicate()) { 51336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines default: 51436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return false; 51536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case ICmpInst::ICMP_SLT: 51636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // X < 0 is equivalent to (X & SignBit) != 0. 51736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (!C->isZero()) 51836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return false; 51936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Y = ConstantInt::get(I->getContext(), APInt::getSignBit(C->getBitWidth())); 52036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Pred = ICmpInst::ICMP_NE; 52136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines break; 52236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case ICmpInst::ICMP_SGT: 52336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // X > -1 is equivalent to (X & SignBit) == 0. 52436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (!C->isAllOnesValue()) 52536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return false; 52636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Y = ConstantInt::get(I->getContext(), APInt::getSignBit(C->getBitWidth())); 52736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Pred = ICmpInst::ICMP_EQ; 52836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines break; 52936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case ICmpInst::ICMP_ULT: 53036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // X <u 2^n is equivalent to (X & ~(2^n-1)) == 0. 53136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (!C->getValue().isPowerOf2()) 53236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return false; 53336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Y = ConstantInt::get(I->getContext(), -C->getValue()); 53436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Pred = ICmpInst::ICMP_EQ; 53536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines break; 53636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case ICmpInst::ICMP_UGT: 53736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines // X >u 2^n-1 is equivalent to (X & ~(2^n-1)) != 0. 53836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (!(C->getValue() + 1).isPowerOf2()) 53936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return false; 54036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Y = ConstantInt::get(I->getContext(), ~C->getValue()); 54136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Pred = ICmpInst::ICMP_NE; 54236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines break; 54336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines } 54447a86077212bb680c3273842b1aba801757836eaBenjamin Kramer 54536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines X = I->getOperand(0); 54636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Z = ConstantInt::getNullValue(C->getType()); 54736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return true; 54847a86077212bb680c3273842b1aba801757836eaBenjamin Kramer} 54947a86077212bb680c3273842b1aba801757836eaBenjamin Kramer 5505c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// foldLogOpOfMaskedICmpsHelper: 5515c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// handle (icmp(A & B) ==/!= C) &/| (icmp(A & D) ==/!= E) 5525c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// return the set of pattern classes (from MaskedICmpType) 5535c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// that both LHS and RHS satisfy 55441a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topperstatic unsigned foldLogOpOfMaskedICmpsHelper(Value*& A, 5555c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value*& B, Value*& C, 5565c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value*& D, Value*& E, 55747a86077212bb680c3273842b1aba801757836eaBenjamin Kramer ICmpInst *LHS, ICmpInst *RHS, 55847a86077212bb680c3273842b1aba801757836eaBenjamin Kramer ICmpInst::Predicate &LHSCC, 55947a86077212bb680c3273842b1aba801757836eaBenjamin Kramer ICmpInst::Predicate &RHSCC) { 5605c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (LHS->getOperand(0)->getType() != RHS->getOperand(0)->getType()) return 0; 5615c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // vectors are not (yet?) supported 5625c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (LHS->getOperand(0)->getType()->isVectorTy()) return 0; 5635c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson 5645c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // Here comes the tricky part: 56541a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper // LHS might be of the form L11 & L12 == X, X == L21 & L22, 5665c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // and L11 & L12 == L21 & L22. The same goes for RHS. 5675c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // Now we must find those components L** and R**, that are equal, so 56841a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper // that we can extract the parameters A, B, C, D, and E for the canonical 5695c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // above. 5705c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value *L1 = LHS->getOperand(0); 5715c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value *L2 = LHS->getOperand(1); 5725c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value *L11,*L12,*L21,*L22; 57347a86077212bb680c3273842b1aba801757836eaBenjamin Kramer // Check whether the icmp can be decomposed into a bit test. 57447a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (decomposeBitTestICmp(LHS, LHSCC, L11, L12, L2)) { 575dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines L21 = L22 = L1 = nullptr; 57647a86077212bb680c3273842b1aba801757836eaBenjamin Kramer } else { 57747a86077212bb680c3273842b1aba801757836eaBenjamin Kramer // Look for ANDs in the LHS icmp. 5780415b1810bbf93f434f1c561e172bf24c1cb37dcTim Northover if (!L1->getType()->isIntegerTy()) { 5790415b1810bbf93f434f1c561e172bf24c1cb37dcTim Northover // You can icmp pointers, for example. They really aren't masks. 580dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines L11 = L12 = nullptr; 5810415b1810bbf93f434f1c561e172bf24c1cb37dcTim Northover } else if (!match(L1, m_And(m_Value(L11), m_Value(L12)))) { 5820415b1810bbf93f434f1c561e172bf24c1cb37dcTim Northover // Any icmp can be viewed as being trivially masked; if it allows us to 5830415b1810bbf93f434f1c561e172bf24c1cb37dcTim Northover // remove one, it's worth it. 5840415b1810bbf93f434f1c561e172bf24c1cb37dcTim Northover L11 = L1; 5850415b1810bbf93f434f1c561e172bf24c1cb37dcTim Northover L12 = Constant::getAllOnesValue(L1->getType()); 5860415b1810bbf93f434f1c561e172bf24c1cb37dcTim Northover } 5870415b1810bbf93f434f1c561e172bf24c1cb37dcTim Northover 5880415b1810bbf93f434f1c561e172bf24c1cb37dcTim Northover if (!L2->getType()->isIntegerTy()) { 5890415b1810bbf93f434f1c561e172bf24c1cb37dcTim Northover // You can icmp pointers, for example. They really aren't masks. 590dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines L21 = L22 = nullptr; 5910415b1810bbf93f434f1c561e172bf24c1cb37dcTim Northover } else if (!match(L2, m_And(m_Value(L21), m_Value(L22)))) { 5920415b1810bbf93f434f1c561e172bf24c1cb37dcTim Northover L21 = L2; 5930415b1810bbf93f434f1c561e172bf24c1cb37dcTim Northover L22 = Constant::getAllOnesValue(L2->getType()); 59447a86077212bb680c3273842b1aba801757836eaBenjamin Kramer } 5955c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson } 5965c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson 59747a86077212bb680c3273842b1aba801757836eaBenjamin Kramer // Bail if LHS was a icmp that can't be decomposed into an equality. 59847a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (!ICmpInst::isEquality(LHSCC)) 59947a86077212bb680c3273842b1aba801757836eaBenjamin Kramer return 0; 60047a86077212bb680c3273842b1aba801757836eaBenjamin Kramer 6015c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value *R1 = RHS->getOperand(0); 6025c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value *R2 = RHS->getOperand(1); 6035c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value *R11,*R12; 6045c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson bool ok = false; 60547a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (decomposeBitTestICmp(RHS, RHSCC, R11, R12, R2)) { 60647a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (R11 == L11 || R11 == L12 || R11 == L21 || R11 == L22) { 60747a86077212bb680c3273842b1aba801757836eaBenjamin Kramer A = R11; D = R12; 60847a86077212bb680c3273842b1aba801757836eaBenjamin Kramer } else if (R12 == L11 || R12 == L12 || R12 == L21 || R12 == L22) { 60947a86077212bb680c3273842b1aba801757836eaBenjamin Kramer A = R12; D = R11; 61047a86077212bb680c3273842b1aba801757836eaBenjamin Kramer } else { 61147a86077212bb680c3273842b1aba801757836eaBenjamin Kramer return 0; 6125c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson } 613dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines E = R2; R1 = nullptr; ok = true; 6140415b1810bbf93f434f1c561e172bf24c1cb37dcTim Northover } else if (R1->getType()->isIntegerTy()) { 6150415b1810bbf93f434f1c561e172bf24c1cb37dcTim Northover if (!match(R1, m_And(m_Value(R11), m_Value(R12)))) { 6160415b1810bbf93f434f1c561e172bf24c1cb37dcTim Northover // As before, model no mask as a trivial mask if it'll let us do an 6170415b1810bbf93f434f1c561e172bf24c1cb37dcTim Northover // optimisation. 6180415b1810bbf93f434f1c561e172bf24c1cb37dcTim Northover R11 = R1; 6190415b1810bbf93f434f1c561e172bf24c1cb37dcTim Northover R12 = Constant::getAllOnesValue(R1->getType()); 6200415b1810bbf93f434f1c561e172bf24c1cb37dcTim Northover } 6210415b1810bbf93f434f1c561e172bf24c1cb37dcTim Northover 62247a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (R11 == L11 || R11 == L12 || R11 == L21 || R11 == L22) { 62347a86077212bb680c3273842b1aba801757836eaBenjamin Kramer A = R11; D = R12; E = R2; ok = true; 62447a86077212bb680c3273842b1aba801757836eaBenjamin Kramer } else if (R12 == L11 || R12 == L12 || R12 == L21 || R12 == L22) { 6255c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson A = R12; D = R11; E = R2; ok = true; 6265c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson } 6275c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson } 62847a86077212bb680c3273842b1aba801757836eaBenjamin Kramer 62947a86077212bb680c3273842b1aba801757836eaBenjamin Kramer // Bail if RHS was a icmp that can't be decomposed into an equality. 63047a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (!ICmpInst::isEquality(RHSCC)) 63147a86077212bb680c3273842b1aba801757836eaBenjamin Kramer return 0; 63247a86077212bb680c3273842b1aba801757836eaBenjamin Kramer 63347a86077212bb680c3273842b1aba801757836eaBenjamin Kramer // Look for ANDs in on the right side of the RHS icmp. 6340415b1810bbf93f434f1c561e172bf24c1cb37dcTim Northover if (!ok && R2->getType()->isIntegerTy()) { 6350415b1810bbf93f434f1c561e172bf24c1cb37dcTim Northover if (!match(R2, m_And(m_Value(R11), m_Value(R12)))) { 6360415b1810bbf93f434f1c561e172bf24c1cb37dcTim Northover R11 = R2; 6370415b1810bbf93f434f1c561e172bf24c1cb37dcTim Northover R12 = Constant::getAllOnesValue(R2->getType()); 6380415b1810bbf93f434f1c561e172bf24c1cb37dcTim Northover } 6390415b1810bbf93f434f1c561e172bf24c1cb37dcTim Northover 64047a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (R11 == L11 || R11 == L12 || R11 == L21 || R11 == L22) { 64147a86077212bb680c3273842b1aba801757836eaBenjamin Kramer A = R11; D = R12; E = R1; ok = true; 64247a86077212bb680c3273842b1aba801757836eaBenjamin Kramer } else if (R12 == L11 || R12 == L12 || R12 == L21 || R12 == L22) { 6435c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson A = R12; D = R11; E = R1; ok = true; 64447a86077212bb680c3273842b1aba801757836eaBenjamin Kramer } else { 6455c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson return 0; 64647a86077212bb680c3273842b1aba801757836eaBenjamin Kramer } 6475c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson } 6485c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (!ok) 6495c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson return 0; 6505c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson 6515c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (L11 == A) { 6525c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson B = L12; C = L2; 65300f8102758316cf754668b98c748c2a349f37966Craig Topper } else if (L12 == A) { 6545c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson B = L11; C = L2; 65500f8102758316cf754668b98c748c2a349f37966Craig Topper } else if (L21 == A) { 6565c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson B = L22; C = L1; 65700f8102758316cf754668b98c748c2a349f37966Craig Topper } else if (L22 == A) { 6585c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson B = L21; C = L1; 6595c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson } 6605c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson 6615c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson unsigned left_type = getTypeOfMaskedICmp(A, B, C, LHSCC); 6625c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson unsigned right_type = getTypeOfMaskedICmp(A, D, E, RHSCC); 6635c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson return left_type & right_type; 6645c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson} 6655c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// foldLogOpOfMaskedICmps: 6665c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// try to fold (icmp(A & B) ==/!= C) &/| (icmp(A & D) ==/!= E) 6675c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson/// into a single (icmp(A & X) ==/!= Y) 6687bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northoverstatic Value* foldLogOpOfMaskedICmps(ICmpInst *LHS, ICmpInst *RHS, bool IsAnd, 6695c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson llvm::InstCombiner::BuilderTy* Builder) { 670dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Value *A = nullptr, *B = nullptr, *C = nullptr, *D = nullptr, *E = nullptr; 67147a86077212bb680c3273842b1aba801757836eaBenjamin Kramer ICmpInst::Predicate LHSCC = LHS->getPredicate(), RHSCC = RHS->getPredicate(); 67247a86077212bb680c3273842b1aba801757836eaBenjamin Kramer unsigned mask = foldLogOpOfMaskedICmpsHelper(A, B, C, D, E, LHS, RHS, 67347a86077212bb680c3273842b1aba801757836eaBenjamin Kramer LHSCC, RHSCC); 674dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (mask == 0) return nullptr; 67547a86077212bb680c3273842b1aba801757836eaBenjamin Kramer assert(ICmpInst::isEquality(LHSCC) && ICmpInst::isEquality(RHSCC) && 67647a86077212bb680c3273842b1aba801757836eaBenjamin Kramer "foldLogOpOfMaskedICmpsHelper must return an equality predicate."); 6775c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson 6787bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover // In full generality: 6797bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover // (icmp (A & B) Op C) | (icmp (A & D) Op E) 6807bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover // == ![ (icmp (A & B) !Op C) & (icmp (A & D) !Op E) ] 6817bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover // 6827bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover // If the latter can be converted into (icmp (A & X) Op Y) then the former is 6837bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover // equivalent to (icmp (A & X) !Op Y). 6847bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover // 6857bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover // Therefore, we can pretend for the rest of this function that we're dealing 6867bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover // with the conjunction, provided we flip the sense of any comparisons (both 6877bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover // input and output). 6887bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover 6897bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover // In most cases we're going to produce an EQ for the "&&" case. 6907bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover ICmpInst::Predicate NEWCC = IsAnd ? ICmpInst::ICMP_EQ : ICmpInst::ICMP_NE; 6917bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover if (!IsAnd) { 6927bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover // Convert the masking analysis into its equivalent with negated 6937bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover // comparisons. 6947bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover mask = conjugateICmpMask(mask); 6957bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover } 6965c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson 6975c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (mask & FoldMskICmp_Mask_AllZeroes) { 69841a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper // (icmp eq (A & B), 0) & (icmp eq (A & D), 0) 6995c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // -> (icmp eq (A & (B|D)), 0) 7005c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value* newOr = Builder->CreateOr(B, D); 7015c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value* newAnd = Builder->CreateAnd(A, newOr); 7025c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // we can't use C as zero, because we might actually handle 70341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper // (icmp ne (A & B), B) & (icmp ne (A & D), D) 7045c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // with B and D, having a single bit set 7055c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value* zero = Constant::getNullValue(A->getType()); 7065c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson return Builder->CreateICmp(NEWCC, newAnd, zero); 7075c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson } 70800f8102758316cf754668b98c748c2a349f37966Craig Topper if (mask & FoldMskICmp_BMask_AllOnes) { 70941a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper // (icmp eq (A & B), B) & (icmp eq (A & D), D) 7105c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // -> (icmp eq (A & (B|D)), (B|D)) 7115c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value* newOr = Builder->CreateOr(B, D); 7125c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value* newAnd = Builder->CreateAnd(A, newOr); 7135c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson return Builder->CreateICmp(NEWCC, newAnd, newOr); 71441a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper } 71500f8102758316cf754668b98c748c2a349f37966Craig Topper if (mask & FoldMskICmp_AMask_AllOnes) { 71641a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper // (icmp eq (A & B), A) & (icmp eq (A & D), A) 7175c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // -> (icmp eq (A & (B&D)), A) 7185c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value* newAnd1 = Builder->CreateAnd(B, D); 7195c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson Value* newAnd = Builder->CreateAnd(A, newAnd1); 7205c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson return Builder->CreateICmp(NEWCC, newAnd, A); 7215c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson } 7227bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover 7237bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover // Remaining cases assume at least that B and D are constant, and depend on 7247bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover // their actual values. This isn't strictly, necessary, just a "handle the 7257bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover // easy cases for now" decision. 7267bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover ConstantInt *BCst = dyn_cast<ConstantInt>(B); 727dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!BCst) return nullptr; 7287bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover ConstantInt *DCst = dyn_cast<ConstantInt>(D); 729dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!DCst) return nullptr; 7307bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover 7317bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover if (mask & (FoldMskICmp_Mask_NotAllZeroes | FoldMskICmp_BMask_NotAllOnes)) { 7327bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover // (icmp ne (A & B), 0) & (icmp ne (A & D), 0) and 7337bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover // (icmp ne (A & B), B) & (icmp ne (A & D), D) 7347bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover // -> (icmp ne (A & B), 0) or (icmp ne (A & D), 0) 7357bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover // Only valid if one of the masks is a superset of the other (check "B&D" is 7367bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover // the same as either B or D). 7377bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover APInt NewMask = BCst->getValue() & DCst->getValue(); 7387bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover 7397bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover if (NewMask == BCst->getValue()) 7407bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover return LHS; 7417bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover else if (NewMask == DCst->getValue()) 7427bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover return RHS; 7437bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover } 7447bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover if (mask & FoldMskICmp_AMask_NotAllOnes) { 7457bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover // (icmp ne (A & B), B) & (icmp ne (A & D), D) 7467bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover // -> (icmp ne (A & B), A) or (icmp ne (A & D), A) 7477bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover // Only valid if one of the masks is a superset of the other (check "B|D" is 7487bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover // the same as either B or D). 7497bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover APInt NewMask = BCst->getValue() | DCst->getValue(); 7507bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover 7517bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover if (NewMask == BCst->getValue()) 7527bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover return LHS; 7537bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover else if (NewMask == DCst->getValue()) 7547bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover return RHS; 7557bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover } 75600f8102758316cf754668b98c748c2a349f37966Craig Topper if (mask & FoldMskICmp_BMask_Mixed) { 75741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper // (icmp eq (A & B), C) & (icmp eq (A & D), E) 7585c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // We already know that B & C == C && D & E == E. 7595c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // If we can prove that (B & D) & (C ^ E) == 0, that is, the bits of 7605c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // C and E, which are shared by both the mask B and the mask D, don't 7615c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // contradict, then we can transform to 7625c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // -> (icmp eq (A & (B|D)), (C|E)) 7635c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // Currently, we only handle the case of B, C, D, and E being constant. 7645c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // we can't simply use C and E, because we might actually handle 76541a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper // (icmp ne (A & B), B) & (icmp eq (A & D), D) 7665c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // with B and D, having a single bit set 7675c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson ConstantInt *CCst = dyn_cast<ConstantInt>(C); 768dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!CCst) return nullptr; 76947a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (LHSCC != NEWCC) 7705c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson CCst = dyn_cast<ConstantInt>( ConstantExpr::getXor(BCst, CCst) ); 7715c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson ConstantInt *ECst = dyn_cast<ConstantInt>(E); 772dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!ECst) return nullptr; 77347a86077212bb680c3273842b1aba801757836eaBenjamin Kramer if (RHSCC != NEWCC) 7745c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson ECst = dyn_cast<ConstantInt>( ConstantExpr::getXor(DCst, ECst) ); 7755c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson ConstantInt* MCst = dyn_cast<ConstantInt>( 7765c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson ConstantExpr::getAnd(ConstantExpr::getAnd(BCst, DCst), 7775c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson ConstantExpr::getXor(CCst, ECst)) ); 7785c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // if there is a conflict we should actually return a false for the 7795c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson // whole construct 7805c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson if (!MCst->isZero()) 781dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 78244cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner Value *newOr1 = Builder->CreateOr(B, D); 78344cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner Value *newOr2 = ConstantExpr::getOr(CCst, ECst); 78444cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner Value *newAnd = Builder->CreateAnd(A, newOr1); 7855c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson return Builder->CreateICmp(NEWCC, newAnd, newOr2); 7865c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson } 787dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 7885c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson} 7895c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson 79025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// FoldAndOfICmps - Fold (icmp)&(icmp) if possible. 791f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris LattnerValue *InstCombiner::FoldAndOfICmps(ICmpInst *LHS, ICmpInst *RHS) { 79225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ICmpInst::Predicate LHSCC = LHS->getPredicate(), RHSCC = RHS->getPredicate(); 79325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 79425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (icmp1 A, B) & (icmp2 A, B) --> (icmp3 A, B) 79525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (PredicatesFoldable(LHSCC, RHSCC)) { 79625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHS->getOperand(0) == RHS->getOperand(1) && 79725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner LHS->getOperand(1) == RHS->getOperand(0)) 79825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner LHS->swapOperands(); 79925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHS->getOperand(0) == RHS->getOperand(0) && 80025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner LHS->getOperand(1) == RHS->getOperand(1)) { 80125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Op0 = LHS->getOperand(0), *Op1 = LHS->getOperand(1); 80225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner unsigned Code = getICmpCode(LHS) & getICmpCode(RHS); 80325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner bool isSigned = LHS->isSigned() || RHS->isSigned(); 8042e33944c101f2a08ed1d85e807830f2fc089dd06Pete Cooper return getNewICmpValue(isSigned, Code, Op0, Op1, Builder); 80525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 80625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 8075c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson 80844cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner // handle (roughly): (icmp eq (A & B), C) & (icmp eq (A & D), E) 8097bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover if (Value *V = foldLogOpOfMaskedICmps(LHS, RHS, true, Builder)) 81044cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner return V; 81141a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 81225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // This only handles icmp of constants: (icmp1 A, C1) & (icmp2 B, C2). 81325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Val = LHS->getOperand(0), *Val2 = RHS->getOperand(0); 81425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt *LHSCst = dyn_cast<ConstantInt>(LHS->getOperand(1)); 81525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt *RHSCst = dyn_cast<ConstantInt>(RHS->getOperand(1)); 816dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!LHSCst || !RHSCst) return nullptr; 81741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 81825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHSCst == RHSCst && LHSCC == RHSCC) { 81925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (icmp ult A, C) & (icmp ult B, C) --> (icmp ult (A|B), C) 82025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // where C is a power of 2 82125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHSCC == ICmpInst::ICMP_ULT && 82225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner LHSCst->getValue().isPowerOf2()) { 82325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NewOr = Builder->CreateOr(Val, Val2); 824f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateICmp(LHSCC, NewOr, LHSCst); 82525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 82641a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 82725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (icmp eq A, 0) & (icmp eq B, 0) --> (icmp eq (A|B), 0) 82825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHSCC == ICmpInst::ICMP_EQ && LHSCst->isZero()) { 82925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NewOr = Builder->CreateOr(Val, Val2); 830f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateICmp(LHSCC, NewOr, LHSCst); 83125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 83225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 833264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer 834e12d58362176a7ea7ead7afa157194c18359499fBenjamin Kramer // (trunc x) == C1 & (and x, CA) == C2 -> (and x, CA|CMAX) == C1|C2 835264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer // where CMAX is the all ones value for the truncated type, 83694c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // iff the lower bits of C2 and CA are zero. 837e1b66f11459c7f1523939fb6ac1dfdc93e1d26efBill Wendling if (LHSCC == ICmpInst::ICMP_EQ && LHSCC == RHSCC && 838264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer LHS->hasOneUse() && RHS->hasOneUse()) { 839264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer Value *V; 840dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines ConstantInt *AndCst, *SmallCst = nullptr, *BigCst = nullptr; 841264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer 842264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer // (trunc x) == C1 & (and x, CA) == C2 84300f8102758316cf754668b98c748c2a349f37966Craig Topper // (and x, CA) == C2 & (trunc x) == C1 844264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer if (match(Val2, m_Trunc(m_Value(V))) && 845264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer match(Val, m_And(m_Specific(V), m_ConstantInt(AndCst)))) { 846264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer SmallCst = RHSCst; 847264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer BigCst = LHSCst; 84800f8102758316cf754668b98c748c2a349f37966Craig Topper } else if (match(Val, m_Trunc(m_Value(V))) && 84900f8102758316cf754668b98c748c2a349f37966Craig Topper match(Val2, m_And(m_Specific(V), m_ConstantInt(AndCst)))) { 850264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer SmallCst = LHSCst; 851264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer BigCst = RHSCst; 852264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer } 853264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer 854264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer if (SmallCst && BigCst) { 855264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer unsigned BigBitSize = BigCst->getType()->getBitWidth(); 856264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer unsigned SmallBitSize = SmallCst->getType()->getBitWidth(); 857264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer 858264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer // Check that the low bits are zero. 859264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer APInt Low = APInt::getLowBitsSet(BigBitSize, SmallBitSize); 860b0884f3f13ca6e5d83e3232d8390a4d58739d57cBenjamin Kramer if ((Low & AndCst->getValue()) == 0 && (Low & BigCst->getValue()) == 0) { 861264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer Value *NewAnd = Builder->CreateAnd(V, Low | AndCst->getValue()); 862264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer APInt N = SmallCst->getValue().zext(BigBitSize) | BigCst->getValue(); 863264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer Value *NewVal = ConstantInt::get(AndCst->getType()->getContext(), N); 864264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer return Builder->CreateICmp(LHSCC, NewAnd, NewVal); 865264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer } 866264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer } 867264ac878b26e90fe446aba9163d714d28d05bd8dBenjamin Kramer } 868dfb806f6ba53b792171b928b57def9d0182d2f5fBenjamin Kramer 86925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // From here on, we only handle: 87025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (icmp1 A, C1) & (icmp2 A, C2) --> something simpler. 871dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (Val != Val2) return nullptr; 87241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 87325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ICMP_[US][GL]E X, CST is folded to ICMP_[US][GL]T elsewhere. 87425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHSCC == ICmpInst::ICMP_UGE || LHSCC == ICmpInst::ICMP_ULE || 87525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner RHSCC == ICmpInst::ICMP_UGE || RHSCC == ICmpInst::ICMP_ULE || 87625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner LHSCC == ICmpInst::ICMP_SGE || LHSCC == ICmpInst::ICMP_SLE || 87725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner RHSCC == ICmpInst::ICMP_SGE || RHSCC == ICmpInst::ICMP_SLE) 878dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 879d70be0b2c199183077626a9e756ecd14b807dd56Anders Carlsson 880d70be0b2c199183077626a9e756ecd14b807dd56Anders Carlsson // Make a constant range that's the intersection of the two icmp ranges. 881d70be0b2c199183077626a9e756ecd14b807dd56Anders Carlsson // If the intersection is empty, we know that the result is false. 88241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper ConstantRange LHSRange = 883d70be0b2c199183077626a9e756ecd14b807dd56Anders Carlsson ConstantRange::makeICmpRegion(LHSCC, LHSCst->getValue()); 88441a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper ConstantRange RHSRange = 885d70be0b2c199183077626a9e756ecd14b807dd56Anders Carlsson ConstantRange::makeICmpRegion(RHSCC, RHSCst->getValue()); 886d70be0b2c199183077626a9e756ecd14b807dd56Anders Carlsson 887d70be0b2c199183077626a9e756ecd14b807dd56Anders Carlsson if (LHSRange.intersectWith(RHSRange).isEmptySet()) 888d70be0b2c199183077626a9e756ecd14b807dd56Anders Carlsson return ConstantInt::get(CmpInst::makeCmpResultType(LHS->getType()), 0); 889d70be0b2c199183077626a9e756ecd14b807dd56Anders Carlsson 89025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // We can't fold (ugt x, C) & (sgt x, C2). 89125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (!PredicatesFoldable(LHSCC, RHSCC)) 892dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 89341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 89425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Ensure that the larger constant is on the RHS. 89525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner bool ShouldSwap; 89625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (CmpInst::isSigned(LHSCC) || 89741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper (ICmpInst::isEquality(LHSCC) && 89825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner CmpInst::isSigned(RHSCC))) 89925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ShouldSwap = LHSCst->getValue().sgt(RHSCst->getValue()); 90025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner else 90125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ShouldSwap = LHSCst->getValue().ugt(RHSCst->getValue()); 90241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 90325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ShouldSwap) { 90425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(LHS, RHS); 90525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(LHSCst, RHSCst); 90625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(LHSCC, RHSCC); 90725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 90825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 909f451cb870efcf9e0302d25ed05f4cac6bb494e42Dan Gohman // At this point, we know we have two icmp instructions 91025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // comparing a value against two constants and and'ing the result 91125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // together. Because of the above check, we know that we only have 91241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper // icmp eq, icmp ne, icmp [su]lt, and icmp [SU]gt here. We also know 91341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper // (from the icmp folding check above), that the two constants 91425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // are not equal and that the larger constant is on the RHS 91525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner assert(LHSCst != RHSCst && "Compares not folded above?"); 91625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 91725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (LHSCC) { 91825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: llvm_unreachable("Unknown integer condition code!"); 91925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_EQ: 92025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (RHSCC) { 92125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: llvm_unreachable("Unknown integer condition code!"); 92225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_NE: // (X == 13 & X != 15) -> X == 13 92325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_ULT: // (X == 13 & X < 15) -> X == 13 92425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SLT: // (X == 13 & X < 15) -> X == 13 925f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return LHS; 92625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 92725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_NE: 92825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (RHSCC) { 92925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: llvm_unreachable("Unknown integer condition code!"); 93025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_ULT: 93125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHSCst == SubOne(RHSCst)) // (X != 13 & X u< 14) -> X < 13 932f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateICmpULT(Val, LHSCst); 93325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; // (X != 13 & X u< 15) -> no change 93425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SLT: 93525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHSCst == SubOne(RHSCst)) // (X != 13 & X s< 14) -> X < 13 936f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateICmpSLT(Val, LHSCst); 93725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; // (X != 13 & X s< 15) -> no change 93825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_EQ: // (X != 13 & X == 15) -> X == 15 93925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_UGT: // (X != 13 & X u> 15) -> X u> 15 94025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SGT: // (X != 13 & X s> 15) -> X s> 15 941f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return RHS; 94225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_NE: 9434658ce9c1f023ca8198add9eabc9ec466d23c8cbJim Grosbach // Special case to get the ordering right when the values wrap around 9444658ce9c1f023ca8198add9eabc9ec466d23c8cbJim Grosbach // zero. 945bff3c587f68530faa1d2be962255254e9adce264Jim Grosbach if (LHSCst->getValue() == 0 && RHSCst->getValue().isAllOnesValue()) 9464658ce9c1f023ca8198add9eabc9ec466d23c8cbJim Grosbach std::swap(LHSCst, RHSCst); 94725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHSCst == SubOne(RHSCst)){// (X != 13 & X != 14) -> X-13 >u 1 94825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Constant *AddCST = ConstantExpr::getNeg(LHSCst); 94925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Add = Builder->CreateAdd(Val, AddCST, Val->getName()+".off"); 9504658ce9c1f023ca8198add9eabc9ec466d23c8cbJim Grosbach return Builder->CreateICmpUGT(Add, ConstantInt::get(Add->getType(), 1), 9514658ce9c1f023ca8198add9eabc9ec466d23c8cbJim Grosbach Val->getName()+".cmp"); 95225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 95325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; // (X != 13 & X != 15) -> no change 95425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 95525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 95625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_ULT: 95725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (RHSCC) { 95825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: llvm_unreachable("Unknown integer condition code!"); 95925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_EQ: // (X u< 13 & X == 15) -> false 96025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_UGT: // (X u< 13 & X u> 15) -> false 961f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return ConstantInt::get(CmpInst::makeCmpResultType(LHS->getType()), 0); 96225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SGT: // (X u< 13 & X s> 15) -> no change 96325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 96425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_NE: // (X u< 13 & X != 15) -> X u< 13 96525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_ULT: // (X u< 13 & X u< 15) -> X u< 13 966f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return LHS; 96725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SLT: // (X u< 13 & X s< 15) -> no change 96825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 96925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 97025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 97125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SLT: 97225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (RHSCC) { 97325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: llvm_unreachable("Unknown integer condition code!"); 97425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_UGT: // (X s< 13 & X u> 15) -> no change 97525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 97625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_NE: // (X s< 13 & X != 15) -> X < 13 97725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SLT: // (X s< 13 & X s< 15) -> X < 13 978f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return LHS; 97925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_ULT: // (X s< 13 & X u< 15) -> no change 98025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 98125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 98225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 98325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_UGT: 98425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (RHSCC) { 98525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: llvm_unreachable("Unknown integer condition code!"); 98625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_EQ: // (X u> 13 & X == 15) -> X == 15 98725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_UGT: // (X u> 13 & X u> 15) -> X u> 15 988f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return RHS; 98925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SGT: // (X u> 13 & X s> 15) -> no change 99025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 99125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_NE: 99225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (RHSCst == AddOne(LHSCst)) // (X u> 13 & X != 14) -> X u> 14 993f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateICmp(LHSCC, Val, RHSCst); 99425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; // (X u> 13 & X != 15) -> no change 99525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_ULT: // (X u> 13 & X u< 15) -> (X-14) <u 1 996f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return InsertRangeTest(Val, AddOne(LHSCst), RHSCst, false, true); 99725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SLT: // (X u> 13 & X s< 15) -> no change 99825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 99925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 100025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 100125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SGT: 100225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (RHSCC) { 100325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: llvm_unreachable("Unknown integer condition code!"); 100425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_EQ: // (X s> 13 & X == 15) -> X == 15 100525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SGT: // (X s> 13 & X s> 15) -> X s> 15 1006f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return RHS; 100725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_UGT: // (X s> 13 & X u> 15) -> no change 100825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 100925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_NE: 101025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (RHSCst == AddOne(LHSCst)) // (X s> 13 & X != 14) -> X s> 14 1011f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateICmp(LHSCC, Val, RHSCst); 101225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; // (X s> 13 & X != 15) -> no change 101325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SLT: // (X s> 13 & X s< 15) -> (X-14) s< 1 1014f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return InsertRangeTest(Val, AddOne(LHSCst), RHSCst, true, true); 101525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_ULT: // (X s> 13 & X u< 15) -> no change 101625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 101725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 101825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 101925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 102041a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 1021dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 102225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 102325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 1024f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner/// FoldAndOfFCmps - Optimize (fcmp)&(fcmp). NOTE: Unlike the rest of 1025f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner/// instcombine, this returns a Value which should already be inserted into the 1026f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner/// function. 1027f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris LattnerValue *InstCombiner::FoldAndOfFCmps(FCmpInst *LHS, FCmpInst *RHS) { 102825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHS->getPredicate() == FCmpInst::FCMP_ORD && 102925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner RHS->getPredicate() == FCmpInst::FCMP_ORD) { 10306ac927860610d134f2a35119abff6eb2d81846a1Benjamin Kramer if (LHS->getOperand(0)->getType() != RHS->getOperand(0)->getType()) 1031dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 10326ac927860610d134f2a35119abff6eb2d81846a1Benjamin Kramer 103325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (fcmp ord x, c) & (fcmp ord y, c) -> (fcmp ord x, y) 103425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ConstantFP *LHSC = dyn_cast<ConstantFP>(LHS->getOperand(1))) 103525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ConstantFP *RHSC = dyn_cast<ConstantFP>(RHS->getOperand(1))) { 103625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If either of the constants are nans, then the whole thing returns 103725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // false. 103825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHSC->getValueAPF().isNaN() || RHSC->getValueAPF().isNaN()) 1039f2d03d74ffe05d08ac7dccbb81f41d996a1f1d2aJakub Staszak return Builder->getFalse(); 1040f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateFCmpORD(LHS->getOperand(0), RHS->getOperand(0)); 104125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 104241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 104325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Handle vector zeros. This occurs because the canonical form of 104425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // "fcmp ord x,x" is "fcmp ord x, 0". 104525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (isa<ConstantAggregateZero>(LHS->getOperand(1)) && 104625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner isa<ConstantAggregateZero>(RHS->getOperand(1))) 1047f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateFCmpORD(LHS->getOperand(0), RHS->getOperand(0)); 1048dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 104925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 105041a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 105125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Op0LHS = LHS->getOperand(0), *Op0RHS = LHS->getOperand(1); 105225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Op1LHS = RHS->getOperand(0), *Op1RHS = RHS->getOperand(1); 105325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner FCmpInst::Predicate Op0CC = LHS->getPredicate(), Op1CC = RHS->getPredicate(); 105441a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 105541a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 105625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0LHS == Op1RHS && Op0RHS == Op1LHS) { 105725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Swap RHS operands to match LHS. 105825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op1CC = FCmpInst::getSwappedPredicate(Op1CC); 105925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(Op1LHS, Op1RHS); 106025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 106141a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 106225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0LHS == Op1LHS && Op0RHS == Op1RHS) { 106325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Simplify (fcmp cc0 x, y) & (fcmp cc1 x, y). 106425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0CC == Op1CC) 1065f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateFCmp((FCmpInst::Predicate)Op0CC, Op0LHS, Op0RHS); 106625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0CC == FCmpInst::FCMP_FALSE || Op1CC == FCmpInst::FCMP_FALSE) 1067f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return ConstantInt::get(CmpInst::makeCmpResultType(LHS->getType()), 0); 106825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0CC == FCmpInst::FCMP_TRUE) 1069f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return RHS; 107025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op1CC == FCmpInst::FCMP_TRUE) 1071f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return LHS; 107241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 107325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner bool Op0Ordered; 107425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner bool Op1Ordered; 107525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner unsigned Op0Pred = getFCmpCode(Op0CC, Op0Ordered); 107625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner unsigned Op1Pred = getFCmpCode(Op1CC, Op1Ordered); 10778b421c8eb2c41ee66cd1023bc7c262bdfaea481dChad Rosier // uno && ord -> false 10788b421c8eb2c41ee66cd1023bc7c262bdfaea481dChad Rosier if (Op0Pred == 0 && Op1Pred == 0 && Op0Ordered != Op1Ordered) 10798b421c8eb2c41ee66cd1023bc7c262bdfaea481dChad Rosier return ConstantInt::get(CmpInst::makeCmpResultType(LHS->getType()), 0); 108025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op1Pred == 0) { 108125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(LHS, RHS); 108225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(Op0Pred, Op1Pred); 108325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(Op0Ordered, Op1Ordered); 108425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 108525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0Pred == 0) { 10867a0575b9a8ca291c33495623eae171394f33b58fManman Ren // uno && ueq -> uno && (uno || eq) -> uno 108725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ord && olt -> ord && (ord && lt) -> olt 10887a0575b9a8ca291c33495623eae171394f33b58fManman Ren if (!Op0Ordered && (Op0Ordered == Op1Ordered)) 10897a0575b9a8ca291c33495623eae171394f33b58fManman Ren return LHS; 10907a0575b9a8ca291c33495623eae171394f33b58fManman Ren if (Op0Ordered && (Op0Ordered == Op1Ordered)) 1091f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return RHS; 109241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 109325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // uno && oeq -> uno && (ord && eq) -> false 109425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (!Op0Ordered) 1095f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return ConstantInt::get(CmpInst::makeCmpResultType(LHS->getType()), 0); 109625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ord && ueq -> ord && (uno || eq) -> oeq 1097f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return getFCmpValue(true, Op1Pred, Op0LHS, Op0RHS, Builder); 109825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 109925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 110025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 1101dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 110225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 110325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 110425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 110525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris LattnerInstruction *InstCombiner::visitAnd(BinaryOperator &I) { 1106096aa79276b8527a3cbbb3691e40e729dea09523Duncan Sands bool Changed = SimplifyAssociativeOrCommutative(I); 110725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1); 110825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 1109dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (Value *V = SimplifyVectorOp(I)) 1110dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return ReplaceInstUsesWith(I, V); 1111dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 111236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (Value *V = SimplifyAndInst(Op0, Op1, DL)) 111325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return ReplaceInstUsesWith(I, V); 111425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 111537bf92b5238434b00fde79347ba5336e7554e562Duncan Sands // (A|B)&(A|C) -> A|(B&C) etc 111637bf92b5238434b00fde79347ba5336e7554e562Duncan Sands if (Value *V = SimplifyUsingDistributiveLaws(I)) 111737bf92b5238434b00fde79347ba5336e7554e562Duncan Sands return ReplaceInstUsesWith(I, V); 11185057f381418ddc8c96699c40479ead993cd62e7bDuncan Sands 111941a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper // See if we can simplify any instructions used by the instruction whose sole 112025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // purpose is to compute bits we don't care about. 112125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (SimplifyDemandedInstructionBits(I)) 112241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper return &I; 112325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 112425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ConstantInt *AndRHS = dyn_cast<ConstantInt>(Op1)) { 112525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner const APInt &AndRHSMask = AndRHS->getValue(); 112625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 112725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Optimize a variety of ((val OP C1) & C2) combinations... 112825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (BinaryOperator *Op0I = dyn_cast<BinaryOperator>(Op0)) { 112925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Op0LHS = Op0I->getOperand(0); 113025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Op0RHS = Op0I->getOperand(1); 113125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (Op0I->getOpcode()) { 113225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: break; 113325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case Instruction::Xor: 113444cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner case Instruction::Or: { 113525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If the mask is only needed on one incoming arm, push it up. 113625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (!Op0I->hasOneUse()) break; 113741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 113844cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner APInt NotAndRHS(~AndRHSMask); 113925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (MaskedValueIsZero(Op0LHS, NotAndRHS)) { 114025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Not masking anything out for the LHS, move to RHS. 114125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NewRHS = Builder->CreateAnd(Op0RHS, AndRHS, 114225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op0RHS->getName()+".masked"); 114325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::Create(Op0I->getOpcode(), Op0LHS, NewRHS); 114425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 114525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (!isa<Constant>(Op0RHS) && 114625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner MaskedValueIsZero(Op0RHS, NotAndRHS)) { 114725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Not masking anything out for the RHS, move to LHS. 114825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NewLHS = Builder->CreateAnd(Op0LHS, AndRHS, 114925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op0LHS->getName()+".masked"); 115025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::Create(Op0I->getOpcode(), NewLHS, Op0RHS); 115125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 115225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 115325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 115444cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner } 115525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case Instruction::Add: 115694c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // ((A & N) + B) & AndRHS -> (A + B) & AndRHS iff N&AndRHS == AndRHS. 115794c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // ((A | N) + B) & AndRHS -> (A + B) & AndRHS iff N&AndRHS == 0 115894c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // ((A ^ N) + B) & AndRHS -> (A + B) & AndRHS iff N&AndRHS == 0 115925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Value *V = FoldLogicalPlusAnd(Op0LHS, Op0RHS, AndRHS, false, I)) 116025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateAnd(V, AndRHS); 116125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Value *V = FoldLogicalPlusAnd(Op0RHS, Op0LHS, AndRHS, false, I)) 116225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateAnd(V, AndRHS); // Add commutes 116325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 116425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 116525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case Instruction::Sub: 116694c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // ((A & N) - B) & AndRHS -> (A - B) & AndRHS iff N&AndRHS == AndRHS. 116794c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // ((A | N) - B) & AndRHS -> (A - B) & AndRHS iff N&AndRHS == 0 116894c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // ((A ^ N) - B) & AndRHS -> (A - B) & AndRHS iff N&AndRHS == 0 116925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Value *V = FoldLogicalPlusAnd(Op0LHS, Op0RHS, AndRHS, true, I)) 117025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateAnd(V, AndRHS); 117125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 117294c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // (A - N) & AndRHS -> -N & AndRHS iff A&AndRHS==0 and AndRHS 117325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // has 1's for all bits that the subtraction with A might affect. 117444cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner if (Op0I->hasOneUse() && !match(Op0LHS, m_Zero())) { 117525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner uint32_t BitWidth = AndRHSMask.getBitWidth(); 117625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner uint32_t Zeros = AndRHSMask.countLeadingZeros(); 117725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner APInt Mask = APInt::getLowBitsSet(BitWidth, BitWidth - Zeros); 117825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 117944cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner if (MaskedValueIsZero(Op0LHS, Mask)) { 118025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NewNeg = Builder->CreateNeg(Op0RHS); 118125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateAnd(NewNeg, AndRHS); 118225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 118325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 118425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 118525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 118625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case Instruction::Shl: 118725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case Instruction::LShr: 118825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (1 << x) & 1 --> zext(x == 0) 118925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (1 >> x) & 1 --> zext(x == 0) 119025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (AndRHSMask == 1 && Op0LHS == AndRHS) { 119125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NewICmp = 119225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Builder->CreateICmpEQ(Op0RHS, Constant::getNullValue(I.getType())); 119325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return new ZExtInst(NewICmp, I.getType()); 119425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 119525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 119625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 119741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 119825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ConstantInt *Op0CI = dyn_cast<ConstantInt>(Op0I->getOperand(1))) 119925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Instruction *Res = OptAndOp(Op0I, Op0CI, AndRHS, I)) 120025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return Res; 120144cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner } 120241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 120344cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner // If this is an integer truncation, and if the source is an 'and' with 120444cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner // immediate, transform it. This frequently occurs for bitfield accesses. 120544cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner { 1206dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Value *X = nullptr; ConstantInt *YC = nullptr; 120744cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner if (match(Op0, m_Trunc(m_And(m_Value(X), m_ConstantInt(YC))))) { 120844cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner // Change: and (trunc (and X, YC) to T), C2 120944cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner // into : and (trunc X to T), trunc(YC) & C2 121041a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper // This will fold the two constants together, which may allow 121144cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner // other simplifications. 121244cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner Value *NewCast = Builder->CreateTrunc(X, I.getType(), "and.shrunk"); 121344cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner Constant *C3 = ConstantExpr::getTrunc(YC, I.getType()); 121444cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner C3 = ConstantExpr::getAnd(C3, AndRHS); 121544cc997d42f896c42a0d37fd8b98d9ec0cb28501Chris Lattner return BinaryOperator::CreateAnd(NewCast, C3); 121625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 121725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 121825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 121925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Try to fold constant and into select arguments. 122025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (SelectInst *SI = dyn_cast<SelectInst>(Op0)) 122125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Instruction *R = FoldOpIntoSelect(I, SI)) 122225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return R; 122325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (isa<PHINode>(Op0)) 122425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Instruction *NV = FoldOpIntoPhi(I)) 122525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return NV; 122625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 122725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 122825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 122925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (~A & ~B) == (~(A | B)) - De Morgan's Law 123025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Value *Op0NotVal = dyn_castNotVal(Op0)) 123125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Value *Op1NotVal = dyn_castNotVal(Op1)) 123225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0->hasOneUse() && Op1->hasOneUse()) { 123325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Or = Builder->CreateOr(Op0NotVal, Op1NotVal, 123425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner I.getName()+".demorgan"); 123525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateNot(Or); 123625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 123741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 123825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner { 1239dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Value *A = nullptr, *B = nullptr, *C = nullptr, *D = nullptr; 124025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (A|B) & ~(A&B) -> A^B 124125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (match(Op0, m_Or(m_Value(A), m_Value(B))) && 124225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(Op1, m_Not(m_And(m_Value(C), m_Value(D)))) && 124325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ((A == C && B == D) || (A == D && B == C))) 124425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateXor(A, B); 124541a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 124625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ~(A&B) & (A|B) -> A^B 124725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (match(Op1, m_Or(m_Value(A), m_Value(B))) && 124825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(Op0, m_Not(m_And(m_Value(C), m_Value(D)))) && 124925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ((A == C && B == D) || (A == D && B == C))) 125025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateXor(A, B); 125141a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 1252c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman // A&(A^B) => A & ~B 1253c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman { 1254c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman Value *tmpOp0 = Op0; 1255c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman Value *tmpOp1 = Op1; 1256c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman if (Op0->hasOneUse() && 1257c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman match(Op0, m_Xor(m_Value(A), m_Value(B)))) { 1258c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman if (A == Op1 || B == Op1 ) { 1259c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman tmpOp1 = Op0; 1260c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman tmpOp0 = Op1; 1261c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman // Simplify below 1262c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman } 126325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 126425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 1265c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman if (tmpOp1->hasOneUse() && 1266c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman match(tmpOp1, m_Xor(m_Value(A), m_Value(B)))) { 1267c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman if (B == tmpOp0) { 1268c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman std::swap(A, B); 1269c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman } 1270c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman // Notice that the patten (A&(~B)) is actually (A&(-1^B)), so if 1271c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman // A is originally -1 (or a vector of -1 and undefs), then we enter 1272c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman // an endless loop. By checking that A is non-constant we ensure that 1273c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman // we will never get to the loop. 1274c6b8ba86738cb6187835e440f2baafaa24dea0b2Eli Friedman if (A == tmpOp0 && !isa<Constant>(A)) // A&(A^B) -> A & ~B 1275a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer return BinaryOperator::CreateAnd(A, Builder->CreateNot(B)); 127625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 127725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 127825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 127925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (A&((~A)|B)) -> A&B 128025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (match(Op0, m_Or(m_Not(m_Specific(Op1)), m_Value(A))) || 128125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(Op0, m_Or(m_Value(A), m_Not(m_Specific(Op1))))) 128225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateAnd(A, Op1); 128325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (match(Op1, m_Or(m_Not(m_Specific(Op0)), m_Value(A))) || 128425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(Op1, m_Or(m_Value(A), m_Not(m_Specific(Op0))))) 128525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateAnd(A, Op0); 128625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 128741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 128825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ICmpInst *RHS = dyn_cast<ICmpInst>(Op1)) 128925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ICmpInst *LHS = dyn_cast<ICmpInst>(Op0)) 1290f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner if (Value *Res = FoldAndOfICmps(LHS, RHS)) 1291f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return ReplaceInstUsesWith(I, Res); 129241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 12938c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner // If and'ing two fcmp, try combine them into one. 12948c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner if (FCmpInst *LHS = dyn_cast<FCmpInst>(I.getOperand(0))) 12958c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner if (FCmpInst *RHS = dyn_cast<FCmpInst>(I.getOperand(1))) 1296f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner if (Value *Res = FoldAndOfFCmps(LHS, RHS)) 1297f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return ReplaceInstUsesWith(I, Res); 129841a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 129941a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 130025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // fold (and (cast A), (cast B)) -> (cast (and A, B)) 130125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (CastInst *Op0C = dyn_cast<CastInst>(Op0)) 13028c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner if (CastInst *Op1C = dyn_cast<CastInst>(Op1)) { 1303db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *SrcTy = Op0C->getOperand(0)->getType(); 13048c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner if (Op0C->getOpcode() == Op1C->getOpcode() && // same cast kind ? 13058c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner SrcTy == Op1C->getOperand(0)->getType() && 1306b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands SrcTy->isIntOrIntVectorTy()) { 13078c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner Value *Op0COp = Op0C->getOperand(0), *Op1COp = Op1C->getOperand(0); 130841a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 13098c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner // Only do this if the casts both really cause code to be generated. 13108c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner if (ShouldOptimizeCast(Op0C->getOpcode(), Op0COp, I.getType()) && 13118c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner ShouldOptimizeCast(Op1C->getOpcode(), Op1COp, I.getType())) { 13128c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner Value *NewOp = Builder->CreateAnd(Op0COp, Op1COp, I.getName()); 131325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return CastInst::Create(Op0C->getOpcode(), NewOp, I.getType()); 131425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 131541a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 13168c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner // If this is and(cast(icmp), cast(icmp)), try to fold this even if the 13178c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner // cast is otherwise not optimizable. This happens for vector sexts. 13188c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner if (ICmpInst *RHS = dyn_cast<ICmpInst>(Op1COp)) 13198c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner if (ICmpInst *LHS = dyn_cast<ICmpInst>(Op0COp)) 1320f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner if (Value *Res = FoldAndOfICmps(LHS, RHS)) 13218c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner return CastInst::Create(Op0C->getOpcode(), Res, I.getType()); 132241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 13238c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner // If this is and(cast(fcmp), cast(fcmp)), try to fold this even if the 13248c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner // cast is otherwise not optimizable. This happens for vector sexts. 13258c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner if (FCmpInst *RHS = dyn_cast<FCmpInst>(Op1COp)) 13268c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner if (FCmpInst *LHS = dyn_cast<FCmpInst>(Op0COp)) 1327f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner if (Value *Res = FoldAndOfFCmps(LHS, RHS)) 13288c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner return CastInst::Create(Op0C->getOpcode(), Res, I.getType()); 132925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 13308c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner } 133141a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 133225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (X >> Z) & (Y >> Z) -> (X&Y) >> Z for all shifts. 133325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (BinaryOperator *SI1 = dyn_cast<BinaryOperator>(Op1)) { 133425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (BinaryOperator *SI0 = dyn_cast<BinaryOperator>(Op0)) 133541a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper if (SI0->isShift() && SI0->getOpcode() == SI1->getOpcode() && 133625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner SI0->getOperand(1) == SI1->getOperand(1) && 133725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner (SI0->hasOneUse() || SI1->hasOneUse())) { 133825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NewOp = 133925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Builder->CreateAnd(SI0->getOperand(0), SI1->getOperand(0), 134025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner SI0->getName()); 134141a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper return BinaryOperator::Create(SI1->getOpcode(), NewOp, 134225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner SI1->getOperand(1)); 134325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 134425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 134525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 1346cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem { 1347dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Value *X = nullptr; 1348cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem bool OpsSwapped = false; 1349cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem // Canonicalize SExt or Not to the LHS 1350cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem if (match(Op1, m_SExt(m_Value())) || 1351cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem match(Op1, m_Not(m_Value()))) { 1352cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem std::swap(Op0, Op1); 1353cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem OpsSwapped = true; 1354cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem } 1355cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem 1356cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem // Fold (and (sext bool to A), B) --> (select bool, B, 0) 1357cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem if (match(Op0, m_SExt(m_Value(X))) && 1358cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem X->getType()->getScalarType()->isIntegerTy(1)) { 1359cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem Value *Zero = Constant::getNullValue(Op1->getType()); 1360cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem return SelectInst::Create(X, Op1, Zero); 1361cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem } 1362cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem 1363cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem // Fold (and ~(sext bool to A), B) --> (select bool, 0, B) 1364cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem if (match(Op0, m_Not(m_SExt(m_Value(X)))) && 1365cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem X->getType()->getScalarType()->isIntegerTy(1)) { 1366cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem Value *Zero = Constant::getNullValue(Op0->getType()); 1367cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem return SelectInst::Create(X, Zero, Op1); 1368cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem } 1369cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem 1370cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem if (OpsSwapped) 1371cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem std::swap(Op0, Op1); 1372cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem } 1373cc687faba373e6aa3cefe594bd9f3212e18617ebNadav Rotem 1374dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return Changed ? &I : nullptr; 137525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 137625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 137725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// CollectBSwapParts - Analyze the specified subexpression and see if it is 137825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// capable of providing pieces of a bswap. The subexpression provides pieces 137925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// of a bswap if it is proven that each of the non-zero bytes in the output of 138025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// the expression came from the corresponding "byte swapped" byte in some other 138125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// value. For example, if the current subexpression is "(shl i32 %X, 24)" then 138225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// we know that the expression deposits the low byte of %X into the high byte 138325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// of the bswap result and that all other bytes are zero. This expression is 138425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// accepted, the high byte of ByteValues is set to X to indicate a correct 138525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// match. 138625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// 138725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// This function returns true if the match was unsuccessful and false if so. 138825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// On entry to the function the "OverallLeftShift" is a signed integer value 138925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// indicating the number of bytes that the subexpression is later shifted. For 139025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// example, if the expression is later right shifted by 16 bits, the 139125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// OverallLeftShift value would be -2 on entry. This is used to specify which 139225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// byte of ByteValues is actually being set. 139325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// 139425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// Similarly, ByteMask is a bitmask where a bit is clear if its corresponding 139525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// byte is masked to zero by a user. For example, in (X & 255), X will be 139625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// processed with a bytemask of 1. Because bytemask is 32-bits, this limits 139725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// this function to working on up to 32-byte (256 bit) values. ByteMask is 139825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// always in the local (OverallLeftShift) coordinate space. 139925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// 140025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattnerstatic bool CollectBSwapParts(Value *V, int OverallLeftShift, uint32_t ByteMask, 1401a0ec3f9b7b826b9b40b80199923b664bad808cceCraig Topper SmallVectorImpl<Value *> &ByteValues) { 140225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Instruction *I = dyn_cast<Instruction>(V)) { 140325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If this is an or instruction, it may be an inner node of the bswap. 140425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (I->getOpcode() == Instruction::Or) { 140525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return CollectBSwapParts(I->getOperand(0), OverallLeftShift, ByteMask, 140625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ByteValues) || 140725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner CollectBSwapParts(I->getOperand(1), OverallLeftShift, ByteMask, 140825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ByteValues); 140925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 141041a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 141125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If this is a logical shift by a constant multiple of 8, recurse with 141225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // OverallLeftShift and ByteMask adjusted. 141325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (I->isLogicalShift() && isa<ConstantInt>(I->getOperand(1))) { 141441a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper unsigned ShAmt = 141525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner cast<ConstantInt>(I->getOperand(1))->getLimitedValue(~0U); 141625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Ensure the shift amount is defined and of a byte value. 141725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if ((ShAmt & 7) || (ShAmt > 8*ByteValues.size())) 141825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return true; 141925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 142025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner unsigned ByteShift = ShAmt >> 3; 142125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (I->getOpcode() == Instruction::Shl) { 142225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // X << 2 -> collect(X, +2) 142325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner OverallLeftShift += ByteShift; 142425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ByteMask >>= ByteShift; 142525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } else { 142625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // X >>u 2 -> collect(X, -2) 142725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner OverallLeftShift -= ByteShift; 142825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ByteMask <<= ByteShift; 142925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ByteMask &= (~0U >> (32-ByteValues.size())); 143025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 143125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 143225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (OverallLeftShift >= (int)ByteValues.size()) return true; 143325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (OverallLeftShift <= -(int)ByteValues.size()) return true; 143425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 143541a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper return CollectBSwapParts(I->getOperand(0), OverallLeftShift, ByteMask, 143625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ByteValues); 143725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 143825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 143925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If this is a logical 'and' with a mask that clears bytes, clear the 144025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // corresponding bytes in ByteMask. 144125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (I->getOpcode() == Instruction::And && 144225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner isa<ConstantInt>(I->getOperand(1))) { 144325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Scan every byte of the and mask, seeing if the byte is either 0 or 255. 144425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner unsigned NumBytes = ByteValues.size(); 144525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner APInt Byte(I->getType()->getPrimitiveSizeInBits(), 255); 144625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner const APInt &AndMask = cast<ConstantInt>(I->getOperand(1))->getValue(); 144741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 144825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner for (unsigned i = 0; i != NumBytes; ++i, Byte <<= 8) { 144925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If this byte is masked out by a later operation, we don't care what 145025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // the and mask is. 145125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if ((ByteMask & (1 << i)) == 0) 145225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner continue; 145341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 145425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If the AndMask is all zeros for this byte, clear the bit. 145525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner APInt MaskB = AndMask & Byte; 145625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (MaskB == 0) { 145725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ByteMask &= ~(1U << i); 145825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner continue; 145925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 146041a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 146125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If the AndMask is not all ones for this byte, it's not a bytezap. 146225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (MaskB != Byte) 146325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return true; 146425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 146525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Otherwise, this byte is kept. 146625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 146725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 146841a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper return CollectBSwapParts(I->getOperand(0), OverallLeftShift, ByteMask, 146925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ByteValues); 147025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 147125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 147241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 147325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Okay, we got to something that isn't a shift, 'or' or 'and'. This must be 147425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // the input value to the bswap. Some observations: 1) if more than one byte 147525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // is demanded from this input, then it could not be successfully assembled 147625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // into a byteswap. At least one of the two bytes would not be aligned with 147725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // their ultimate destination. 147825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (!isPowerOf2_32(ByteMask)) return true; 1479c6af2432c802d241c8fffbe0371c023e6c58844eMichael J. Spencer unsigned InputByteNo = countTrailingZeros(ByteMask); 148041a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 148125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // 2) The input and ultimate destinations must line up: if byte 3 of an i32 148225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // is demanded, it needs to go into byte 0 of the result. This means that the 148325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // byte needs to be shifted until it lands in the right byte bucket. The 148425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // shift amount depends on the position: if the byte is coming from the high 148525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // part of the value (e.g. byte 3) then it must be shifted right. If from the 148625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // low part, it must be shifted left. 148725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner unsigned DestByteNo = InputByteNo + OverallLeftShift; 1488de813b7108de64829ab006e6b998a7b38d119eccChris Lattner if (ByteValues.size()-1-DestByteNo != InputByteNo) 1489de813b7108de64829ab006e6b998a7b38d119eccChris Lattner return true; 149041a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 149125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If the destination byte value is already defined, the values are or'd 149225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // together, which isn't a bswap (unless it's an or of the same bits). 149325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ByteValues[DestByteNo] && ByteValues[DestByteNo] != V) 149425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return true; 149525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ByteValues[DestByteNo] = V; 149625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return false; 149725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 149825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 149925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// MatchBSwap - Given an OR instruction, check to see if this is a bswap idiom. 150025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// If so, insert the new bswap intrinsic and return it. 150125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris LattnerInstruction *InstCombiner::MatchBSwap(BinaryOperator &I) { 15025fdd6c8793462549e3593890ec61573da06e3346Jay Foad IntegerType *ITy = dyn_cast<IntegerType>(I.getType()); 150341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper if (!ITy || ITy->getBitWidth() % 16 || 150425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ByteMask only allows up to 32-byte values. 150541a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper ITy->getBitWidth() > 32*8) 1506dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; // Can only bswap pairs of bytes. Can't do vectors. 150741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 150825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner /// ByteValues - For each byte of the result, we keep track of which value 150925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner /// defines each byte. 151025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner SmallVector<Value*, 8> ByteValues; 151125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ByteValues.resize(ITy->getBitWidth()/8); 151241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 151325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Try to find all the pieces corresponding to the bswap. 151425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner uint32_t ByteMask = ~0U >> (32-ByteValues.size()); 151525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (CollectBSwapParts(&I, 0, ByteMask, ByteValues)) 1516dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 151741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 151825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Check to see if all of the bytes come from the same value. 151925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *V = ByteValues[0]; 1520dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!V) return nullptr; // Didn't find a byte? Must be zero. 152141a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 152225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Check to make sure that all of the bytes come from the same value. 152325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner for (unsigned i = 1, e = ByteValues.size(); i != e; ++i) 152425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ByteValues[i] != V) 1525dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 152625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Module *M = I.getParent()->getParent()->getParent(); 1527eb9a85f09e18b3fe88499710404b38d3a9128f62Benjamin Kramer Function *F = Intrinsic::getDeclaration(M, Intrinsic::bswap, ITy); 152825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return CallInst::Create(F, V); 152925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 153025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 153125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// MatchSelectFromAndOr - We have an expression of the form (A&C)|(B&D). Check 153225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// If A is (cond?-1:0) and either B or D is ~(cond?-1,0) or (cond?0,-1), then 153325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// we can simplify this expression to "cond ? C : D or B". 153425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattnerstatic Instruction *MatchSelectFromAndOr(Value *A, Value *B, 153525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *C, Value *D) { 153625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If A is not a select of -1/0, this cannot match. 1537dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Value *Cond = nullptr; 1538e538db4fb0ec30500da721a2a698946fa36db1a8Chris Lattner if (!match(A, m_SExt(m_Value(Cond))) || 1539b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands !Cond->getType()->isIntegerTy(1)) 1540dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 154125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 154225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ((cond?-1:0)&C) | (B&(cond?0:-1)) -> cond ? C : B. 1543e576f292ee5f7af40489a68fa626d53a14e46a10Chris Lattner if (match(D, m_Not(m_SExt(m_Specific(Cond))))) 154425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return SelectInst::Create(Cond, C, B); 1545e576f292ee5f7af40489a68fa626d53a14e46a10Chris Lattner if (match(D, m_SExt(m_Not(m_Specific(Cond))))) 154674529826a70546d71c6558e9a3917244a87acfe9Chris Lattner return SelectInst::Create(Cond, C, B); 154741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 154825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ((cond?-1:0)&C) | ((cond?0:-1)&D) -> cond ? C : D. 1549e576f292ee5f7af40489a68fa626d53a14e46a10Chris Lattner if (match(B, m_Not(m_SExt(m_Specific(Cond))))) 155074529826a70546d71c6558e9a3917244a87acfe9Chris Lattner return SelectInst::Create(Cond, C, D); 1551e576f292ee5f7af40489a68fa626d53a14e46a10Chris Lattner if (match(B, m_SExt(m_Not(m_Specific(Cond))))) 155225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return SelectInst::Create(Cond, C, D); 1553dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 155425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 155525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 1556f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner/// FoldOrOfICmps - Fold (icmp)|(icmp) if possible. 1557f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris LattnerValue *InstCombiner::FoldOrOfICmps(ICmpInst *LHS, ICmpInst *RHS) { 155825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ICmpInst::Predicate LHSCC = LHS->getPredicate(), RHSCC = RHS->getPredicate(); 155925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 15606c84f7ad2dbba5d1afa26a4929c3b032ae9e7e10Nadav Rotem // Fold (iszero(A & K1) | iszero(A & K2)) -> (A & (K1 | K2)) != (K1 | K2) 15616c84f7ad2dbba5d1afa26a4929c3b032ae9e7e10Nadav Rotem // if K1 and K2 are a one-bit mask. 15626c84f7ad2dbba5d1afa26a4929c3b032ae9e7e10Nadav Rotem ConstantInt *LHSCst = dyn_cast<ConstantInt>(LHS->getOperand(1)); 15636c84f7ad2dbba5d1afa26a4929c3b032ae9e7e10Nadav Rotem ConstantInt *RHSCst = dyn_cast<ConstantInt>(RHS->getOperand(1)); 15646c84f7ad2dbba5d1afa26a4929c3b032ae9e7e10Nadav Rotem 15656c84f7ad2dbba5d1afa26a4929c3b032ae9e7e10Nadav Rotem if (LHS->getPredicate() == ICmpInst::ICMP_EQ && LHSCst && LHSCst->isZero() && 15666c84f7ad2dbba5d1afa26a4929c3b032ae9e7e10Nadav Rotem RHS->getPredicate() == ICmpInst::ICMP_EQ && RHSCst && RHSCst->isZero()) { 15676c84f7ad2dbba5d1afa26a4929c3b032ae9e7e10Nadav Rotem 15686c84f7ad2dbba5d1afa26a4929c3b032ae9e7e10Nadav Rotem BinaryOperator *LAnd = dyn_cast<BinaryOperator>(LHS->getOperand(0)); 15696c84f7ad2dbba5d1afa26a4929c3b032ae9e7e10Nadav Rotem BinaryOperator *RAnd = dyn_cast<BinaryOperator>(RHS->getOperand(0)); 15706c84f7ad2dbba5d1afa26a4929c3b032ae9e7e10Nadav Rotem if (LAnd && RAnd && LAnd->hasOneUse() && RHS->hasOneUse() && 15716c84f7ad2dbba5d1afa26a4929c3b032ae9e7e10Nadav Rotem LAnd->getOpcode() == Instruction::And && 15726c84f7ad2dbba5d1afa26a4929c3b032ae9e7e10Nadav Rotem RAnd->getOpcode() == Instruction::And) { 15736c84f7ad2dbba5d1afa26a4929c3b032ae9e7e10Nadav Rotem 1574dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Value *Mask = nullptr; 1575dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Value *Masked = nullptr; 15766c84f7ad2dbba5d1afa26a4929c3b032ae9e7e10Nadav Rotem if (LAnd->getOperand(0) == RAnd->getOperand(0) && 157736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines isKnownToBeAPowerOfTwo(LAnd->getOperand(1)) && 157836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines isKnownToBeAPowerOfTwo(RAnd->getOperand(1))) { 15796c84f7ad2dbba5d1afa26a4929c3b032ae9e7e10Nadav Rotem Mask = Builder->CreateOr(LAnd->getOperand(1), RAnd->getOperand(1)); 15806c84f7ad2dbba5d1afa26a4929c3b032ae9e7e10Nadav Rotem Masked = Builder->CreateAnd(LAnd->getOperand(0), Mask); 15816c84f7ad2dbba5d1afa26a4929c3b032ae9e7e10Nadav Rotem } else if (LAnd->getOperand(1) == RAnd->getOperand(1) && 158236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines isKnownToBeAPowerOfTwo(LAnd->getOperand(0)) && 158336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines isKnownToBeAPowerOfTwo(RAnd->getOperand(0))) { 15846c84f7ad2dbba5d1afa26a4929c3b032ae9e7e10Nadav Rotem Mask = Builder->CreateOr(LAnd->getOperand(0), RAnd->getOperand(0)); 15856c84f7ad2dbba5d1afa26a4929c3b032ae9e7e10Nadav Rotem Masked = Builder->CreateAnd(LAnd->getOperand(1), Mask); 15866c84f7ad2dbba5d1afa26a4929c3b032ae9e7e10Nadav Rotem } 15876c84f7ad2dbba5d1afa26a4929c3b032ae9e7e10Nadav Rotem 15886c84f7ad2dbba5d1afa26a4929c3b032ae9e7e10Nadav Rotem if (Masked) 15896c84f7ad2dbba5d1afa26a4929c3b032ae9e7e10Nadav Rotem return Builder->CreateICmp(ICmpInst::ICMP_NE, Masked, Mask); 15906c84f7ad2dbba5d1afa26a4929c3b032ae9e7e10Nadav Rotem } 15916c84f7ad2dbba5d1afa26a4929c3b032ae9e7e10Nadav Rotem } 15926c84f7ad2dbba5d1afa26a4929c3b032ae9e7e10Nadav Rotem 159325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (icmp1 A, B) | (icmp2 A, B) --> (icmp3 A, B) 159425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (PredicatesFoldable(LHSCC, RHSCC)) { 159525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHS->getOperand(0) == RHS->getOperand(1) && 159625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner LHS->getOperand(1) == RHS->getOperand(0)) 159725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner LHS->swapOperands(); 159825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHS->getOperand(0) == RHS->getOperand(0) && 159925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner LHS->getOperand(1) == RHS->getOperand(1)) { 160025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Op0 = LHS->getOperand(0), *Op1 = LHS->getOperand(1); 160125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner unsigned Code = getICmpCode(LHS) | getICmpCode(RHS); 160225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner bool isSigned = LHS->isSigned() || RHS->isSigned(); 16032e33944c101f2a08ed1d85e807830f2fc089dd06Pete Cooper return getNewICmpValue(isSigned, Code, Op0, Op1, Builder); 160425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 160525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 16064dc1ac094714a5866b9d32c6bbf2ecaa672fde48Benjamin Kramer 16074dc1ac094714a5866b9d32c6bbf2ecaa672fde48Benjamin Kramer // handle (roughly): 16084dc1ac094714a5866b9d32c6bbf2ecaa672fde48Benjamin Kramer // (icmp ne (A & B), C) | (icmp ne (A & D), E) 16097bfabdac4ebf82f9f6a9ee7a00fd948f729dc7feTim Northover if (Value *V = foldLogOpOfMaskedICmps(LHS, RHS, false, Builder)) 16104dc1ac094714a5866b9d32c6bbf2ecaa672fde48Benjamin Kramer return V; 16115c3c23afe77a2ce784b613af12cf9278c38fdcbfOwen Anderson 161225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Val = LHS->getOperand(0), *Val2 = RHS->getOperand(0); 1613b1b738e03613e98f0ae367af1b5423221c5bd29dDavid Majnemer if (LHS->hasOneUse() || RHS->hasOneUse()) { 1614b1b738e03613e98f0ae367af1b5423221c5bd29dDavid Majnemer // (icmp eq B, 0) | (icmp ult A, B) -> (icmp ule A, B-1) 1615b1b738e03613e98f0ae367af1b5423221c5bd29dDavid Majnemer // (icmp eq B, 0) | (icmp ugt B, A) -> (icmp ule A, B-1) 1616dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Value *A = nullptr, *B = nullptr; 1617b1b738e03613e98f0ae367af1b5423221c5bd29dDavid Majnemer if (LHSCC == ICmpInst::ICMP_EQ && LHSCst && LHSCst->isZero()) { 1618b1b738e03613e98f0ae367af1b5423221c5bd29dDavid Majnemer B = Val; 1619b1b738e03613e98f0ae367af1b5423221c5bd29dDavid Majnemer if (RHSCC == ICmpInst::ICMP_ULT && Val == RHS->getOperand(1)) 1620b1b738e03613e98f0ae367af1b5423221c5bd29dDavid Majnemer A = Val2; 1621b1b738e03613e98f0ae367af1b5423221c5bd29dDavid Majnemer else if (RHSCC == ICmpInst::ICMP_UGT && Val == Val2) 1622b1b738e03613e98f0ae367af1b5423221c5bd29dDavid Majnemer A = RHS->getOperand(1); 1623b1b738e03613e98f0ae367af1b5423221c5bd29dDavid Majnemer } 1624b1b738e03613e98f0ae367af1b5423221c5bd29dDavid Majnemer // (icmp ult A, B) | (icmp eq B, 0) -> (icmp ule A, B-1) 1625b1b738e03613e98f0ae367af1b5423221c5bd29dDavid Majnemer // (icmp ugt B, A) | (icmp eq B, 0) -> (icmp ule A, B-1) 1626b1b738e03613e98f0ae367af1b5423221c5bd29dDavid Majnemer else if (RHSCC == ICmpInst::ICMP_EQ && RHSCst && RHSCst->isZero()) { 1627b1b738e03613e98f0ae367af1b5423221c5bd29dDavid Majnemer B = Val2; 1628b1b738e03613e98f0ae367af1b5423221c5bd29dDavid Majnemer if (LHSCC == ICmpInst::ICMP_ULT && Val2 == LHS->getOperand(1)) 1629b1b738e03613e98f0ae367af1b5423221c5bd29dDavid Majnemer A = Val; 1630b1b738e03613e98f0ae367af1b5423221c5bd29dDavid Majnemer else if (LHSCC == ICmpInst::ICMP_UGT && Val2 == Val) 1631b1b738e03613e98f0ae367af1b5423221c5bd29dDavid Majnemer A = LHS->getOperand(1); 1632b1b738e03613e98f0ae367af1b5423221c5bd29dDavid Majnemer } 1633b1b738e03613e98f0ae367af1b5423221c5bd29dDavid Majnemer if (A && B) 1634b1b738e03613e98f0ae367af1b5423221c5bd29dDavid Majnemer return Builder->CreateICmp( 1635b1b738e03613e98f0ae367af1b5423221c5bd29dDavid Majnemer ICmpInst::ICMP_UGE, 1636b1b738e03613e98f0ae367af1b5423221c5bd29dDavid Majnemer Builder->CreateAdd(B, ConstantInt::getSigned(B->getType(), -1)), A); 1637b1b738e03613e98f0ae367af1b5423221c5bd29dDavid Majnemer } 1638b1b738e03613e98f0ae367af1b5423221c5bd29dDavid Majnemer 1639b1b738e03613e98f0ae367af1b5423221c5bd29dDavid Majnemer // This only handles icmp of constants: (icmp1 A, C1) | (icmp2 B, C2). 1640dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!LHSCst || !RHSCst) return nullptr; 164125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 164261378363b76ad84dc7effff506d7c3e991225743Owen Anderson if (LHSCst == RHSCst && LHSCC == RHSCC) { 164361378363b76ad84dc7effff506d7c3e991225743Owen Anderson // (icmp ne A, 0) | (icmp ne B, 0) --> (icmp ne (A|B), 0) 164461378363b76ad84dc7effff506d7c3e991225743Owen Anderson if (LHSCC == ICmpInst::ICMP_NE && LHSCst->isZero()) { 164561378363b76ad84dc7effff506d7c3e991225743Owen Anderson Value *NewOr = Builder->CreateOr(Val, Val2); 164661378363b76ad84dc7effff506d7c3e991225743Owen Anderson return Builder->CreateICmp(LHSCC, NewOr, LHSCst); 164761378363b76ad84dc7effff506d7c3e991225743Owen Anderson } 1648dfb806f6ba53b792171b928b57def9d0182d2f5fBenjamin Kramer } 1649dfb806f6ba53b792171b928b57def9d0182d2f5fBenjamin Kramer 1650b0de244f23c2e11505cab729f198dfaaa2028532Benjamin Kramer // (icmp ult (X + CA), C1) | (icmp eq X, C2) -> (icmp ule (X + CA), C1) 165194c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // iff C2 + CA == C1. 1652b0de244f23c2e11505cab729f198dfaaa2028532Benjamin Kramer if (LHSCC == ICmpInst::ICMP_ULT && RHSCC == ICmpInst::ICMP_EQ) { 16535337f20c1516296edcea6bc3da6cdc74329142aeBenjamin Kramer ConstantInt *AddCst; 16545337f20c1516296edcea6bc3da6cdc74329142aeBenjamin Kramer if (match(Val, m_Add(m_Specific(Val2), m_ConstantInt(AddCst)))) 16555337f20c1516296edcea6bc3da6cdc74329142aeBenjamin Kramer if (RHSCst->getValue() + AddCst->getValue() == LHSCst->getValue()) 1656b0de244f23c2e11505cab729f198dfaaa2028532Benjamin Kramer return Builder->CreateICmpULE(Val, LHSCst); 16575337f20c1516296edcea6bc3da6cdc74329142aeBenjamin Kramer } 16585337f20c1516296edcea6bc3da6cdc74329142aeBenjamin Kramer 165925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // From here on, we only handle: 166025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (icmp1 A, C1) | (icmp2 A, C2) --> something simpler. 1661dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (Val != Val2) return nullptr; 166241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 166325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ICMP_[US][GL]E X, CST is folded to ICMP_[US][GL]T elsewhere. 166425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHSCC == ICmpInst::ICMP_UGE || LHSCC == ICmpInst::ICMP_ULE || 166525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner RHSCC == ICmpInst::ICMP_UGE || RHSCC == ICmpInst::ICMP_ULE || 166625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner LHSCC == ICmpInst::ICMP_SGE || LHSCC == ICmpInst::ICMP_SLE || 166725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner RHSCC == ICmpInst::ICMP_SGE || RHSCC == ICmpInst::ICMP_SLE) 1668dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 166941a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 167025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // We can't fold (ugt x, C) | (sgt x, C2). 167125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (!PredicatesFoldable(LHSCC, RHSCC)) 1672dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 167341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 167425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Ensure that the larger constant is on the RHS. 167525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner bool ShouldSwap; 167625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (CmpInst::isSigned(LHSCC) || 167741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper (ICmpInst::isEquality(LHSCC) && 167825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner CmpInst::isSigned(RHSCC))) 167925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ShouldSwap = LHSCst->getValue().sgt(RHSCst->getValue()); 168025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner else 168125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ShouldSwap = LHSCst->getValue().ugt(RHSCst->getValue()); 168241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 168325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ShouldSwap) { 168425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(LHS, RHS); 168525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(LHSCst, RHSCst); 168625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(LHSCC, RHSCC); 168725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 168841a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 1689f451cb870efcf9e0302d25ed05f4cac6bb494e42Dan Gohman // At this point, we know we have two icmp instructions 169025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // comparing a value against two constants and or'ing the result 169125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // together. Because of the above check, we know that we only have 169225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ICMP_EQ, ICMP_NE, ICMP_LT, and ICMP_GT here. We also know (from the 169325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // icmp folding check above), that the two constants are not 169425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // equal. 169525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner assert(LHSCst != RHSCst && "Compares not folded above?"); 169625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 169725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (LHSCC) { 169825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: llvm_unreachable("Unknown integer condition code!"); 169925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_EQ: 170025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (RHSCC) { 170125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: llvm_unreachable("Unknown integer condition code!"); 170225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_EQ: 1703d60b8ac64fa161646d50c49d6171cb49e6a2c7eeJakub Staszak if (LHS->getOperand(0) == RHS->getOperand(0)) { 1704b6d9c4181a57a4b57d92a4437761387606f49c2dJakub Staszak // if LHSCst and RHSCst differ only by one bit: 1705d60b8ac64fa161646d50c49d6171cb49e6a2c7eeJakub Staszak // (A == C1 || A == C2) -> (A & ~(C1 ^ C2)) == C1 1706526057921dcb57e0d51d60ddb0f5ce16596c307fJakub Staszak assert(LHSCst->getValue().ule(LHSCst->getValue())); 1707526057921dcb57e0d51d60ddb0f5ce16596c307fJakub Staszak 1708d60b8ac64fa161646d50c49d6171cb49e6a2c7eeJakub Staszak APInt Xor = LHSCst->getValue() ^ RHSCst->getValue(); 1709d60b8ac64fa161646d50c49d6171cb49e6a2c7eeJakub Staszak if (Xor.isPowerOf2()) { 1710d60b8ac64fa161646d50c49d6171cb49e6a2c7eeJakub Staszak Value *NegCst = Builder->getInt(~Xor); 1711d60b8ac64fa161646d50c49d6171cb49e6a2c7eeJakub Staszak Value *And = Builder->CreateAnd(LHS->getOperand(0), NegCst); 1712d60b8ac64fa161646d50c49d6171cb49e6a2c7eeJakub Staszak return Builder->CreateICmp(ICmpInst::ICMP_EQ, And, LHSCst); 1713d60b8ac64fa161646d50c49d6171cb49e6a2c7eeJakub Staszak } 1714d60b8ac64fa161646d50c49d6171cb49e6a2c7eeJakub Staszak } 1715d60b8ac64fa161646d50c49d6171cb49e6a2c7eeJakub Staszak 1716024d943bca85ee0b6bc1b9e5f13ec5276f16c13dDavid Majnemer if (LHSCst == SubOne(RHSCst)) { 1717024d943bca85ee0b6bc1b9e5f13ec5276f16c13dDavid Majnemer // (X == 13 | X == 14) -> X-13 <u 2 1718024d943bca85ee0b6bc1b9e5f13ec5276f16c13dDavid Majnemer Constant *AddCST = ConstantExpr::getNeg(LHSCst); 1719024d943bca85ee0b6bc1b9e5f13ec5276f16c13dDavid Majnemer Value *Add = Builder->CreateAdd(Val, AddCST, Val->getName()+".off"); 1720024d943bca85ee0b6bc1b9e5f13ec5276f16c13dDavid Majnemer AddCST = ConstantExpr::getSub(AddOne(RHSCst), LHSCst); 1721024d943bca85ee0b6bc1b9e5f13ec5276f16c13dDavid Majnemer return Builder->CreateICmpULT(Add, AddCST); 1722024d943bca85ee0b6bc1b9e5f13ec5276f16c13dDavid Majnemer } 1723024d943bca85ee0b6bc1b9e5f13ec5276f16c13dDavid Majnemer 172425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; // (X == 13 | X == 15) -> no change 172525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_UGT: // (X == 13 | X u> 14) -> no change 172625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SGT: // (X == 13 | X s> 14) -> no change 172725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 172825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_NE: // (X == 13 | X != 15) -> X != 15 172925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_ULT: // (X == 13 | X u< 15) -> X u< 15 173025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SLT: // (X == 13 | X s< 15) -> X s< 15 1731f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return RHS; 173225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 173325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 173425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_NE: 173525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (RHSCC) { 173625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: llvm_unreachable("Unknown integer condition code!"); 173725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_EQ: // (X != 13 | X == 15) -> X != 13 173825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_UGT: // (X != 13 | X u> 15) -> X != 13 173925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SGT: // (X != 13 | X s> 15) -> X != 13 1740f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return LHS; 174125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_NE: // (X != 13 | X != 15) -> true 174225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_ULT: // (X != 13 | X u< 15) -> true 174325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SLT: // (X != 13 | X s< 15) -> true 1744f2d03d74ffe05d08ac7dccbb81f41d996a1f1d2aJakub Staszak return Builder->getTrue(); 174525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 174625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_ULT: 174725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (RHSCC) { 174825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: llvm_unreachable("Unknown integer condition code!"); 174925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_EQ: // (X u< 13 | X == 14) -> no change 175025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 175125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_UGT: // (X u< 13 | X u> 15) -> (X-13) u> 2 175225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If RHSCst is [us]MAXINT, it is always false. Not handling 175325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // this can cause overflow. 175425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (RHSCst->isMaxValue(false)) 1755f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return LHS; 1756f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return InsertRangeTest(Val, LHSCst, AddOne(RHSCst), false, false); 175725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SGT: // (X u< 13 | X s> 15) -> no change 175825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 175925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_NE: // (X u< 13 | X != 15) -> X != 15 176025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_ULT: // (X u< 13 | X u< 15) -> X u< 15 1761f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return RHS; 176225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SLT: // (X u< 13 | X s< 15) -> no change 176325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 176425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 176525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 176625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SLT: 176725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (RHSCC) { 176825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: llvm_unreachable("Unknown integer condition code!"); 176925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_EQ: // (X s< 13 | X == 14) -> no change 177025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 177125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SGT: // (X s< 13 | X s> 15) -> (X-13) s> 2 177225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If RHSCst is [us]MAXINT, it is always false. Not handling 177325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // this can cause overflow. 177425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (RHSCst->isMaxValue(true)) 1775f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return LHS; 1776f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return InsertRangeTest(Val, LHSCst, AddOne(RHSCst), true, false); 177725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_UGT: // (X s< 13 | X u> 15) -> no change 177825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 177925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_NE: // (X s< 13 | X != 15) -> X != 15 178025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SLT: // (X s< 13 | X s< 15) -> X s< 15 1781f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return RHS; 178225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_ULT: // (X s< 13 | X u< 15) -> no change 178325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 178425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 178525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 178625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_UGT: 178725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (RHSCC) { 178825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: llvm_unreachable("Unknown integer condition code!"); 178925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_EQ: // (X u> 13 | X == 15) -> X u> 13 179025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_UGT: // (X u> 13 | X u> 15) -> X u> 13 1791f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return LHS; 179225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SGT: // (X u> 13 | X s> 15) -> no change 179325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 179425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_NE: // (X u> 13 | X != 15) -> true 179525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_ULT: // (X u> 13 | X u< 15) -> true 1796f2d03d74ffe05d08ac7dccbb81f41d996a1f1d2aJakub Staszak return Builder->getTrue(); 179725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SLT: // (X u> 13 | X s< 15) -> no change 179825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 179925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 180025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 180125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SGT: 180225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner switch (RHSCC) { 180325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner default: llvm_unreachable("Unknown integer condition code!"); 180425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_EQ: // (X s> 13 | X == 15) -> X > 13 180525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SGT: // (X s> 13 | X s> 15) -> X > 13 1806f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return LHS; 180725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_UGT: // (X s> 13 | X u> 15) -> no change 180825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 180925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_NE: // (X s> 13 | X != 15) -> true 181025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_SLT: // (X s> 13 | X s< 15) -> true 1811f2d03d74ffe05d08ac7dccbb81f41d996a1f1d2aJakub Staszak return Builder->getTrue(); 181225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner case ICmpInst::ICMP_ULT: // (X s> 13 | X u< 15) -> no change 181325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 181425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 181525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner break; 181625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 1817dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 181825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 181925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 1820f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner/// FoldOrOfFCmps - Optimize (fcmp)|(fcmp). NOTE: Unlike the rest of 1821f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner/// instcombine, this returns a Value which should already be inserted into the 1822f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner/// function. 1823f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris LattnerValue *InstCombiner::FoldOrOfFCmps(FCmpInst *LHS, FCmpInst *RHS) { 182425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHS->getPredicate() == FCmpInst::FCMP_UNO && 182541a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper RHS->getPredicate() == FCmpInst::FCMP_UNO && 182625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner LHS->getOperand(0)->getType() == RHS->getOperand(0)->getType()) { 182725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ConstantFP *LHSC = dyn_cast<ConstantFP>(LHS->getOperand(1))) 182825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ConstantFP *RHSC = dyn_cast<ConstantFP>(RHS->getOperand(1))) { 182925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If either of the constants are nans, then the whole thing returns 183025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // true. 183125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHSC->getValueAPF().isNaN() || RHSC->getValueAPF().isNaN()) 1832f2d03d74ffe05d08ac7dccbb81f41d996a1f1d2aJakub Staszak return Builder->getTrue(); 183341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 183425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Otherwise, no need to compare the two constants, compare the 183525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // rest. 1836f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateFCmpUNO(LHS->getOperand(0), RHS->getOperand(0)); 183725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 183841a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 183925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Handle vector zeros. This occurs because the canonical form of 184025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // "fcmp uno x,x" is "fcmp uno x, 0". 184125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (isa<ConstantAggregateZero>(LHS->getOperand(1)) && 184225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner isa<ConstantAggregateZero>(RHS->getOperand(1))) 1843f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateFCmpUNO(LHS->getOperand(0), RHS->getOperand(0)); 184441a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 1845dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 184625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 184741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 184825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Op0LHS = LHS->getOperand(0), *Op0RHS = LHS->getOperand(1); 184925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Op1LHS = RHS->getOperand(0), *Op1RHS = RHS->getOperand(1); 185025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner FCmpInst::Predicate Op0CC = LHS->getPredicate(), Op1CC = RHS->getPredicate(); 185141a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 185225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0LHS == Op1RHS && Op0RHS == Op1LHS) { 185325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Swap RHS operands to match LHS. 185425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op1CC = FCmpInst::getSwappedPredicate(Op1CC); 185525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(Op1LHS, Op1RHS); 185625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 185725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0LHS == Op1LHS && Op0RHS == Op1RHS) { 185825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Simplify (fcmp cc0 x, y) | (fcmp cc1 x, y). 185925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0CC == Op1CC) 1860f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return Builder->CreateFCmp((FCmpInst::Predicate)Op0CC, Op0LHS, Op0RHS); 186125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0CC == FCmpInst::FCMP_TRUE || Op1CC == FCmpInst::FCMP_TRUE) 1862f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return ConstantInt::get(CmpInst::makeCmpResultType(LHS->getType()), 1); 186325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0CC == FCmpInst::FCMP_FALSE) 1864f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return RHS; 186525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op1CC == FCmpInst::FCMP_FALSE) 1866f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return LHS; 186725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner bool Op0Ordered; 186825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner bool Op1Ordered; 186925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner unsigned Op0Pred = getFCmpCode(Op0CC, Op0Ordered); 187025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner unsigned Op1Pred = getFCmpCode(Op1CC, Op1Ordered); 187125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0Ordered == Op1Ordered) { 187225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // If both are ordered or unordered, return a new fcmp with 187325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // or'ed predicates. 1874f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return getFCmpValue(Op0Ordered, Op0Pred|Op1Pred, Op0LHS, Op0RHS, Builder); 187525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 187625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 1877dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 187825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 187925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 188025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// FoldOrWithConstants - This helper function folds: 188125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// 188225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// ((A | B) & C1) | (B & C2) 188325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// 188425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// into: 188541a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper/// 188625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// (A & C1) | B 188725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// 188825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner/// when the XOR of the two constants is "all ones" (-1). 188925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris LattnerInstruction *InstCombiner::FoldOrWithConstants(BinaryOperator &I, Value *Op, 189025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *A, Value *B, Value *C) { 189125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt *CI1 = dyn_cast<ConstantInt>(C); 1892dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!CI1) return nullptr; 189325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 1894dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Value *V1 = nullptr; 1895dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines ConstantInt *CI2 = nullptr; 1896dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!match(Op, m_And(m_Value(V1), m_ConstantInt(CI2)))) return nullptr; 189725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 189825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner APInt Xor = CI1->getValue() ^ CI2->getValue(); 1899dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!Xor.isAllOnesValue()) return nullptr; 190025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 190125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (V1 == A || V1 == B) { 190225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NewOp = Builder->CreateAnd((V1 == A) ? B : A, CI1); 190325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateOr(NewOp, V1); 190425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 190525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 1906dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 190725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 190825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 190925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris LattnerInstruction *InstCombiner::visitOr(BinaryOperator &I) { 1910096aa79276b8527a3cbbb3691e40e729dea09523Duncan Sands bool Changed = SimplifyAssociativeOrCommutative(I); 191125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1); 191225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 1913dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (Value *V = SimplifyVectorOp(I)) 1914dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return ReplaceInstUsesWith(I, V); 1915dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 191636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (Value *V = SimplifyOrInst(Op0, Op1, DL)) 191725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return ReplaceInstUsesWith(I, V); 19187d9f2b93a356aa89186522bd61c5c565718ff555Bill Wendling 191937bf92b5238434b00fde79347ba5336e7554e562Duncan Sands // (A&B)|(A&C) -> A&(B|C) etc 192037bf92b5238434b00fde79347ba5336e7554e562Duncan Sands if (Value *V = SimplifyUsingDistributiveLaws(I)) 192137bf92b5238434b00fde79347ba5336e7554e562Duncan Sands return ReplaceInstUsesWith(I, V); 19225057f381418ddc8c96699c40479ead993cd62e7bDuncan Sands 192341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper // See if we can simplify any instructions used by the instruction whose sole 192425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // purpose is to compute bits we don't care about. 192525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (SimplifyDemandedInstructionBits(I)) 192625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return &I; 192725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 192825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ConstantInt *RHS = dyn_cast<ConstantInt>(Op1)) { 1929dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines ConstantInt *C1 = nullptr; Value *X = nullptr; 193025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (X & C1) | C2 --> (X | C2) & (C1|C2) 193194c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // iff (C1 & C2) == 0. 193225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (match(Op0, m_And(m_Value(X), m_ConstantInt(C1))) && 19337d9f2b93a356aa89186522bd61c5c565718ff555Bill Wendling (RHS->getValue() & C1->getValue()) != 0 && 193425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op0->hasOneUse()) { 193525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Or = Builder->CreateOr(X, RHS); 193625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Or->takeName(Op0); 193741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper return BinaryOperator::CreateAnd(Or, 1938f2d03d74ffe05d08ac7dccbb81f41d996a1f1d2aJakub Staszak Builder->getInt(RHS->getValue() | C1->getValue())); 193925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 194025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 194125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (X ^ C1) | C2 --> (X | C2) ^ (C1&~C2) 194225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (match(Op0, m_Xor(m_Value(X), m_ConstantInt(C1))) && 194325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op0->hasOneUse()) { 194425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Or = Builder->CreateOr(X, RHS); 194525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Or->takeName(Op0); 194625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateXor(Or, 1947f2d03d74ffe05d08ac7dccbb81f41d996a1f1d2aJakub Staszak Builder->getInt(C1->getValue() & ~RHS->getValue())); 194825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 194925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 195025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Try to fold constant and into select arguments. 195125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (SelectInst *SI = dyn_cast<SelectInst>(Op0)) 195225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Instruction *R = FoldOpIntoSelect(I, SI)) 195325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return R; 19547d9f2b93a356aa89186522bd61c5c565718ff555Bill Wendling 195525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (isa<PHINode>(Op0)) 195625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Instruction *NV = FoldOpIntoPhi(I)) 195725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return NV; 195825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 195925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 1960dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Value *A = nullptr, *B = nullptr; 1961dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines ConstantInt *C1 = nullptr, *C2 = nullptr; 196225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 196325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (A | B) | C and A | (B | C) -> bswap if possible. 196425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (A >> B) | (C << D) and (A << B) | (B >> C) -> bswap if possible. 196525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (match(Op0, m_Or(m_Value(), m_Value())) || 196625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(Op1, m_Or(m_Value(), m_Value())) || 1967aeaf3d484b4d4c35e8794378c4b6cfbbde718dd1Chris Lattner (match(Op0, m_LogicalShift(m_Value(), m_Value())) && 1968aeaf3d484b4d4c35e8794378c4b6cfbbde718dd1Chris Lattner match(Op1, m_LogicalShift(m_Value(), m_Value())))) { 196925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Instruction *BSwap = MatchBSwap(I)) 197025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BSwap; 197125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 197241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 197394c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // (X^C)|Y -> (X|Y)^C iff Y&C == 0 197425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0->hasOneUse() && 197525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(Op0, m_Xor(m_Value(A), m_ConstantInt(C1))) && 197625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner MaskedValueIsZero(Op1, C1->getValue())) { 197725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NOr = Builder->CreateOr(A, Op1); 197825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner NOr->takeName(Op0); 197925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateXor(NOr, C1); 198025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 198125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 198294c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // Y|(X^C) -> (X|Y)^C iff Y&C == 0 198325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op1->hasOneUse() && 198425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(Op1, m_Xor(m_Value(A), m_ConstantInt(C1))) && 198525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner MaskedValueIsZero(Op0, C1->getValue())) { 198625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NOr = Builder->CreateOr(A, Op0); 198725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner NOr->takeName(Op0); 198825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateXor(NOr, C1); 198925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 199025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 199125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (A & C)|(B & D) 1992dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Value *C = nullptr, *D = nullptr; 199325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (match(Op0, m_And(m_Value(A), m_Value(C))) && 199425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(Op1, m_And(m_Value(B), m_Value(D)))) { 1995dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Value *V1 = nullptr, *V2 = nullptr; 199625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner C1 = dyn_cast<ConstantInt>(C); 199725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner C2 = dyn_cast<ConstantInt>(D); 199825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (C1 && C2) { // (A & C1)|(B & C2) 199925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if ((C1->getValue() & C2->getValue()) == 0) { 20008e76764de86d7906db5123626b65f593e159d9f3Chris Lattner // ((V | N) & C1) | (V & C2) --> (V|N) & (C1|C2) 200194c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // iff (C1&C2) == 0 and (N&~C1) == 0 200225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (match(A, m_Or(m_Value(V1), m_Value(V2))) && 200325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ((V1 == B && MaskedValueIsZero(V2, ~C1->getValue())) || // (V|N) 200425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner (V2 == B && MaskedValueIsZero(V1, ~C1->getValue())))) // (N|V) 200525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateAnd(A, 2006f2d03d74ffe05d08ac7dccbb81f41d996a1f1d2aJakub Staszak Builder->getInt(C1->getValue()|C2->getValue())); 200725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Or commutes, try both ways. 200825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (match(B, m_Or(m_Value(V1), m_Value(V2))) && 200925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ((V1 == A && MaskedValueIsZero(V2, ~C2->getValue())) || // (V|N) 201025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner (V2 == A && MaskedValueIsZero(V1, ~C2->getValue())))) // (N|V) 201125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateAnd(B, 2012f2d03d74ffe05d08ac7dccbb81f41d996a1f1d2aJakub Staszak Builder->getInt(C1->getValue()|C2->getValue())); 201341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 20148e76764de86d7906db5123626b65f593e159d9f3Chris Lattner // ((V|C3)&C1) | ((V|C4)&C2) --> (V|C3|C4)&(C1|C2) 201594c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // iff (C1&C2) == 0 and (C3&~C1) == 0 and (C4&~C2) == 0. 2016dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines ConstantInt *C3 = nullptr, *C4 = nullptr; 20178e76764de86d7906db5123626b65f593e159d9f3Chris Lattner if (match(A, m_Or(m_Value(V1), m_ConstantInt(C3))) && 20188e76764de86d7906db5123626b65f593e159d9f3Chris Lattner (C3->getValue() & ~C1->getValue()) == 0 && 20198e76764de86d7906db5123626b65f593e159d9f3Chris Lattner match(B, m_Or(m_Specific(V1), m_ConstantInt(C4))) && 20208e76764de86d7906db5123626b65f593e159d9f3Chris Lattner (C4->getValue() & ~C2->getValue()) == 0) { 20218e76764de86d7906db5123626b65f593e159d9f3Chris Lattner V2 = Builder->CreateOr(V1, ConstantExpr::getOr(C3, C4), "bitfield"); 20228e76764de86d7906db5123626b65f593e159d9f3Chris Lattner return BinaryOperator::CreateAnd(V2, 2023f2d03d74ffe05d08ac7dccbb81f41d996a1f1d2aJakub Staszak Builder->getInt(C1->getValue()|C2->getValue())); 20248e76764de86d7906db5123626b65f593e159d9f3Chris Lattner } 202525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 202625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 202725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 202839ceb471b7ebaf0ebef09f7916419ae2e0f30accChris Lattner // (A & (C0?-1:0)) | (B & ~(C0?-1:0)) -> C0 ? A : B, and commuted variants. 202939ceb471b7ebaf0ebef09f7916419ae2e0f30accChris Lattner // Don't do this for vector select idioms, the code generator doesn't handle 203039ceb471b7ebaf0ebef09f7916419ae2e0f30accChris Lattner // them well yet. 20311df9859c40492511b8aa4321eb76496005d3b75bDuncan Sands if (!I.getType()->isVectorTy()) { 203239ceb471b7ebaf0ebef09f7916419ae2e0f30accChris Lattner if (Instruction *Match = MatchSelectFromAndOr(A, B, C, D)) 203339ceb471b7ebaf0ebef09f7916419ae2e0f30accChris Lattner return Match; 203439ceb471b7ebaf0ebef09f7916419ae2e0f30accChris Lattner if (Instruction *Match = MatchSelectFromAndOr(B, A, D, C)) 203539ceb471b7ebaf0ebef09f7916419ae2e0f30accChris Lattner return Match; 203639ceb471b7ebaf0ebef09f7916419ae2e0f30accChris Lattner if (Instruction *Match = MatchSelectFromAndOr(C, B, A, D)) 203739ceb471b7ebaf0ebef09f7916419ae2e0f30accChris Lattner return Match; 203839ceb471b7ebaf0ebef09f7916419ae2e0f30accChris Lattner if (Instruction *Match = MatchSelectFromAndOr(D, A, B, C)) 203939ceb471b7ebaf0ebef09f7916419ae2e0f30accChris Lattner return Match; 204039ceb471b7ebaf0ebef09f7916419ae2e0f30accChris Lattner } 204125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 204225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ((A&~B)|(~A&B)) -> A^B 204325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if ((match(C, m_Not(m_Specific(D))) && 204425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(B, m_Not(m_Specific(A))))) 204525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateXor(A, D); 204625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ((~B&A)|(~A&B)) -> A^B 204725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if ((match(A, m_Not(m_Specific(D))) && 204825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(B, m_Not(m_Specific(C))))) 204925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateXor(C, D); 205025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ((A&~B)|(B&~A)) -> A^B 205125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if ((match(C, m_Not(m_Specific(B))) && 205225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(D, m_Not(m_Specific(A))))) 205325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateXor(A, B); 205425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ((~B&A)|(B&~A)) -> A^B 205525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if ((match(A, m_Not(m_Specific(B))) && 205625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(D, m_Not(m_Specific(C))))) 205725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateXor(C, B); 2058ad854f0764e6a386b0dc49a2640766b8e9ae0b61Benjamin Kramer 2059ad854f0764e6a386b0dc49a2640766b8e9ae0b61Benjamin Kramer // ((A|B)&1)|(B&-2) -> (A&1) | B 2060ad854f0764e6a386b0dc49a2640766b8e9ae0b61Benjamin Kramer if (match(A, m_Or(m_Value(V1), m_Specific(B))) || 2061ad854f0764e6a386b0dc49a2640766b8e9ae0b61Benjamin Kramer match(A, m_Or(m_Specific(B), m_Value(V1)))) { 2062ad854f0764e6a386b0dc49a2640766b8e9ae0b61Benjamin Kramer Instruction *Ret = FoldOrWithConstants(I, Op1, V1, B, C); 2063ad854f0764e6a386b0dc49a2640766b8e9ae0b61Benjamin Kramer if (Ret) return Ret; 2064ad854f0764e6a386b0dc49a2640766b8e9ae0b61Benjamin Kramer } 2065ad854f0764e6a386b0dc49a2640766b8e9ae0b61Benjamin Kramer // (B&-2)|((A|B)&1) -> (A&1) | B 2066ad854f0764e6a386b0dc49a2640766b8e9ae0b61Benjamin Kramer if (match(B, m_Or(m_Specific(A), m_Value(V1))) || 2067ad854f0764e6a386b0dc49a2640766b8e9ae0b61Benjamin Kramer match(B, m_Or(m_Value(V1), m_Specific(A)))) { 2068ad854f0764e6a386b0dc49a2640766b8e9ae0b61Benjamin Kramer Instruction *Ret = FoldOrWithConstants(I, Op0, A, V1, D); 2069ad854f0764e6a386b0dc49a2640766b8e9ae0b61Benjamin Kramer if (Ret) return Ret; 2070ad854f0764e6a386b0dc49a2640766b8e9ae0b61Benjamin Kramer } 207125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 207241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 207325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (X >> Z) | (Y >> Z) -> (X|Y) >> Z for all shifts. 207425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (BinaryOperator *SI1 = dyn_cast<BinaryOperator>(Op1)) { 207525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (BinaryOperator *SI0 = dyn_cast<BinaryOperator>(Op0)) 207641a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper if (SI0->isShift() && SI0->getOpcode() == SI1->getOpcode() && 207725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner SI0->getOperand(1) == SI1->getOperand(1) && 207825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner (SI0->hasOneUse() || SI1->hasOneUse())) { 207925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NewOp = Builder->CreateOr(SI0->getOperand(0), SI1->getOperand(0), 208025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner SI0->getName()); 208141a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper return BinaryOperator::Create(SI1->getOpcode(), NewOp, 208225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner SI1->getOperand(1)); 208325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 208425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 208525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 208625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (~A | ~B) == (~(A & B)) - De Morgan's Law 208725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Value *Op0NotVal = dyn_castNotVal(Op0)) 208825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Value *Op1NotVal = dyn_castNotVal(Op1)) 208925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0->hasOneUse() && Op1->hasOneUse()) { 209025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *And = Builder->CreateAnd(Op0NotVal, Op1NotVal, 209125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner I.getName()+".demorgan"); 209225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateNot(And); 209325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 209425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 209591e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer // Canonicalize xor to the RHS. 2096e9f15c8a563a745c5cafa7c98b1f12de2dcab070Eli Friedman bool SwappedForXor = false; 2097e9f15c8a563a745c5cafa7c98b1f12de2dcab070Eli Friedman if (match(Op0, m_Xor(m_Value(), m_Value()))) { 209891e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer std::swap(Op0, Op1); 2099e9f15c8a563a745c5cafa7c98b1f12de2dcab070Eli Friedman SwappedForXor = true; 2100e9f15c8a563a745c5cafa7c98b1f12de2dcab070Eli Friedman } 210191e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer 210291e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer // A | ( A ^ B) -> A | B 210391e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer // A | (~A ^ B) -> A | ~B 2104c1fc5e4464788be072509eab7d66a73dc7a5f275Chad Rosier // (A & B) | (A ^ B) 210591e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer if (match(Op1, m_Xor(m_Value(A), m_Value(B)))) { 210691e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer if (Op0 == A || Op0 == B) 210791e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer return BinaryOperator::CreateOr(A, B); 210891e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer 2109c1fc5e4464788be072509eab7d66a73dc7a5f275Chad Rosier if (match(Op0, m_And(m_Specific(A), m_Specific(B))) || 2110c1fc5e4464788be072509eab7d66a73dc7a5f275Chad Rosier match(Op0, m_And(m_Specific(B), m_Specific(A)))) 2111c1fc5e4464788be072509eab7d66a73dc7a5f275Chad Rosier return BinaryOperator::CreateOr(A, B); 2112c1fc5e4464788be072509eab7d66a73dc7a5f275Chad Rosier 211391e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer if (Op1->hasOneUse() && match(A, m_Not(m_Specific(Op0)))) { 211491e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer Value *Not = Builder->CreateNot(B, B->getName()+".not"); 211591e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer return BinaryOperator::CreateOr(Not, Op0); 211691e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer } 211791e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer if (Op1->hasOneUse() && match(B, m_Not(m_Specific(Op0)))) { 211891e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer Value *Not = Builder->CreateNot(A, A->getName()+".not"); 211991e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer return BinaryOperator::CreateOr(Not, Op0); 212091e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer } 212191e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer } 212291e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer 212391e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer // A | ~(A | B) -> A | ~B 212491e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer // A | ~(A ^ B) -> A | ~B 212591e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer if (match(Op1, m_Not(m_Value(A)))) 212691e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer if (BinaryOperator *B = dyn_cast<BinaryOperator>(A)) 212738f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer if ((Op0 == B->getOperand(0) || Op0 == B->getOperand(1)) && 212838f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer Op1->hasOneUse() && (B->getOpcode() == Instruction::Or || 212938f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer B->getOpcode() == Instruction::Xor)) { 213038f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer Value *NotOp = Op0 == B->getOperand(0) ? B->getOperand(1) : 213138f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer B->getOperand(0); 213238f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer Value *Not = Builder->CreateNot(NotOp, NotOp->getName()+".not"); 213338f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer return BinaryOperator::CreateOr(Not, Op0); 213438f7f66fcc6ed5e43be4d9c96c782d4eabdb7342Benjamin Kramer } 213591e37ef278779c3c8700bbddbb5c9d37739b1716Benjamin Kramer 2136e9f15c8a563a745c5cafa7c98b1f12de2dcab070Eli Friedman if (SwappedForXor) 2137e9f15c8a563a745c5cafa7c98b1f12de2dcab070Eli Friedman std::swap(Op0, Op1); 2138e9f15c8a563a745c5cafa7c98b1f12de2dcab070Eli Friedman 213925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ICmpInst *RHS = dyn_cast<ICmpInst>(I.getOperand(1))) 214025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ICmpInst *LHS = dyn_cast<ICmpInst>(I.getOperand(0))) 2141f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner if (Value *Res = FoldOrOfICmps(LHS, RHS)) 2142f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return ReplaceInstUsesWith(I, Res); 214341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 21448c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner // (fcmp uno x, c) | (fcmp uno y, c) -> (fcmp uno x, y) 21458c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner if (FCmpInst *LHS = dyn_cast<FCmpInst>(I.getOperand(0))) 21468c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner if (FCmpInst *RHS = dyn_cast<FCmpInst>(I.getOperand(1))) 2147f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner if (Value *Res = FoldOrOfFCmps(LHS, RHS)) 2148f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return ReplaceInstUsesWith(I, Res); 214941a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 215025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // fold (or (cast A), (cast B)) -> (cast (or A, B)) 215125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (CastInst *Op0C = dyn_cast<CastInst>(Op0)) { 215228621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner CastInst *Op1C = dyn_cast<CastInst>(Op1); 215328621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner if (Op1C && Op0C->getOpcode() == Op1C->getOpcode()) {// same cast kind ? 2154db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *SrcTy = Op0C->getOperand(0)->getType(); 215528621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner if (SrcTy == Op1C->getOperand(0)->getType() && 215628621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner SrcTy->isIntOrIntVectorTy()) { 215728621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner Value *Op0COp = Op0C->getOperand(0), *Op1COp = Op1C->getOperand(0); 215828621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner 215928621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner if ((!isa<ICmpInst>(Op0COp) || !isa<ICmpInst>(Op1COp)) && 216028621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner // Only do this if the casts both really cause code to be 216128621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner // generated. 216228621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner ShouldOptimizeCast(Op0C->getOpcode(), Op0COp, I.getType()) && 216328621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner ShouldOptimizeCast(Op1C->getOpcode(), Op1COp, I.getType())) { 216428621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner Value *NewOp = Builder->CreateOr(Op0COp, Op1COp, I.getName()); 216528621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner return CastInst::Create(Op0C->getOpcode(), NewOp, I.getType()); 216625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 216741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 216828621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner // If this is or(cast(icmp), cast(icmp)), try to fold this even if the 216928621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner // cast is otherwise not optimizable. This happens for vector sexts. 217028621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner if (ICmpInst *RHS = dyn_cast<ICmpInst>(Op1COp)) 217128621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner if (ICmpInst *LHS = dyn_cast<ICmpInst>(Op0COp)) 217228621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner if (Value *Res = FoldOrOfICmps(LHS, RHS)) 217328621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner return CastInst::Create(Op0C->getOpcode(), Res, I.getType()); 217441a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 217528621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner // If this is or(cast(fcmp), cast(fcmp)), try to fold this even if the 217628621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner // cast is otherwise not optimizable. This happens for vector sexts. 217728621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner if (FCmpInst *RHS = dyn_cast<FCmpInst>(Op1COp)) 217828621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner if (FCmpInst *LHS = dyn_cast<FCmpInst>(Op0COp)) 217928621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner if (Value *Res = FoldOrOfFCmps(LHS, RHS)) 218028621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner return CastInst::Create(Op0C->getOpcode(), Res, I.getType()); 218125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 218228621cb36f1d5c761dc5b493c501b4c7252fe5dcChris Lattner } 218325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 21843ec01b7dac769449723a25d8f7d33b49c917ccc9Eli Friedman 21853ec01b7dac769449723a25d8f7d33b49c917ccc9Eli Friedman // or(sext(A), B) -> A ? -1 : B where A is an i1 21863ec01b7dac769449723a25d8f7d33b49c917ccc9Eli Friedman // or(A, sext(B)) -> B ? -1 : A where B is an i1 21873ec01b7dac769449723a25d8f7d33b49c917ccc9Eli Friedman if (match(Op0, m_SExt(m_Value(A))) && A->getType()->isIntegerTy(1)) 21883ec01b7dac769449723a25d8f7d33b49c917ccc9Eli Friedman return SelectInst::Create(A, ConstantInt::getSigned(I.getType(), -1), Op1); 21893ec01b7dac769449723a25d8f7d33b49c917ccc9Eli Friedman if (match(Op1, m_SExt(m_Value(A))) && A->getType()->isIntegerTy(1)) 21903ec01b7dac769449723a25d8f7d33b49c917ccc9Eli Friedman return SelectInst::Create(A, ConstantInt::getSigned(I.getType(), -1), Op0); 21913ec01b7dac769449723a25d8f7d33b49c917ccc9Eli Friedman 21922c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson // Note: If we've gotten to the point of visiting the outer OR, then the 21932c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson // inner one couldn't be simplified. If it was a constant, then it won't 21942c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson // be simplified by a later pass either, so we try swapping the inner/outer 21952c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson // ORs in the hopes that we'll be able to simplify it this way. 21962c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson // (X|C) | V --> (X|V) | C 21972c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson if (Op0->hasOneUse() && !isa<ConstantInt>(Op1) && 21982c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson match(Op0, m_Or(m_Value(A), m_ConstantInt(C1)))) { 21992c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson Value *Inner = Builder->CreateOr(A, Op1); 22002c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson Inner->takeName(Op0); 22012c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson return BinaryOperator::CreateOr(Inner, C1); 22022c5f19db2eef055d2a65482504ae98e79f2ca24dOwen Anderson } 220341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 2204cc54889cd58322b8766525f43cc1f7cb52e4692eBill Wendling // Change (or (bool?A:B),(bool?C:D)) --> (bool?(or A,C):(or B,D)) 2205cc54889cd58322b8766525f43cc1f7cb52e4692eBill Wendling // Since this OR statement hasn't been optimized further yet, we hope 2206cc54889cd58322b8766525f43cc1f7cb52e4692eBill Wendling // that this transformation will allow the new ORs to be optimized. 2207cc54889cd58322b8766525f43cc1f7cb52e4692eBill Wendling { 2208dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Value *X = nullptr, *Y = nullptr; 2209cc54889cd58322b8766525f43cc1f7cb52e4692eBill Wendling if (Op0->hasOneUse() && Op1->hasOneUse() && 2210cc54889cd58322b8766525f43cc1f7cb52e4692eBill Wendling match(Op0, m_Select(m_Value(X), m_Value(A), m_Value(B))) && 2211cc54889cd58322b8766525f43cc1f7cb52e4692eBill Wendling match(Op1, m_Select(m_Value(Y), m_Value(C), m_Value(D))) && X == Y) { 2212cc54889cd58322b8766525f43cc1f7cb52e4692eBill Wendling Value *orTrue = Builder->CreateOr(A, C); 2213cc54889cd58322b8766525f43cc1f7cb52e4692eBill Wendling Value *orFalse = Builder->CreateOr(B, D); 2214cc54889cd58322b8766525f43cc1f7cb52e4692eBill Wendling return SelectInst::Create(X, orTrue, orFalse); 2215cc54889cd58322b8766525f43cc1f7cb52e4692eBill Wendling } 2216cc54889cd58322b8766525f43cc1f7cb52e4692eBill Wendling } 2217cc54889cd58322b8766525f43cc1f7cb52e4692eBill Wendling 2218dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return Changed ? &I : nullptr; 221925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 222025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 222125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris LattnerInstruction *InstCombiner::visitXor(BinaryOperator &I) { 2222096aa79276b8527a3cbbb3691e40e729dea09523Duncan Sands bool Changed = SimplifyAssociativeOrCommutative(I); 222325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1); 222425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 2225dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (Value *V = SimplifyVectorOp(I)) 2226dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return ReplaceInstUsesWith(I, V); 2227dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines 222836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (Value *V = SimplifyXorInst(Op0, Op1, DL)) 22292b749870d0488c3b049edf5d0c8875f56f5b1bedDuncan Sands return ReplaceInstUsesWith(I, V); 223025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 223137bf92b5238434b00fde79347ba5336e7554e562Duncan Sands // (A&B)^(A&C) -> A&(B^C) etc 223237bf92b5238434b00fde79347ba5336e7554e562Duncan Sands if (Value *V = SimplifyUsingDistributiveLaws(I)) 223337bf92b5238434b00fde79347ba5336e7554e562Duncan Sands return ReplaceInstUsesWith(I, V); 22345057f381418ddc8c96699c40479ead993cd62e7bDuncan Sands 223541a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper // See if we can simplify any instructions used by the instruction whose sole 223625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // purpose is to compute bits we don't care about. 223725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (SimplifyDemandedInstructionBits(I)) 223825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return &I; 223925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 224025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Is this a ~ operation? 224125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Value *NotOp = dyn_castNotVal(&I)) { 224225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (BinaryOperator *Op0I = dyn_cast<BinaryOperator>(NotOp)) { 224341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper if (Op0I->getOpcode() == Instruction::And || 224425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op0I->getOpcode() == Instruction::Or) { 224525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ~(~X & Y) --> (X | ~Y) - De Morgan's Law 224625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ~(~X | Y) === (X & ~Y) - De Morgan's Law 224725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (dyn_castNotVal(Op0I->getOperand(1))) 224825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op0I->swapOperands(); 224925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Value *Op0NotVal = dyn_castNotVal(Op0I->getOperand(0))) { 225025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NotY = 225125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Builder->CreateNot(Op0I->getOperand(1), 225225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op0I->getOperand(1)->getName()+".not"); 225325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0I->getOpcode() == Instruction::And) 225425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateOr(Op0NotVal, NotY); 225525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateAnd(Op0NotVal, NotY); 225625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 225741a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 225825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ~(X & Y) --> (~X | ~Y) - De Morgan's Law 225925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ~(X | Y) === (~X & ~Y) - De Morgan's Law 226041a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper if (isFreeToInvert(Op0I->getOperand(0)) && 226125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner isFreeToInvert(Op0I->getOperand(1))) { 226225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NotX = 226325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Builder->CreateNot(Op0I->getOperand(0), "notlhs"); 226425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NotY = 226525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Builder->CreateNot(Op0I->getOperand(1), "notrhs"); 226625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0I->getOpcode() == Instruction::And) 226725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateOr(NotX, NotY); 226825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateAnd(NotX, NotY); 226925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 2270c0404b3715151d020dda074740bbdaa794f9328aChris Lattner 2271c0404b3715151d020dda074740bbdaa794f9328aChris Lattner } else if (Op0I->getOpcode() == Instruction::AShr) { 2272c0404b3715151d020dda074740bbdaa794f9328aChris Lattner // ~(~X >>s Y) --> (X >>s Y) 2273c0404b3715151d020dda074740bbdaa794f9328aChris Lattner if (Value *Op0NotVal = dyn_castNotVal(Op0I->getOperand(0))) 2274c0404b3715151d020dda074740bbdaa794f9328aChris Lattner return BinaryOperator::CreateAShr(Op0NotVal, Op0I->getOperand(1)); 227525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 227625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 227725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 227841a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 227941a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 228025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ConstantInt *RHS = dyn_cast<ConstantInt>(Op1)) { 22816c3ae655b846ae663ea14000adf3b42e9455ce56Dan Gohman if (RHS->isOne() && Op0->hasOneUse()) 228225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // xor (cmp A, B), true = not (cmp A, B) = !cmp A, B 22836c3ae655b846ae663ea14000adf3b42e9455ce56Dan Gohman if (CmpInst *CI = dyn_cast<CmpInst>(Op0)) 22846c3ae655b846ae663ea14000adf3b42e9455ce56Dan Gohman return CmpInst::Create(CI->getOpcode(), 22856c3ae655b846ae663ea14000adf3b42e9455ce56Dan Gohman CI->getInversePredicate(), 22866c3ae655b846ae663ea14000adf3b42e9455ce56Dan Gohman CI->getOperand(0), CI->getOperand(1)); 228725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 228825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // fold (xor(zext(cmp)), 1) and (xor(sext(cmp)), -1) to ext(!cmp). 228925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (CastInst *Op0C = dyn_cast<CastInst>(Op0)) { 229025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (CmpInst *CI = dyn_cast<CmpInst>(Op0C->getOperand(0))) { 229125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (CI->hasOneUse() && Op0C->hasOneUse()) { 229225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Instruction::CastOps Opcode = Op0C->getOpcode(); 229325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if ((Opcode == Instruction::ZExt || Opcode == Instruction::SExt) && 2294f2d03d74ffe05d08ac7dccbb81f41d996a1f1d2aJakub Staszak (RHS == ConstantExpr::getCast(Opcode, Builder->getTrue(), 229525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op0C->getDestTy()))) { 229625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner CI->setPredicate(CI->getInversePredicate()); 229725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return CastInst::Create(Opcode, CI, Op0C->getType()); 229825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 229925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 230025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 230125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 230225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 230325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (BinaryOperator *Op0I = dyn_cast<BinaryOperator>(Op0)) { 230425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ~(c-X) == X-c-1 == X+(-c-1) 230525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0I->getOpcode() == Instruction::Sub && RHS->isAllOnesValue()) 230625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Constant *Op0I0C = dyn_cast<Constant>(Op0I->getOperand(0))) { 230725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Constant *NegOp0I0C = ConstantExpr::getNeg(Op0I0C); 230825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Constant *ConstantRHS = ConstantExpr::getSub(NegOp0I0C, 230925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt::get(I.getType(), 1)); 231025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateAdd(Op0I->getOperand(1), ConstantRHS); 231125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 231241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 231325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ConstantInt *Op0CI = dyn_cast<ConstantInt>(Op0I->getOperand(1))) { 231425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0I->getOpcode() == Instruction::Add) { 231525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // ~(X-c) --> (-c-1)-X 231625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (RHS->isAllOnesValue()) { 231725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Constant *NegOp0CI = ConstantExpr::getNeg(Op0CI); 231825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateSub( 231925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantExpr::getSub(NegOp0CI, 232025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantInt::get(I.getType(), 1)), 232125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op0I->getOperand(0)); 232225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } else if (RHS->getValue().isSignBit()) { 232325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (X + C) ^ signbit -> (X + C + signbit) 2324f2d03d74ffe05d08ac7dccbb81f41d996a1f1d2aJakub Staszak Constant *C = Builder->getInt(RHS->getValue() + Op0CI->getValue()); 232525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateAdd(Op0I->getOperand(0), C); 232625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 232725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 232825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } else if (Op0I->getOpcode() == Instruction::Or) { 232994c22716d60ff5edf6a98a3c67e0faa001be1142Sylvestre Ledru // (X|C1)^C2 -> X^(C1|C2) iff X&~C1 == 0 233025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (MaskedValueIsZero(Op0I->getOperand(0), Op0CI->getValue())) { 233125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Constant *NewRHS = ConstantExpr::getOr(Op0CI, RHS); 233225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Anything in both C1 and C2 is known to be zero, remove it from 233325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // NewRHS. 233425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Constant *CommonBits = ConstantExpr::getAnd(Op0CI, RHS); 233541a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper NewRHS = ConstantExpr::getAnd(NewRHS, 233625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner ConstantExpr::getNot(CommonBits)); 233725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Worklist.Add(Op0I); 233825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner I.setOperand(0, Op0I->getOperand(0)); 233925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner I.setOperand(1, NewRHS); 234025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return &I; 234125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 2342b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang } else if (Op0I->getOpcode() == Instruction::LShr) { 2343b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang // ((X^C1) >> C2) ^ C3 -> (X>>C2) ^ ((C1>>C2)^C3) 2344b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang // E1 = "X ^ C1" 234541a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper BinaryOperator *E1; 2346b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang ConstantInt *C1; 2347b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang if (Op0I->hasOneUse() && 2348b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang (E1 = dyn_cast<BinaryOperator>(Op0I->getOperand(0))) && 2349b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang E1->getOpcode() == Instruction::Xor && 2350b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang (C1 = dyn_cast<ConstantInt>(E1->getOperand(1)))) { 2351b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang // fold (C1 >> C2) ^ C3 2352b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang ConstantInt *C2 = Op0CI, *C3 = RHS; 2353b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang APInt FoldConst = C1->getValue().lshr(C2->getValue()); 2354b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang FoldConst ^= C3->getValue(); 2355b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang // Prepare the two operands. 2356b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang Value *Opnd0 = Builder->CreateLShr(E1->getOperand(0), C2); 2357b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang Opnd0->takeName(Op0I); 2358b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang cast<Instruction>(Opnd0)->setDebugLoc(I.getDebugLoc()); 2359b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang Value *FoldVal = ConstantInt::get(Opnd0->getType(), FoldConst); 2360b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang 2361b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang return BinaryOperator::CreateXor(Opnd0, FoldVal); 2362b30e256993e075c838ffa1b7af6b04dd28be2c34Shuxin Yang } 236325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 236425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 236525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 236625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 236725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Try to fold constant and into select arguments. 236825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (SelectInst *SI = dyn_cast<SelectInst>(Op0)) 236925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Instruction *R = FoldOpIntoSelect(I, SI)) 237025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return R; 237125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (isa<PHINode>(Op0)) 237225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Instruction *NV = FoldOpIntoPhi(I)) 237325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return NV; 237425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 237525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 237625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner BinaryOperator *Op1I = dyn_cast<BinaryOperator>(Op1); 237725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op1I) { 237825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *A, *B; 237925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (match(Op1I, m_Or(m_Value(A), m_Value(B)))) { 238025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (A == Op0) { // B^(B|A) == (A|B)^B 238125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op1I->swapOperands(); 238225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner I.swapOperands(); 238325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(Op0, Op1); 238425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } else if (B == Op0) { // B^(A|B) == (A|B)^B 238525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner I.swapOperands(); // Simplified below. 238625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(Op0, Op1); 238725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 238841a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper } else if (match(Op1I, m_And(m_Value(A), m_Value(B))) && 238925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op1I->hasOneUse()){ 239025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (A == Op0) { // A^(A&B) -> A^(B&A) 239125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op1I->swapOperands(); 239225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(A, B); 239325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 239425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (B == Op0) { // A^(B&A) -> (B&A)^A 239525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner I.swapOperands(); // Simplified below. 239625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(Op0, Op1); 239725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 239825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 239925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 240041a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 240125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner BinaryOperator *Op0I = dyn_cast<BinaryOperator>(Op0); 240225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0I) { 240325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *A, *B; 240425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (match(Op0I, m_Or(m_Value(A), m_Value(B))) && 240525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op0I->hasOneUse()) { 240625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (A == Op1) // (B|A)^B == (A|B)^B 240725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(A, B); 240825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (B == Op1) // (A|B)^B == A & ~B 2409a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer return BinaryOperator::CreateAnd(A, Builder->CreateNot(Op1)); 241041a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper } else if (match(Op0I, m_And(m_Value(A), m_Value(B))) && 241125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op0I->hasOneUse()){ 241225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (A == Op1) // (A&B)^A -> (B&A)^A 241325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner std::swap(A, B); 241425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (B == Op1 && // (B&A)^A == ~B & A 241525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner !isa<ConstantInt>(Op1)) { // Canonical form is (B&C)^C 2416a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer return BinaryOperator::CreateAnd(Builder->CreateNot(A), Op1); 241725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 241825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 241925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 242041a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 242125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (X >> Z) ^ (Y >> Z) -> (X^Y) >> Z for all shifts. 242241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper if (Op0I && Op1I && Op0I->isShift() && 242341a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper Op0I->getOpcode() == Op1I->getOpcode() && 242425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op0I->getOperand(1) == Op1I->getOperand(1) && 24257bb9f063be7c1228eb2647364ce3bbc9b31b7dc8Benjamin Kramer (Op0I->hasOneUse() || Op1I->hasOneUse())) { 242625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NewOp = 242725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Builder->CreateXor(Op0I->getOperand(0), Op1I->getOperand(0), 242825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op0I->getName()); 242941a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper return BinaryOperator::Create(Op1I->getOpcode(), NewOp, 243025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op1I->getOperand(1)); 243125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 243241a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper 243325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0I && Op1I) { 243425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *A, *B, *C, *D; 243525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (A & B)^(A | B) -> A ^ B 243625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (match(Op0I, m_And(m_Value(A), m_Value(B))) && 243725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(Op1I, m_Or(m_Value(C), m_Value(D)))) { 243841a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper if ((A == C && B == D) || (A == D && B == C)) 243925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateXor(A, B); 244025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 244125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (A | B)^(A & B) -> A ^ B 244225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (match(Op0I, m_Or(m_Value(A), m_Value(B))) && 244325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner match(Op1I, m_And(m_Value(C), m_Value(D)))) { 244441a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper if ((A == C && B == D) || (A == D && B == C)) 244525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return BinaryOperator::CreateXor(A, B); 244625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 244725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 24485057f381418ddc8c96699c40479ead993cd62e7bDuncan Sands 244925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // (icmp1 A, B) ^ (icmp2 A, B) --> (icmp3 A, B) 245025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ICmpInst *RHS = dyn_cast<ICmpInst>(I.getOperand(1))) 245125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (ICmpInst *LHS = dyn_cast<ICmpInst>(I.getOperand(0))) 245225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (PredicatesFoldable(LHS->getPredicate(), RHS->getPredicate())) { 245325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHS->getOperand(0) == RHS->getOperand(1) && 245425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner LHS->getOperand(1) == RHS->getOperand(0)) 245525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner LHS->swapOperands(); 245625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (LHS->getOperand(0) == RHS->getOperand(0) && 245725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner LHS->getOperand(1) == RHS->getOperand(1)) { 245825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *Op0 = LHS->getOperand(0), *Op1 = LHS->getOperand(1); 245925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner unsigned Code = getICmpCode(LHS) ^ getICmpCode(RHS); 246025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner bool isSigned = LHS->isSigned() || RHS->isSigned(); 246141a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper return ReplaceInstUsesWith(I, 24622e33944c101f2a08ed1d85e807830f2fc089dd06Pete Cooper getNewICmpValue(isSigned, Code, Op0, Op1, 24632e33944c101f2a08ed1d85e807830f2fc089dd06Pete Cooper Builder)); 246425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 246525f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 246625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 246725f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // fold (xor (cast A), (cast B)) -> (cast (xor A, B)) 246825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (CastInst *Op0C = dyn_cast<CastInst>(Op0)) { 246925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (CastInst *Op1C = dyn_cast<CastInst>(Op1)) 247025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner if (Op0C->getOpcode() == Op1C->getOpcode()) { // same cast kind? 2471db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *SrcTy = Op0C->getOperand(0)->getType(); 2472b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands if (SrcTy == Op1C->getOperand(0)->getType() && SrcTy->isIntegerTy() && 247325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner // Only do this if the casts both really cause code to be generated. 247441a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper ShouldOptimizeCast(Op0C->getOpcode(), Op0C->getOperand(0), 24758c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner I.getType()) && 247641a05dc59c599b2d121650c77ec11e28d17e5cc7Craig Topper ShouldOptimizeCast(Op1C->getOpcode(), Op1C->getOperand(0), 24778c5ad3a5da7419af4d31963c3824836b5da52478Chris Lattner I.getType())) { 247825f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Value *NewOp = Builder->CreateXor(Op0C->getOperand(0), 247925f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner Op1C->getOperand(0), I.getName()); 248025f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner return CastInst::Create(Op0C->getOpcode(), NewOp, I.getType()); 248125f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 248225f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 248325f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner } 248425f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner 2485dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return Changed ? &I : nullptr; 248625f2a23b4ac9610eaa73e9dff9831fdbf1492071Chris Lattner} 2487