102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner//===- InstCombineCompares.cpp --------------------------------------------===// 202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner// 302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner// The LLVM Compiler Infrastructure 402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner// 502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner// This file is distributed under the University of Illinois Open Source 602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner// License. See LICENSE.TXT for details. 702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner// 802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner//===----------------------------------------------------------------------===// 902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner// 1002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner// This file implements the visitICmp and visitFCmp functions. 1102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner// 1202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner//===----------------------------------------------------------------------===// 1302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 1402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner#include "InstCombine.h" 15747032522f9f3b2d9bae71aa303c1a0fd953eee9Eli Friedman#include "llvm/Analysis/ConstantFolding.h" 1602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner#include "llvm/Analysis/InstructionSimplify.h" 1702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner#include "llvm/Analysis/MemoryBuiltins.h" 180b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/DataLayout.h" 190b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/IntrinsicInst.h" 2002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner#include "llvm/Support/ConstantRange.h" 2102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner#include "llvm/Support/GetElementPtrTypeIterator.h" 2202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner#include "llvm/Support/PatternMatch.h" 23d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Target/TargetLibraryInfo.h" 2402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattnerusing namespace llvm; 2502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattnerusing namespace PatternMatch; 2602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 27b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattnerstatic ConstantInt *getOne(Constant *C) { 28b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner return ConstantInt::get(cast<IntegerType>(C->getType()), 1); 29b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner} 30b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner 3102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// AddOne - Add one to a ConstantInt 3202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattnerstatic Constant *AddOne(Constant *C) { 3302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return ConstantExpr::getAdd(C, ConstantInt::get(C->getType(), 1)); 3402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner} 3502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// SubOne - Subtract one from a ConstantInt 36b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattnerstatic Constant *SubOne(Constant *C) { 37b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner return ConstantExpr::getSub(C, ConstantInt::get(C->getType(), 1)); 3802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner} 3902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 4002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattnerstatic ConstantInt *ExtractElement(Constant *V, Constant *Idx) { 4102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return cast<ConstantInt>(ConstantExpr::getExtractElement(V, Idx)); 4202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner} 4302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 4402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattnerstatic bool HasAddOverflow(ConstantInt *Result, 4502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt *In1, ConstantInt *In2, 4602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner bool IsSigned) { 47c73b24db5f6226ed44ebc44ce1c25bb357206623Chris Lattner if (!IsSigned) 4802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return Result->getValue().ult(In1->getValue()); 49c73b24db5f6226ed44ebc44ce1c25bb357206623Chris Lattner 50c73b24db5f6226ed44ebc44ce1c25bb357206623Chris Lattner if (In2->isNegative()) 51c73b24db5f6226ed44ebc44ce1c25bb357206623Chris Lattner return Result->getValue().sgt(In1->getValue()); 52c73b24db5f6226ed44ebc44ce1c25bb357206623Chris Lattner return Result->getValue().slt(In1->getValue()); 5302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner} 5402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 5502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// AddWithOverflow - Compute Result = In1+In2, returning true if the result 5602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// overflowed for this type. 5702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattnerstatic bool AddWithOverflow(Constant *&Result, Constant *In1, 5802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant *In2, bool IsSigned = false) { 5902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Result = ConstantExpr::getAdd(In1, In2); 6002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 61db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (VectorType *VTy = dyn_cast<VectorType>(In1->getType())) { 6202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) { 6302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant *Idx = ConstantInt::get(Type::getInt32Ty(In1->getContext()), i); 6402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (HasAddOverflow(ExtractElement(Result, Idx), 6502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ExtractElement(In1, Idx), 6602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ExtractElement(In2, Idx), 6702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner IsSigned)) 6802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return true; 6902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 7002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return false; 7102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 7202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 7302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return HasAddOverflow(cast<ConstantInt>(Result), 7402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner cast<ConstantInt>(In1), cast<ConstantInt>(In2), 7502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner IsSigned); 7602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner} 7702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 7802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattnerstatic bool HasSubOverflow(ConstantInt *Result, 7902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt *In1, ConstantInt *In2, 8002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner bool IsSigned) { 81c73b24db5f6226ed44ebc44ce1c25bb357206623Chris Lattner if (!IsSigned) 8202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return Result->getValue().ugt(In1->getValue()); 830cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 84c73b24db5f6226ed44ebc44ce1c25bb357206623Chris Lattner if (In2->isNegative()) 85c73b24db5f6226ed44ebc44ce1c25bb357206623Chris Lattner return Result->getValue().slt(In1->getValue()); 86c73b24db5f6226ed44ebc44ce1c25bb357206623Chris Lattner 87c73b24db5f6226ed44ebc44ce1c25bb357206623Chris Lattner return Result->getValue().sgt(In1->getValue()); 8802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner} 8902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 9002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// SubWithOverflow - Compute Result = In1-In2, returning true if the result 9102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// overflowed for this type. 9202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattnerstatic bool SubWithOverflow(Constant *&Result, Constant *In1, 9302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant *In2, bool IsSigned = false) { 9402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Result = ConstantExpr::getSub(In1, In2); 9502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 96db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (VectorType *VTy = dyn_cast<VectorType>(In1->getType())) { 9702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner for (unsigned i = 0, e = VTy->getNumElements(); i != e; ++i) { 9802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant *Idx = ConstantInt::get(Type::getInt32Ty(In1->getContext()), i); 9902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (HasSubOverflow(ExtractElement(Result, Idx), 10002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ExtractElement(In1, Idx), 10102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ExtractElement(In2, Idx), 10202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner IsSigned)) 10302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return true; 10402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 10502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return false; 10602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 10702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 10802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return HasSubOverflow(cast<ConstantInt>(Result), 10902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner cast<ConstantInt>(In1), cast<ConstantInt>(In2), 11002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner IsSigned); 11102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner} 11202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 11302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// isSignBitCheck - Given an exploded icmp instruction, return true if the 11402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// comparison only checks the sign bit. If it only checks the sign bit, set 11502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// TrueIfSigned if the result of the comparison is true when the input value is 11602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// signed. 11702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattnerstatic bool isSignBitCheck(ICmpInst::Predicate pred, ConstantInt *RHS, 11802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner bool &TrueIfSigned) { 11902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner switch (pred) { 12002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_SLT: // True if LHS s< 0 12102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner TrueIfSigned = true; 12202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return RHS->isZero(); 12302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_SLE: // True if LHS s<= RHS and RHS == -1 12402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner TrueIfSigned = true; 12502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return RHS->isAllOnesValue(); 12602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_SGT: // True if LHS s> -1 12702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner TrueIfSigned = false; 12802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return RHS->isAllOnesValue(); 12902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_UGT: 13002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // True if LHS u> RHS and RHS == high-bit-mask - 1 13102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner TrueIfSigned = true; 132c73b24db5f6226ed44ebc44ce1c25bb357206623Chris Lattner return RHS->isMaxValue(true); 1330cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach case ICmpInst::ICMP_UGE: 13402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // True if LHS u>= RHS and RHS == high-bit-mask (2^7, 2^15, 2^31, etc) 13502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner TrueIfSigned = true; 13602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return RHS->getValue().isSignBit(); 13702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner default: 13802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return false; 13902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 14002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner} 14102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 14202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner// isHighOnes - Return true if the constant is of the form 1+0+. 14302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner// This is the same as lowones(~X). 14402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattnerstatic bool isHighOnes(const ConstantInt *CI) { 14502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return (~CI->getValue() + 1).isPowerOf2(); 14602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner} 14702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 1480cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach/// ComputeSignedMinMaxValuesFromKnownBits - Given a signed integer type and a 14902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// set of known zero and one bits, compute the maximum and minimum values that 15002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// could have the specified known zero and known one bits, returning them in 15102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// min/max. 15202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattnerstatic void ComputeSignedMinMaxValuesFromKnownBits(const APInt& KnownZero, 15302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner const APInt& KnownOne, 15402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner APInt& Min, APInt& Max) { 15502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner assert(KnownZero.getBitWidth() == KnownOne.getBitWidth() && 15602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner KnownZero.getBitWidth() == Min.getBitWidth() && 15702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner KnownZero.getBitWidth() == Max.getBitWidth() && 15802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner "KnownZero, KnownOne and Min, Max must have equal bitwidth."); 15902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner APInt UnknownBits = ~(KnownZero|KnownOne); 16002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 16102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // The minimum value is when all unknown bits are zeros, EXCEPT for the sign 16202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // bit if it is unknown. 16302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Min = KnownOne; 16402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Max = KnownOne|UnknownBits; 1650cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 16602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (UnknownBits.isNegative()) { // Sign bit is unknown 1677a874ddda037349184fbeb22838cc11a1a9bb78fJay Foad Min.setBit(Min.getBitWidth()-1); 1687a874ddda037349184fbeb22838cc11a1a9bb78fJay Foad Max.clearBit(Max.getBitWidth()-1); 16902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 17002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner} 17102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 17202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner// ComputeUnsignedMinMaxValuesFromKnownBits - Given an unsigned integer type and 17302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner// a set of known zero and one bits, compute the maximum and minimum values that 17402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner// could have the specified known zero and known one bits, returning them in 17502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner// min/max. 17602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattnerstatic void ComputeUnsignedMinMaxValuesFromKnownBits(const APInt &KnownZero, 17702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner const APInt &KnownOne, 17802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner APInt &Min, APInt &Max) { 17902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner assert(KnownZero.getBitWidth() == KnownOne.getBitWidth() && 18002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner KnownZero.getBitWidth() == Min.getBitWidth() && 18102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner KnownZero.getBitWidth() == Max.getBitWidth() && 18202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner "Ty, KnownZero, KnownOne and Min, Max must have equal bitwidth."); 18302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner APInt UnknownBits = ~(KnownZero|KnownOne); 1840cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 18502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // The minimum value is when the unknown bits are all zeros. 18602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Min = KnownOne; 18702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // The maximum value is when the unknown bits are all ones. 18802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Max = KnownOne|UnknownBits; 18902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner} 19002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 19102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 19202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 19302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// FoldCmpLoadFromIndexedGlobal - Called we see this pattern: 19402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// cmp pred (load (gep GV, ...)), cmpcst 19502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// where GV is a global variable with a constant initializer. Try to simplify 19602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// this into some simple computation that does not need the load. For example 19702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// we can optimize "icmp eq (load (gep "foo", 0, i)), 0" into "icmp eq i, 3". 19802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// 19902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// If AndCst is non-null, then the loaded value is masked with that constant 20002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// before doing the comparison. This handles cases like "A[i]&4 == 0". 20102446fc99abb06d3117d65c0b1f5fba4f906db2eChris LattnerInstruction *InstCombiner:: 20202446fc99abb06d3117d65c0b1f5fba4f906db2eChris LattnerFoldCmpLoadFromIndexedGlobal(GetElementPtrInst *GEP, GlobalVariable *GV, 20302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner CmpInst &ICI, ConstantInt *AndCst) { 204d7f5a588907f86ddc83fa29accea54a6c0e78e94Chris Lattner // We need TD information to know the pointer size unless this is inbounds. 205d7f5a588907f86ddc83fa29accea54a6c0e78e94Chris Lattner if (!GEP->isInBounds() && TD == 0) return 0; 2060cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 207c8d75c78ec5d30db0d5b75bd8bc85dd65106868fChris Lattner Constant *Init = GV->getInitializer(); 208c8d75c78ec5d30db0d5b75bd8bc85dd65106868fChris Lattner if (!isa<ConstantArray>(Init) && !isa<ConstantDataArray>(Init)) 209c8d75c78ec5d30db0d5b75bd8bc85dd65106868fChris Lattner return 0; 210c8d75c78ec5d30db0d5b75bd8bc85dd65106868fChris Lattner 211c8d75c78ec5d30db0d5b75bd8bc85dd65106868fChris Lattner uint64_t ArrayElementCount = Init->getType()->getArrayNumElements(); 212c8d75c78ec5d30db0d5b75bd8bc85dd65106868fChris Lattner if (ArrayElementCount > 1024) return 0; // Don't blow up on huge arrays. 2130cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 21402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // There are many forms of this optimization we can handle, for now, just do 21502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // the simple index into a single-dimensional array. 21602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // 21702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Require: GEP GV, 0, i {{, constant indices}} 21802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (GEP->getNumOperands() < 3 || 21902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner !isa<ConstantInt>(GEP->getOperand(1)) || 22002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner !cast<ConstantInt>(GEP->getOperand(1))->isZero() || 22102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner isa<Constant>(GEP->getOperand(2))) 22202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return 0; 22302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 22402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Check that indices after the variable are constants and in-range for the 22502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // type they index. Collect the indices. This is typically for arrays of 22602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // structs. 22702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner SmallVector<unsigned, 4> LaterIndices; 2280cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 229c8d75c78ec5d30db0d5b75bd8bc85dd65106868fChris Lattner Type *EltTy = Init->getType()->getArrayElementType(); 23002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner for (unsigned i = 3, e = GEP->getNumOperands(); i != e; ++i) { 23102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt *Idx = dyn_cast<ConstantInt>(GEP->getOperand(i)); 23202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Idx == 0) return 0; // Variable index. 2330cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 23402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner uint64_t IdxVal = Idx->getZExtValue(); 23502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if ((unsigned)IdxVal != IdxVal) return 0; // Too large array index. 2360cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 237db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (StructType *STy = dyn_cast<StructType>(EltTy)) 23802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner EltTy = STy->getElementType(IdxVal); 239db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner else if (ArrayType *ATy = dyn_cast<ArrayType>(EltTy)) { 24002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (IdxVal >= ATy->getNumElements()) return 0; 24102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner EltTy = ATy->getElementType(); 24202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else { 24302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return 0; // Unknown type. 24402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 2450cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 24602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner LaterIndices.push_back(IdxVal); 24702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 2480cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 24902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner enum { Overdefined = -3, Undefined = -2 }; 25002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 25102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Variables for our state machines. 2520cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 25302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // FirstTrueElement/SecondTrueElement - Used to emit a comparison of the form 25402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // "i == 47 | i == 87", where 47 is the first index the condition is true for, 25502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // and 87 is the second (and last) index. FirstTrueElement is -2 when 25602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // undefined, otherwise set to the first true element. SecondTrueElement is 25702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // -2 when undefined, -3 when overdefined and >= 0 when that index is true. 25802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner int FirstTrueElement = Undefined, SecondTrueElement = Undefined; 25902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 26002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // FirstFalseElement/SecondFalseElement - Used to emit a comparison of the 26102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // form "i != 47 & i != 87". Same state transitions as for true elements. 26202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner int FirstFalseElement = Undefined, SecondFalseElement = Undefined; 2630cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 26402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner /// TrueRangeEnd/FalseRangeEnd - In conjunction with First*Element, these 26502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner /// define a state machine that triggers for ranges of values that the index 26602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner /// is true or false for. This triggers on things like "abbbbc"[i] == 'b'. 26702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner /// This is -2 when undefined, -3 when overdefined, and otherwise the last 26802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner /// index in the range (inclusive). We use -2 for undefined here because we 26902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner /// use relative comparisons and don't want 0-1 to match -1. 27002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner int TrueRangeEnd = Undefined, FalseRangeEnd = Undefined; 2710cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 27202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // MagicBitvector - This is a magic bitvector where we set a bit if the 27302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // comparison is true for element 'i'. If there are 64 elements or less in 27402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // the array, this will fully represent all the comparison results. 27502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner uint64_t MagicBitvector = 0; 2760cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 2770cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 27802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Scan the array and see if one of our patterns matches. 27902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant *CompareRHS = cast<Constant>(ICI.getOperand(1)); 280c8d75c78ec5d30db0d5b75bd8bc85dd65106868fChris Lattner for (unsigned i = 0, e = ArrayElementCount; i != e; ++i) { 281c8d75c78ec5d30db0d5b75bd8bc85dd65106868fChris Lattner Constant *Elt = Init->getAggregateElement(i); 282c8d75c78ec5d30db0d5b75bd8bc85dd65106868fChris Lattner if (Elt == 0) return 0; 2830cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 28402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If this is indexing an array of structures, get the structure element. 28502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!LaterIndices.empty()) 286fc6d3a49867cd38954dc40936a88f1907252c6d2Jay Foad Elt = ConstantExpr::getExtractValue(Elt, LaterIndices); 2870cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 28802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If the element is masked, handle it. 28902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (AndCst) Elt = ConstantExpr::getAnd(Elt, AndCst); 2900cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 29102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Find out if the comparison would be true or false for the i'th element. 29202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant *C = ConstantFoldCompareInstOperands(ICI.getPredicate(), Elt, 293aab8e28d5e470711d80276bbf717408c3ab966fdChad Rosier CompareRHS, TD, TLI); 29402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If the result is undef for this element, ignore it. 29502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (isa<UndefValue>(C)) { 29602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Extend range state machines to cover this element in case there is an 29702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // undef in the middle of the range. 29802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (TrueRangeEnd == (int)i-1) 29902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner TrueRangeEnd = i; 30002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (FalseRangeEnd == (int)i-1) 30102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner FalseRangeEnd = i; 30202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner continue; 30302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 3040cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 30502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If we can't compute the result for any of the elements, we have to give 30602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // up evaluating the entire conditional. 30702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!isa<ConstantInt>(C)) return 0; 3080cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 30902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Otherwise, we know if the comparison is true or false for this element, 31002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // update our state machines. 31102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner bool IsTrueForElt = !cast<ConstantInt>(C)->isZero(); 3120cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 31302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // State machine for single/double/range index comparison. 31402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (IsTrueForElt) { 31502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Update the TrueElement state machine. 31602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (FirstTrueElement == Undefined) 31702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner FirstTrueElement = TrueRangeEnd = i; // First true element. 31802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner else { 31902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Update double-compare state machine. 32002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (SecondTrueElement == Undefined) 32102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner SecondTrueElement = i; 32202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner else 32302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner SecondTrueElement = Overdefined; 3240cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 32502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Update range state machine. 32602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (TrueRangeEnd == (int)i-1) 32702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner TrueRangeEnd = i; 32802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner else 32902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner TrueRangeEnd = Overdefined; 33002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 33102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else { 33202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Update the FalseElement state machine. 33302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (FirstFalseElement == Undefined) 33402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner FirstFalseElement = FalseRangeEnd = i; // First false element. 33502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner else { 33602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Update double-compare state machine. 33702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (SecondFalseElement == Undefined) 33802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner SecondFalseElement = i; 33902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner else 34002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner SecondFalseElement = Overdefined; 3410cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 34202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Update range state machine. 34302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (FalseRangeEnd == (int)i-1) 34402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner FalseRangeEnd = i; 34502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner else 34602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner FalseRangeEnd = Overdefined; 34702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 34802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 3490cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 3500cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 35102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If this element is in range, update our magic bitvector. 35202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (i < 64 && IsTrueForElt) 35302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner MagicBitvector |= 1ULL << i; 3540cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 35502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If all of our states become overdefined, bail out early. Since the 35602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // predicate is expensive, only check it every 8 elements. This is only 35702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // really useful for really huge arrays. 35802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if ((i & 8) == 0 && i >= 64 && SecondTrueElement == Overdefined && 35902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner SecondFalseElement == Overdefined && TrueRangeEnd == Overdefined && 36002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner FalseRangeEnd == Overdefined) 36102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return 0; 36202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 36302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 36402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Now that we've scanned the entire array, emit our new comparison(s). We 36502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // order the state machines in complexity of the generated code. 36602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *Idx = GEP->getOperand(2); 36702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 368d7f5a588907f86ddc83fa29accea54a6c0e78e94Chris Lattner // If the index is larger than the pointer size of the target, truncate the 369d7f5a588907f86ddc83fa29accea54a6c0e78e94Chris Lattner // index down like the GEP would do implicitly. We don't have to do this for 370d7f5a588907f86ddc83fa29accea54a6c0e78e94Chris Lattner // an inbounds GEP because the index can't be out of range. 371d7f5a588907f86ddc83fa29accea54a6c0e78e94Chris Lattner if (!GEP->isInBounds() && 372426c2bf5cdd2173e4a33aea8cb92cf684a724f4bChandler Carruth Idx->getType()->getPrimitiveSizeInBits() > TD->getPointerSizeInBits()) 373ece6c6bb6329748b92403c06ac87f45c43485911Chandler Carruth Idx = Builder->CreateTrunc(Idx, TD->getIntPtrType(Idx->getContext())); 3740cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 37502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If the comparison is only true for one or two elements, emit direct 37602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // comparisons. 37702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (SecondTrueElement != Overdefined) { 37802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // None true -> false. 37902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (FirstTrueElement == Undefined) 38002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return ReplaceInstUsesWith(ICI, ConstantInt::getFalse(GEP->getContext())); 3810cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 38202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *FirstTrueIdx = ConstantInt::get(Idx->getType(), FirstTrueElement); 3830cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 38402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // True for one element -> 'i == 47'. 38502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (SecondTrueElement == Undefined) 38602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_EQ, Idx, FirstTrueIdx); 3870cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 38802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // True for two elements -> 'i == 47 | i == 72'. 38902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *C1 = Builder->CreateICmpEQ(Idx, FirstTrueIdx); 39002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *SecondTrueIdx = ConstantInt::get(Idx->getType(), SecondTrueElement); 39102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *C2 = Builder->CreateICmpEQ(Idx, SecondTrueIdx); 39202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return BinaryOperator::CreateOr(C1, C2); 39302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 39402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 39502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If the comparison is only false for one or two elements, emit direct 39602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // comparisons. 39702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (SecondFalseElement != Overdefined) { 39802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // None false -> true. 39902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (FirstFalseElement == Undefined) 40002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return ReplaceInstUsesWith(ICI, ConstantInt::getTrue(GEP->getContext())); 4010cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 40202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *FirstFalseIdx = ConstantInt::get(Idx->getType(), FirstFalseElement); 40302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 40402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // False for one element -> 'i != 47'. 40502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (SecondFalseElement == Undefined) 40602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_NE, Idx, FirstFalseIdx); 4070cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 40802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // False for two elements -> 'i != 47 & i != 72'. 40902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *C1 = Builder->CreateICmpNE(Idx, FirstFalseIdx); 41002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *SecondFalseIdx = ConstantInt::get(Idx->getType(),SecondFalseElement); 41102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *C2 = Builder->CreateICmpNE(Idx, SecondFalseIdx); 41202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return BinaryOperator::CreateAnd(C1, C2); 41302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 4140cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 41502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If the comparison can be replaced with a range comparison for the elements 41602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // where it is true, emit the range check. 41702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (TrueRangeEnd != Overdefined) { 41802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner assert(TrueRangeEnd != FirstTrueElement && "Should emit single compare"); 4190cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 42002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Generate (i-FirstTrue) <u (TrueRangeEnd-FirstTrue+1). 42102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (FirstTrueElement) { 42202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *Offs = ConstantInt::get(Idx->getType(), -FirstTrueElement); 42302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Idx = Builder->CreateAdd(Idx, Offs); 42402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 4250cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 42602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *End = ConstantInt::get(Idx->getType(), 42702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner TrueRangeEnd-FirstTrueElement+1); 42802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_ULT, Idx, End); 42902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 4300cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 43102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // False range check. 43202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (FalseRangeEnd != Overdefined) { 43302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner assert(FalseRangeEnd != FirstFalseElement && "Should emit single compare"); 43402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Generate (i-FirstFalse) >u (FalseRangeEnd-FirstFalse). 43502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (FirstFalseElement) { 43602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *Offs = ConstantInt::get(Idx->getType(), -FirstFalseElement); 43702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Idx = Builder->CreateAdd(Idx, Offs); 43802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 4390cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 44002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *End = ConstantInt::get(Idx->getType(), 44102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner FalseRangeEnd-FirstFalseElement); 44202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_UGT, Idx, End); 44302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 4440cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 4450cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 44602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If a 32-bit or 64-bit magic bitvector captures the entire comparison state 44702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // of this load, replace it with computation that does: 44802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // ((magic_cst >> i) & 1) != 0 449c8d75c78ec5d30db0d5b75bd8bc85dd65106868fChris Lattner if (ArrayElementCount <= 32 || 450c8d75c78ec5d30db0d5b75bd8bc85dd65106868fChris Lattner (TD && ArrayElementCount <= 64 && TD->isLegalInteger(64))) { 451db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty; 452c8d75c78ec5d30db0d5b75bd8bc85dd65106868fChris Lattner if (ArrayElementCount <= 32) 45302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Ty = Type::getInt32Ty(Init->getContext()); 45402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner else 45502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Ty = Type::getInt64Ty(Init->getContext()); 45602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *V = Builder->CreateIntCast(Idx, Ty, false); 45702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner V = Builder->CreateLShr(ConstantInt::get(Ty, MagicBitvector), V); 45802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner V = Builder->CreateAnd(ConstantInt::get(Ty, 1), V); 45902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_NE, V, ConstantInt::get(Ty, 0)); 46002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 4610cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 46202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return 0; 46302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner} 46402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 46502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 46602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// EvaluateGEPOffsetExpression - Return a value that can be used to compare 46702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// the *offset* implied by a GEP to zero. For example, if we have &A[i], we 46802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// want to return 'i' for "icmp ne i, 0". Note that, in general, indices can 46902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// be complex, and scales are involved. The above expression would also be 47002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// legal to codegen as "icmp ne (i*4), 0" (assuming A is a pointer to i32). 47102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// This later form is less amenable to optimization though, and we are allowed 47202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// to generate the first by knowing that pointer arithmetic doesn't overflow. 47302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// 47402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// If we can't emit an optimized form for this expression, this returns null. 4750cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach/// 476107ffd58f70651cc928416f6aaf267accc992c23Eli Friedmanstatic Value *EvaluateGEPOffsetExpression(User *GEP, InstCombiner &IC) { 4773574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow DataLayout &TD = *IC.getDataLayout(); 47802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner gep_type_iterator GTI = gep_type_begin(GEP); 4790cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 48002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Check to see if this gep only has a single variable index. If so, and if 48102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // any constant indices are a multiple of its scale, then we can compute this 48202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // in terms of the scale of the variable index. For example, if the GEP 48302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // implies an offset of "12 + i*4", then we can codegen this as "3 + i", 48402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // because the expression will cross zero at the same point. 48502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner unsigned i, e = GEP->getNumOperands(); 48602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner int64_t Offset = 0; 48702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner for (i = 1; i != e; ++i, ++GTI) { 48802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(GEP->getOperand(i))) { 48902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Compute the aggregate offset of constant indices. 49002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (CI->isZero()) continue; 4910cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 49202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Handle a struct index, which adds its field offset to the pointer. 493db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (StructType *STy = dyn_cast<StructType>(*GTI)) { 49402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Offset += TD.getStructLayout(STy)->getElementOffset(CI->getZExtValue()); 49502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else { 49602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner uint64_t Size = TD.getTypeAllocSize(GTI.getIndexedType()); 49702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Offset += Size*CI->getSExtValue(); 49802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 49902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else { 50002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Found our variable index. 50102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 50202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 50302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 5040cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 50502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If there are no variable indices, we must have a constant offset, just 50602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // evaluate it the general way. 50702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (i == e) return 0; 5080cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 50902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *VariableIdx = GEP->getOperand(i); 51002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Determine the scale factor of the variable element. For example, this is 51102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // 4 if the variable index is into an array of i32. 51202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner uint64_t VariableScale = TD.getTypeAllocSize(GTI.getIndexedType()); 5130cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 51402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Verify that there are no other variable indices. If so, emit the hard way. 51502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner for (++i, ++GTI; i != e; ++i, ++GTI) { 51602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt *CI = dyn_cast<ConstantInt>(GEP->getOperand(i)); 51702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!CI) return 0; 5180cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 51902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Compute the aggregate offset of constant indices. 52002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (CI->isZero()) continue; 5210cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 52202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Handle a struct index, which adds its field offset to the pointer. 523db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (StructType *STy = dyn_cast<StructType>(*GTI)) { 52402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Offset += TD.getStructLayout(STy)->getElementOffset(CI->getZExtValue()); 52502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else { 52602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner uint64_t Size = TD.getTypeAllocSize(GTI.getIndexedType()); 52702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Offset += Size*CI->getSExtValue(); 52802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 52902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 5300cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 53102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Okay, we know we have a single variable index, which must be a 53202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // pointer/array/vector index. If there is no offset, life is simple, return 53302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // the index. 534426c2bf5cdd2173e4a33aea8cb92cf684a724f4bChandler Carruth unsigned IntPtrWidth = TD.getPointerSizeInBits(); 53502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Offset == 0) { 53602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Cast to intptrty in case a truncation occurs. If an extension is needed, 53702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // we don't need to bother extending: the extension won't affect where the 53802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // computation crosses zero. 539107ffd58f70651cc928416f6aaf267accc992c23Eli Friedman if (VariableIdx->getType()->getPrimitiveSizeInBits() > IntPtrWidth) { 540ece6c6bb6329748b92403c06ac87f45c43485911Chandler Carruth Type *IntPtrTy = TD.getIntPtrType(VariableIdx->getContext()); 541107ffd58f70651cc928416f6aaf267accc992c23Eli Friedman VariableIdx = IC.Builder->CreateTrunc(VariableIdx, IntPtrTy); 542107ffd58f70651cc928416f6aaf267accc992c23Eli Friedman } 54302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return VariableIdx; 54402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 5450cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 54602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Otherwise, there is an index. The computation we will do will be modulo 54702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // the pointer size, so get it. 54802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner uint64_t PtrSizeMask = ~0ULL >> (64-IntPtrWidth); 5490cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 55002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Offset &= PtrSizeMask; 55102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner VariableScale &= PtrSizeMask; 5520cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 55302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // To do this transformation, any constant index must be a multiple of the 55402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // variable scale factor. For example, we can evaluate "12 + 4*i" as "3 + i", 55502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // but we can't evaluate "10 + 3*i" in terms of i. Check that the offset is a 55602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // multiple of the variable scale. 55702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner int64_t NewOffs = Offset / (int64_t)VariableScale; 55802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Offset != NewOffs*(int64_t)VariableScale) 55902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return 0; 5600cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 56102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Okay, we can do this evaluation. Start by converting the index to intptr. 562ece6c6bb6329748b92403c06ac87f45c43485911Chandler Carruth Type *IntPtrTy = TD.getIntPtrType(VariableIdx->getContext()); 56302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (VariableIdx->getType() != IntPtrTy) 564107ffd58f70651cc928416f6aaf267accc992c23Eli Friedman VariableIdx = IC.Builder->CreateIntCast(VariableIdx, IntPtrTy, 565107ffd58f70651cc928416f6aaf267accc992c23Eli Friedman true /*Signed*/); 56602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant *OffsetVal = ConstantInt::get(IntPtrTy, NewOffs); 567107ffd58f70651cc928416f6aaf267accc992c23Eli Friedman return IC.Builder->CreateAdd(VariableIdx, OffsetVal, "offset"); 56802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner} 56902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 57002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// FoldGEPICmp - Fold comparisons between a GEP instruction and something 57102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// else. At this point we know that the GEP is on the LHS of the comparison. 57202446fc99abb06d3117d65c0b1f5fba4f906db2eChris LattnerInstruction *InstCombiner::FoldGEPICmp(GEPOperator *GEPLHS, Value *RHS, 57302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ICmpInst::Predicate Cond, 57402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Instruction &I) { 5758294eb5599092e3d8e95c9c4d323ffa139499acfBenjamin Kramer // Don't transform signed compares of GEPs into index compares. Even if the 5768294eb5599092e3d8e95c9c4d323ffa139499acfBenjamin Kramer // GEP is inbounds, the final add of the base pointer can have signed overflow 5778294eb5599092e3d8e95c9c4d323ffa139499acfBenjamin Kramer // and would change the result of the icmp. 5788294eb5599092e3d8e95c9c4d323ffa139499acfBenjamin Kramer // e.g. "&foo[0] <s &foo[1]" can't be folded to "true" because "foo" could be 579a42d5c425251b6f30d46744d494817f788c408beBenjamin Kramer // the maximum signed value for the pointer type. 5808294eb5599092e3d8e95c9c4d323ffa139499acfBenjamin Kramer if (ICmpInst::isSigned(Cond)) 5818294eb5599092e3d8e95c9c4d323ffa139499acfBenjamin Kramer return 0; 5828294eb5599092e3d8e95c9c4d323ffa139499acfBenjamin Kramer 58302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Look through bitcasts. 58402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (BitCastInst *BCI = dyn_cast<BitCastInst>(RHS)) 58502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner RHS = BCI->getOperand(0); 58602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 58702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *PtrBase = GEPLHS->getOperand(0); 58802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (TD && PtrBase == RHS && GEPLHS->isInBounds()) { 58902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // ((gep Ptr, OFFSET) cmp Ptr) ---> (OFFSET cmp 0). 59002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // This transformation (ignoring the base and scales) is valid because we 59102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // know pointers can't overflow since the gep is inbounds. See if we can 59202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // output an optimized form. 593107ffd58f70651cc928416f6aaf267accc992c23Eli Friedman Value *Offset = EvaluateGEPOffsetExpression(GEPLHS, *this); 5940cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 59502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If not, synthesize the offset the hard way. 59602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Offset == 0) 59702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Offset = EmitGEPOffset(GEPLHS); 59802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::getSignedPredicate(Cond), Offset, 59902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant::getNullValue(Offset->getType())); 60002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else if (GEPOperator *GEPRHS = dyn_cast<GEPOperator>(RHS)) { 60102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If the base pointers are different, but the indices are the same, just 60202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // compare the base pointer. 60302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (PtrBase != GEPRHS->getOperand(0)) { 60402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner bool IndicesTheSame = GEPLHS->getNumOperands()==GEPRHS->getNumOperands(); 60502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner IndicesTheSame &= GEPLHS->getOperand(0)->getType() == 60602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner GEPRHS->getOperand(0)->getType(); 60702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (IndicesTheSame) 60802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner for (unsigned i = 1, e = GEPLHS->getNumOperands(); i != e; ++i) 60902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (GEPLHS->getOperand(i) != GEPRHS->getOperand(i)) { 61002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner IndicesTheSame = false; 61102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 61202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 61302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 61402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If all indices are the same, just compare the base pointers. 61502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (IndicesTheSame) 61602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::getSignedPredicate(Cond), 61702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner GEPLHS->getOperand(0), GEPRHS->getOperand(0)); 61802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 6199bb40853eeef1d11b626bdc58e00121e35187866Benjamin Kramer // If we're comparing GEPs with two base pointers that only differ in type 6209bb40853eeef1d11b626bdc58e00121e35187866Benjamin Kramer // and both GEPs have only constant indices or just one use, then fold 6219bb40853eeef1d11b626bdc58e00121e35187866Benjamin Kramer // the compare with the adjusted indices. 6226ad48f413743366c91b088a8e39d7f882200429dBenjamin Kramer if (TD && GEPLHS->isInBounds() && GEPRHS->isInBounds() && 6239bb40853eeef1d11b626bdc58e00121e35187866Benjamin Kramer (GEPLHS->hasAllConstantIndices() || GEPLHS->hasOneUse()) && 6249bb40853eeef1d11b626bdc58e00121e35187866Benjamin Kramer (GEPRHS->hasAllConstantIndices() || GEPRHS->hasOneUse()) && 6259bb40853eeef1d11b626bdc58e00121e35187866Benjamin Kramer PtrBase->stripPointerCasts() == 6269bb40853eeef1d11b626bdc58e00121e35187866Benjamin Kramer GEPRHS->getOperand(0)->stripPointerCasts()) { 6279bb40853eeef1d11b626bdc58e00121e35187866Benjamin Kramer Value *Cmp = Builder->CreateICmp(ICmpInst::getSignedPredicate(Cond), 6289bb40853eeef1d11b626bdc58e00121e35187866Benjamin Kramer EmitGEPOffset(GEPLHS), 6299bb40853eeef1d11b626bdc58e00121e35187866Benjamin Kramer EmitGEPOffset(GEPRHS)); 6309bb40853eeef1d11b626bdc58e00121e35187866Benjamin Kramer return ReplaceInstUsesWith(I, Cmp); 6319bb40853eeef1d11b626bdc58e00121e35187866Benjamin Kramer } 6329bb40853eeef1d11b626bdc58e00121e35187866Benjamin Kramer 63302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Otherwise, the base pointers are different and the indices are 63402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // different, bail out. 63502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return 0; 63602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 63702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 63802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If one of the GEPs has all zero indices, recurse. 63902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner bool AllZeros = true; 64002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner for (unsigned i = 1, e = GEPLHS->getNumOperands(); i != e; ++i) 64102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!isa<Constant>(GEPLHS->getOperand(i)) || 64202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner !cast<Constant>(GEPLHS->getOperand(i))->isNullValue()) { 64302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner AllZeros = false; 64402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 64502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 64602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (AllZeros) 64702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return FoldGEPICmp(GEPRHS, GEPLHS->getOperand(0), 64802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ICmpInst::getSwappedPredicate(Cond), I); 64902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 65002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If the other GEP has all zero indices, recurse. 65102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner AllZeros = true; 65202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner for (unsigned i = 1, e = GEPRHS->getNumOperands(); i != e; ++i) 65302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!isa<Constant>(GEPRHS->getOperand(i)) || 65402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner !cast<Constant>(GEPRHS->getOperand(i))->isNullValue()) { 65502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner AllZeros = false; 65602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 65702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 65802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (AllZeros) 65902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return FoldGEPICmp(GEPLHS, GEPRHS->getOperand(0), Cond, I); 66002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 66167f071e69795dca1151cdb8d57d222b6f041d748Stuart Hastings bool GEPsInBounds = GEPLHS->isInBounds() && GEPRHS->isInBounds(); 66202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (GEPLHS->getNumOperands() == GEPRHS->getNumOperands()) { 66302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If the GEPs only differ by one index, compare it. 66402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner unsigned NumDifferences = 0; // Keep track of # differences. 66502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner unsigned DiffOperand = 0; // The operand that differs. 66602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner for (unsigned i = 1, e = GEPRHS->getNumOperands(); i != e; ++i) 66702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (GEPLHS->getOperand(i) != GEPRHS->getOperand(i)) { 66802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (GEPLHS->getOperand(i)->getType()->getPrimitiveSizeInBits() != 66902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner GEPRHS->getOperand(i)->getType()->getPrimitiveSizeInBits()) { 67002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Irreconcilable differences. 67102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner NumDifferences = 2; 67202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 67302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else { 67402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (NumDifferences++) break; 67502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner DiffOperand = i; 67602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 67702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 67802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 67902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (NumDifferences == 0) // SAME GEP? 68002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return ReplaceInstUsesWith(I, // No comparison is needed here. 68102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt::get(Type::getInt1Ty(I.getContext()), 68202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ICmpInst::isTrueWhenEqual(Cond))); 68302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 68467f071e69795dca1151cdb8d57d222b6f041d748Stuart Hastings else if (NumDifferences == 1 && GEPsInBounds) { 68502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *LHSV = GEPLHS->getOperand(DiffOperand); 68602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *RHSV = GEPRHS->getOperand(DiffOperand); 68702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Make sure we do a signed comparison here. 68802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::getSignedPredicate(Cond), LHSV, RHSV); 68902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 69002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 69102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 69202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Only lower this if the icmp is the only user of the GEP or if we expect 69302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // the result to fold to a constant! 69402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (TD && 69567f071e69795dca1151cdb8d57d222b6f041d748Stuart Hastings GEPsInBounds && 69602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner (isa<ConstantExpr>(GEPLHS) || GEPLHS->hasOneUse()) && 69702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner (isa<ConstantExpr>(GEPRHS) || GEPRHS->hasOneUse())) { 69802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // ((gep Ptr, OFFSET1) cmp (gep Ptr, OFFSET2) ---> (OFFSET1 cmp OFFSET2) 69902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *L = EmitGEPOffset(GEPLHS); 70002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *R = EmitGEPOffset(GEPRHS); 70102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::getSignedPredicate(Cond), L, R); 70202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 70302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 70402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return 0; 70502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner} 70602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 70702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// FoldICmpAddOpCst - Fold "icmp pred (X+CI), X". 70802446fc99abb06d3117d65c0b1f5fba4f906db2eChris LattnerInstruction *InstCombiner::FoldICmpAddOpCst(ICmpInst &ICI, 70902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *X, ConstantInt *CI, 71002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ICmpInst::Predicate Pred, 71102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *TheAdd) { 71202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If we have X+0, exit early (simplifying logic below) and let it get folded 71302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // elsewhere. icmp X+0, X -> icmp X, X 71402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (CI->isZero()) { 71502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner bool isTrue = ICmpInst::isTrueWhenEqual(Pred); 71602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return ReplaceInstUsesWith(ICI, ConstantInt::get(ICI.getType(), isTrue)); 71702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 7180cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 71902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (X+4) == X -> false. 72002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Pred == ICmpInst::ICMP_EQ) 72102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return ReplaceInstUsesWith(ICI, ConstantInt::getFalse(X->getContext())); 72202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 72302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (X+4) != X -> true. 72402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Pred == ICmpInst::ICMP_NE) 72502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return ReplaceInstUsesWith(ICI, ConstantInt::getTrue(X->getContext())); 72602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 72702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // From this point on, we know that (X+C <= X) --> (X+C < X) because C != 0, 7287a2bdde0a0eebcd2125055e0eacaca040f0b766cChris Lattner // so the values can never be equal. Similarly for all other "or equals" 72902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // operators. 7300cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 7319aa1e246dd15dfc73a2f6f44766ca97ba9573c9dChris Lattner // (X+1) <u X --> X >u (MAXUINT-1) --> X == 255 73202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (X+2) <u X --> X >u (MAXUINT-2) --> X > 253 73302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (X+MAXUINT) <u X --> X >u (MAXUINT-MAXUINT) --> X != 0 73402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Pred == ICmpInst::ICMP_ULT || Pred == ICmpInst::ICMP_ULE) { 7350cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach Value *R = 7369aa1e246dd15dfc73a2f6f44766ca97ba9573c9dChris Lattner ConstantExpr::getSub(ConstantInt::getAllOnesValue(CI->getType()), CI); 73702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_UGT, X, R); 73802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 7390cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 74002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (X+1) >u X --> X <u (0-1) --> X != 255 74102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (X+2) >u X --> X <u (0-2) --> X <u 254 74202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (X+MAXUINT) >u X --> X <u (0-MAXUINT) --> X <u 1 --> X == 0 743a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands if (Pred == ICmpInst::ICMP_UGT || Pred == ICmpInst::ICMP_UGE) 74402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_ULT, X, ConstantExpr::getNeg(CI)); 7450cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 74602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner unsigned BitWidth = CI->getType()->getPrimitiveSizeInBits(); 74702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt *SMax = ConstantInt::get(X->getContext(), 74802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner APInt::getSignedMaxValue(BitWidth)); 74902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 75002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (X+ 1) <s X --> X >s (MAXSINT-1) --> X == 127 75102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (X+ 2) <s X --> X >s (MAXSINT-2) --> X >s 125 75202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (X+MAXSINT) <s X --> X >s (MAXSINT-MAXSINT) --> X >s 0 75302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (X+MINSINT) <s X --> X >s (MAXSINT-MINSINT) --> X >s -1 75402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (X+ -2) <s X --> X >s (MAXSINT- -2) --> X >s 126 75502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (X+ -1) <s X --> X >s (MAXSINT- -1) --> X != 127 756a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands if (Pred == ICmpInst::ICMP_SLT || Pred == ICmpInst::ICMP_SLE) 75702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_SGT, X, ConstantExpr::getSub(SMax, CI)); 7580cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 75902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (X+ 1) >s X --> X <s (MAXSINT-(1-1)) --> X != 127 76002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (X+ 2) >s X --> X <s (MAXSINT-(2-1)) --> X <s 126 76102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (X+MAXSINT) >s X --> X <s (MAXSINT-(MAXSINT-1)) --> X <s 1 76202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (X+MINSINT) >s X --> X <s (MAXSINT-(MINSINT-1)) --> X <s -2 76302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (X+ -2) >s X --> X <s (MAXSINT-(-2-1)) --> X <s -126 76402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (X+ -1) >s X --> X <s (MAXSINT-(-1-1)) --> X == -128 7650cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 76602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner assert(Pred == ICmpInst::ICMP_SGT || Pred == ICmpInst::ICMP_SGE); 76702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant *C = ConstantInt::get(X->getContext(), CI->getValue()-1); 76802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_SLT, X, ConstantExpr::getSub(SMax, C)); 76902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner} 77002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 77102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// FoldICmpDivCst - Fold "icmp pred, ([su]div X, DivRHS), CmpRHS" where DivRHS 77202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// and CmpRHS are both known to be integer constants. 77302446fc99abb06d3117d65c0b1f5fba4f906db2eChris LattnerInstruction *InstCombiner::FoldICmpDivCst(ICmpInst &ICI, BinaryOperator *DivI, 77402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt *DivRHS) { 77502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt *CmpRHS = cast<ConstantInt>(ICI.getOperand(1)); 77602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner const APInt &CmpRHSV = CmpRHS->getValue(); 7770cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 7780cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // FIXME: If the operand types don't match the type of the divide 77902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // then don't attempt this transform. The code below doesn't have the 78002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // logic to deal with a signed divide and an unsigned compare (and 7810cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // vice versa). This is because (x /s C1) <s C2 produces different 78202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // results than (x /s C1) <u C2 or (x /u C1) <s C2 or even 7830cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // (x /u C1) <u C2. Simply casting the operands and result won't 7840cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // work. :( The if statement below tests that condition and bails 785b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner // if it finds it. 78602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner bool DivIsSigned = DivI->getOpcode() == Instruction::SDiv; 78702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!ICI.isEquality() && DivIsSigned != ICI.isSigned()) 78802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return 0; 78902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (DivRHS->isZero()) 79002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return 0; // The ProdOV computation fails on divide by zero. 79102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (DivIsSigned && DivRHS->isAllOnesValue()) 79202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return 0; // The overflow computation also screws up here 793bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner if (DivRHS->isOne()) { 794bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner // This eliminates some funny cases with INT_MIN. 795bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner ICI.setOperand(0, DivI->getOperand(0)); // X/1 == X. 796bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner return &ICI; 797bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner } 79802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 79902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Compute Prod = CI * DivRHS. We are essentially solving an equation 8000cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // of form X/C1=C2. We solve for X by multiplying C1 (DivRHS) and 8010cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // C2 (CI). By solving for X we can turn this into a range check 8020cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // instead of computing a divide. 80302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant *Prod = ConstantExpr::getMul(CmpRHS, DivRHS); 80402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 80502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Determine if the product overflows by seeing if the product is 80602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // not equal to the divide. Make sure we do the same kind of divide 8070cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // as in the LHS instruction that we're folding. 80802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner bool ProdOV = (DivIsSigned ? ConstantExpr::getSDiv(Prod, DivRHS) : 80902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantExpr::getUDiv(Prod, DivRHS)) != CmpRHS; 81002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 81102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Get the ICmp opcode 81202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ICmpInst::Predicate Pred = ICI.getPredicate(); 81302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 814b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner /// If the division is known to be exact, then there is no remainder from the 815b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner /// divide, so the covered range size is unit, otherwise it is the divisor. 816b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner ConstantInt *RangeSize = DivI->isExact() ? getOne(Prod) : DivRHS; 8170cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 81802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Figure out the interval that is being checked. For example, a comparison 8190cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // like "X /u 5 == 0" is really checking that X is in the interval [0, 5). 82002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Compute this interval based on the constants involved and the signedness of 82102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // the compare/divide. This computes a half-open interval, keeping track of 82202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // whether either value in the interval overflows. After analysis each 82302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // overflow variable is set to 0 if it's corresponding bound variable is valid 82402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // -1 if overflowed off the bottom end, or +1 if overflowed off the top end. 82502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner int LoOverflow = 0, HiOverflow = 0; 82602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant *LoBound = 0, *HiBound = 0; 827b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner 82802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!DivIsSigned) { // udiv 82902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // e.g. X/5 op 3 --> [15, 20) 83002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner LoBound = Prod; 83102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner HiOverflow = LoOverflow = ProdOV; 832b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner if (!HiOverflow) { 833b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner // If this is not an exact divide, then many values in the range collapse 834b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner // to the same result value. 835b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner HiOverflow = AddWithOverflow(HiBound, LoBound, RangeSize, false); 836b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner } 8370cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 83802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else if (DivRHS->getValue().isStrictlyPositive()) { // Divisor is > 0. 83902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (CmpRHSV == 0) { // (X / pos) op 0 84002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Can't overflow. e.g. X/2 op 0 --> [-1, 2) 841b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner LoBound = ConstantExpr::getNeg(SubOne(RangeSize)); 842b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner HiBound = RangeSize; 84302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else if (CmpRHSV.isStrictlyPositive()) { // (X / pos) op pos 84402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner LoBound = Prod; // e.g. X/5 op 3 --> [15, 20) 84502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner HiOverflow = LoOverflow = ProdOV; 84602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!HiOverflow) 847b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner HiOverflow = AddWithOverflow(HiBound, Prod, RangeSize, true); 84802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else { // (X / pos) op neg 84902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // e.g. X/5 op -3 --> [-15-4, -15+1) --> [-19, -14) 85002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner HiBound = AddOne(Prod); 85102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner LoOverflow = HiOverflow = ProdOV ? -1 : 0; 85202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!LoOverflow) { 853b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner ConstantInt *DivNeg =cast<ConstantInt>(ConstantExpr::getNeg(RangeSize)); 85402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner LoOverflow = AddWithOverflow(LoBound, HiBound, DivNeg, true) ? -1 : 0; 855b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner } 85602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 857c73b24db5f6226ed44ebc44ce1c25bb357206623Chris Lattner } else if (DivRHS->isNegative()) { // Divisor is < 0. 858b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner if (DivI->isExact()) 859b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner RangeSize = cast<ConstantInt>(ConstantExpr::getNeg(RangeSize)); 86002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (CmpRHSV == 0) { // (X / neg) op 0 86102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // e.g. X/-5 op 0 --> [-4, 5) 862b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner LoBound = AddOne(RangeSize); 863b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner HiBound = cast<ConstantInt>(ConstantExpr::getNeg(RangeSize)); 86402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (HiBound == DivRHS) { // -INTMIN = INTMIN 86502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner HiOverflow = 1; // [INTMIN+1, overflow) 86602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner HiBound = 0; // e.g. X/INTMIN = 0 --> X > INTMIN 86702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 86802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else if (CmpRHSV.isStrictlyPositive()) { // (X / neg) op pos 86902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // e.g. X/-5 op 3 --> [-19, -14) 87002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner HiBound = AddOne(Prod); 87102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner HiOverflow = LoOverflow = ProdOV ? -1 : 0; 87202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!LoOverflow) 873b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner LoOverflow = AddWithOverflow(LoBound, HiBound, RangeSize, true) ? -1:0; 87402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else { // (X / neg) op neg 87502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner LoBound = Prod; // e.g. X/-5 op -3 --> [15, 20) 87602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner LoOverflow = HiOverflow = ProdOV; 87702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!HiOverflow) 878b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner HiOverflow = SubWithOverflow(HiBound, Prod, RangeSize, true); 87902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 8800cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 88102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Dividing by a negative swaps the condition. LT <-> GT 88202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Pred = ICmpInst::getSwappedPredicate(Pred); 88302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 88402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 88502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *X = DivI->getOperand(0); 88602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner switch (Pred) { 88702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner default: llvm_unreachable("Unhandled icmp opcode!"); 88802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_EQ: 88902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (LoOverflow && HiOverflow) 89002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return ReplaceInstUsesWith(ICI, ConstantInt::getFalse(ICI.getContext())); 891f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner if (HiOverflow) 89202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(DivIsSigned ? ICmpInst::ICMP_SGE : 89302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ICmpInst::ICMP_UGE, X, LoBound); 894f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner if (LoOverflow) 89502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(DivIsSigned ? ICmpInst::ICMP_SLT : 89602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ICmpInst::ICMP_ULT, X, HiBound); 897b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner return ReplaceInstUsesWith(ICI, InsertRangeTest(X, LoBound, HiBound, 898b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner DivIsSigned, true)); 89902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_NE: 90002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (LoOverflow && HiOverflow) 90102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return ReplaceInstUsesWith(ICI, ConstantInt::getTrue(ICI.getContext())); 902f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner if (HiOverflow) 90302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(DivIsSigned ? ICmpInst::ICMP_SLT : 90402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ICmpInst::ICMP_ULT, X, LoBound); 905f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner if (LoOverflow) 90602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(DivIsSigned ? ICmpInst::ICMP_SGE : 90702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ICmpInst::ICMP_UGE, X, HiBound); 908f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return ReplaceInstUsesWith(ICI, InsertRangeTest(X, LoBound, HiBound, 909f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner DivIsSigned, false)); 91002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_ULT: 91102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_SLT: 91202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (LoOverflow == +1) // Low bound is greater than input range. 91302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return ReplaceInstUsesWith(ICI, ConstantInt::getTrue(ICI.getContext())); 91402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (LoOverflow == -1) // Low bound is less than input range. 91502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return ReplaceInstUsesWith(ICI, ConstantInt::getFalse(ICI.getContext())); 91602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(Pred, X, LoBound); 91702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_UGT: 91802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_SGT: 91902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (HiOverflow == +1) // High bound greater than input range. 92002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return ReplaceInstUsesWith(ICI, ConstantInt::getFalse(ICI.getContext())); 921b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner if (HiOverflow == -1) // High bound less than input range. 92202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return ReplaceInstUsesWith(ICI, ConstantInt::getTrue(ICI.getContext())); 92302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Pred == ICmpInst::ICMP_UGT) 92402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_UGE, X, HiBound); 925b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner return new ICmpInst(ICmpInst::ICMP_SGE, X, HiBound); 92602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 92702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner} 92802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 92974542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner/// FoldICmpShrCst - Handle "icmp(([al]shr X, cst1), cst2)". 93074542aa5001fb6ff3d7d0958b5c391cde63df1caChris LattnerInstruction *InstCombiner::FoldICmpShrCst(ICmpInst &ICI, BinaryOperator *Shr, 93174542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner ConstantInt *ShAmt) { 93274542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner const APInt &CmpRHSV = cast<ConstantInt>(ICI.getOperand(1))->getValue(); 9330cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 93474542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner // Check that the shift amount is in range. If not, don't perform 93574542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner // undefined shifts. When the shift is visited it will be 93674542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner // simplified. 93774542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner uint32_t TypeBits = CmpRHSV.getBitWidth(); 93874542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner uint32_t ShAmtVal = (uint32_t)ShAmt->getLimitedValue(TypeBits); 939bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner if (ShAmtVal >= TypeBits || ShAmtVal == 0) 94074542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner return 0; 9410cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 942bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner if (!ICI.isEquality()) { 943bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner // If we have an unsigned comparison and an ashr, we can't simplify this. 944bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner // Similarly for signed comparisons with lshr. 945bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner if (ICI.isSigned() != (Shr->getOpcode() == Instruction::AShr)) 946bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner return 0; 9470cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 948a831a9b972f1b4fa4f3457acf303abbfc71c1edeEli Friedman // Otherwise, all lshr and most exact ashr's are equivalent to a udiv/sdiv 949a831a9b972f1b4fa4f3457acf303abbfc71c1edeEli Friedman // by a power of 2. Since we already have logic to simplify these, 950a831a9b972f1b4fa4f3457acf303abbfc71c1edeEli Friedman // transform to div and then simplify the resultant comparison. 951bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner if (Shr->getOpcode() == Instruction::AShr && 952a831a9b972f1b4fa4f3457acf303abbfc71c1edeEli Friedman (!Shr->isExact() || ShAmtVal == TypeBits - 1)) 953bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner return 0; 9540cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 955bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner // Revisit the shift (to delete it). 956bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner Worklist.Add(Shr); 9570cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 958bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner Constant *DivCst = 959bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner ConstantInt::get(Shr->getType(), APInt::getOneBitSet(TypeBits, ShAmtVal)); 9600cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 961bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner Value *Tmp = 962bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner Shr->getOpcode() == Instruction::AShr ? 963bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner Builder->CreateSDiv(Shr->getOperand(0), DivCst, "", Shr->isExact()) : 964bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner Builder->CreateUDiv(Shr->getOperand(0), DivCst, "", Shr->isExact()); 9650cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 966bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner ICI.setOperand(0, Tmp); 9670cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 968bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner // If the builder folded the binop, just return it. 969bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner BinaryOperator *TheDiv = dyn_cast<BinaryOperator>(Tmp); 970bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner if (TheDiv == 0) 971bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner return &ICI; 9720cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 973bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner // Otherwise, fold this div/compare. 974bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner assert(TheDiv->getOpcode() == Instruction::SDiv || 975bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner TheDiv->getOpcode() == Instruction::UDiv); 9760cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 977bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner Instruction *Res = FoldICmpDivCst(ICI, TheDiv, cast<ConstantInt>(DivCst)); 978bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner assert(Res && "This div/cst should have folded!"); 979bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner return Res; 980bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner } 9810cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 9820cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 98374542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner // If we are comparing against bits always shifted out, the 98474542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner // comparison cannot succeed. 98574542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner APInt Comp = CmpRHSV << ShAmtVal; 98674542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner ConstantInt *ShiftedCmpRHS = ConstantInt::get(ICI.getContext(), Comp); 98774542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner if (Shr->getOpcode() == Instruction::LShr) 98874542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner Comp = Comp.lshr(ShAmtVal); 98974542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner else 99074542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner Comp = Comp.ashr(ShAmtVal); 9910cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 99274542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner if (Comp != CmpRHSV) { // Comparing against a bit that we know is zero. 99374542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner bool IsICMP_NE = ICI.getPredicate() == ICmpInst::ICMP_NE; 99474542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner Constant *Cst = ConstantInt::get(Type::getInt1Ty(ICI.getContext()), 99574542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner IsICMP_NE); 99674542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner return ReplaceInstUsesWith(ICI, Cst); 99774542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner } 9980cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 99974542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner // Otherwise, check to see if the bits shifted out are known to be zero. 100074542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner // If so, we can compare against the unshifted value: 100174542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner // (X & 4) >> 1 == 2 --> (X & 4) == 4. 1002e5116f840eedbc3cffa31adc683b4e37d53f2c7aChris Lattner if (Shr->hasOneUse() && Shr->isExact()) 100374542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner return new ICmpInst(ICI.getPredicate(), Shr->getOperand(0), ShiftedCmpRHS); 10040cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 100574542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner if (Shr->hasOneUse()) { 100674542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner // Otherwise strength reduce the shift into an and. 100774542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner APInt Val(APInt::getHighBitsSet(TypeBits, TypeBits - ShAmtVal)); 100874542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner Constant *Mask = ConstantInt::get(ICI.getContext(), Val); 10090cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 101074542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner Value *And = Builder->CreateAnd(Shr->getOperand(0), 101174542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner Mask, Shr->getName()+".mask"); 101274542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner return new ICmpInst(ICI.getPredicate(), And, ShiftedCmpRHS); 101374542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner } 101474542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner return 0; 101574542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner} 101674542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner 101702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 101802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// visitICmpInstWithInstAndIntCst - Handle "icmp (instr, intcst)". 101902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// 102002446fc99abb06d3117d65c0b1f5fba4f906db2eChris LattnerInstruction *InstCombiner::visitICmpInstWithInstAndIntCst(ICmpInst &ICI, 102102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Instruction *LHSI, 102202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt *RHS) { 102302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner const APInt &RHSV = RHS->getValue(); 10240cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 102502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner switch (LHSI->getOpcode()) { 102602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::Trunc: 102702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ICI.isEquality() && LHSI->hasOneUse()) { 102802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Simplify icmp eq (trunc x to i8), 42 -> icmp eq x, 42|highbits if all 102902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // of the high bits truncated out of x are known. 103002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner unsigned DstBits = LHSI->getType()->getPrimitiveSizeInBits(), 103102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner SrcBits = LHSI->getOperand(0)->getType()->getPrimitiveSizeInBits(); 103202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner APInt KnownZero(SrcBits, 0), KnownOne(SrcBits, 0); 103326c8dcc692fb2addd475446cfff24d6a4e958bcaRafael Espindola ComputeMaskedBits(LHSI->getOperand(0), KnownZero, KnownOne); 10340cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 103502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If all the high bits are known, we can do this xform. 103602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if ((KnownZero|KnownOne).countLeadingOnes() >= SrcBits-DstBits) { 103702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Pull in the high bits from known-ones set. 103840f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad APInt NewRHS = RHS->getValue().zext(SrcBits); 10395b6dfee28e86529030cabdc356e00b4d70747d65Eli Friedman NewRHS |= KnownOne & APInt::getHighBitsSet(SrcBits, SrcBits-DstBits); 104002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICI.getPredicate(), LHSI->getOperand(0), 104102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt::get(ICI.getContext(), NewRHS)); 104202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 104302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 104402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 10450cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 104602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::Xor: // (icmp pred (xor X, XorCST), CI) 104702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ConstantInt *XorCST = dyn_cast<ConstantInt>(LHSI->getOperand(1))) { 104802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If this is a comparison that tests the signbit (X < 0) or (x > -1), 104902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // fold the xor. 105002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if ((ICI.getPredicate() == ICmpInst::ICMP_SLT && RHSV == 0) || 105102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner (ICI.getPredicate() == ICmpInst::ICMP_SGT && RHSV.isAllOnesValue())) { 105202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *CompareVal = LHSI->getOperand(0); 10530cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 105402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If the sign bit of the XorCST is not set, there is no change to 105502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // the operation, just stop using the Xor. 1056c73b24db5f6226ed44ebc44ce1c25bb357206623Chris Lattner if (!XorCST->isNegative()) { 105702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ICI.setOperand(0, CompareVal); 105802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Worklist.Add(LHSI); 105902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return &ICI; 106002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 10610cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 106202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Was the old condition true if the operand is positive? 106302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner bool isTrueIfPositive = ICI.getPredicate() == ICmpInst::ICMP_SGT; 10640cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 106502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If so, the new one isn't. 106602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner isTrueIfPositive ^= true; 10670cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 106802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (isTrueIfPositive) 106902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_SGT, CompareVal, 107002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner SubOne(RHS)); 107102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner else 107202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_SLT, CompareVal, 107302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner AddOne(RHS)); 107402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 107502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 107602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (LHSI->hasOneUse()) { 107702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (icmp u/s (xor A SignBit), C) -> (icmp s/u A, (xor C SignBit)) 107802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!ICI.isEquality() && XorCST->getValue().isSignBit()) { 107902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner const APInt &SignBit = XorCST->getValue(); 108002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ICmpInst::Predicate Pred = ICI.isSigned() 108102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ? ICI.getUnsignedPredicate() 108202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner : ICI.getSignedPredicate(); 108302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(Pred, LHSI->getOperand(0), 108402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt::get(ICI.getContext(), 108502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner RHSV ^ SignBit)); 108602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 108702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 108802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (icmp u/s (xor A ~SignBit), C) -> (icmp s/u (xor C ~SignBit), A) 1089c73b24db5f6226ed44ebc44ce1c25bb357206623Chris Lattner if (!ICI.isEquality() && XorCST->isMaxValue(true)) { 109002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner const APInt &NotSignBit = XorCST->getValue(); 109102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ICmpInst::Predicate Pred = ICI.isSigned() 109202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ? ICI.getUnsignedPredicate() 109302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner : ICI.getSignedPredicate(); 109402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Pred = ICI.getSwappedPredicate(Pred); 109502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(Pred, LHSI->getOperand(0), 109602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt::get(ICI.getContext(), 109702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner RHSV ^ NotSignBit)); 109802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 109902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 110002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 110102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 110202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::And: // (icmp pred (and X, AndCST), RHS) 110302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (LHSI->hasOneUse() && isa<ConstantInt>(LHSI->getOperand(1)) && 110402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner LHSI->getOperand(0)->hasOneUse()) { 110502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt *AndCST = cast<ConstantInt>(LHSI->getOperand(1)); 11060cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 110702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If the LHS is an AND of a truncating cast, we can widen the 110802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // and/compare to be the input width without changing the value 110902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // produced, eliminating a cast. 111002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (TruncInst *Cast = dyn_cast<TruncInst>(LHSI->getOperand(0))) { 111102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // We can do this transformation if either the AND constant does not 11120cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // have its sign bit set or if it is an equality comparison. 111302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Extending a relational comparison when we're checking the sign 111402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // bit would not work. 11157e7c9cc31a9c0ca337235ae04fc268e58da1d01bBenjamin Kramer if (ICI.isEquality() || 1116c73b24db5f6226ed44ebc44ce1c25bb357206623Chris Lattner (!AndCST->isNegative() && RHSV.isNonNegative())) { 11177e7c9cc31a9c0ca337235ae04fc268e58da1d01bBenjamin Kramer Value *NewAnd = 111802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Builder->CreateAnd(Cast->getOperand(0), 11197e7c9cc31a9c0ca337235ae04fc268e58da1d01bBenjamin Kramer ConstantExpr::getZExt(AndCST, Cast->getSrcTy())); 11207e7c9cc31a9c0ca337235ae04fc268e58da1d01bBenjamin Kramer NewAnd->takeName(LHSI); 112102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICI.getPredicate(), NewAnd, 11227e7c9cc31a9c0ca337235ae04fc268e58da1d01bBenjamin Kramer ConstantExpr::getZExt(RHS, Cast->getSrcTy())); 112302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 112402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 1125ffd0ae64c497d13956d16526c46245bfbf48e91fBenjamin Kramer 1126ffd0ae64c497d13956d16526c46245bfbf48e91fBenjamin Kramer // If the LHS is an AND of a zext, and we have an equality compare, we can 1127ffd0ae64c497d13956d16526c46245bfbf48e91fBenjamin Kramer // shrink the and/compare to the smaller type, eliminating the cast. 1128ffd0ae64c497d13956d16526c46245bfbf48e91fBenjamin Kramer if (ZExtInst *Cast = dyn_cast<ZExtInst>(LHSI->getOperand(0))) { 1129db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner IntegerType *Ty = cast<IntegerType>(Cast->getSrcTy()); 1130ffd0ae64c497d13956d16526c46245bfbf48e91fBenjamin Kramer // Make sure we don't compare the upper bits, SimplifyDemandedBits 1131ffd0ae64c497d13956d16526c46245bfbf48e91fBenjamin Kramer // should fold the icmp to true/false in that case. 1132ffd0ae64c497d13956d16526c46245bfbf48e91fBenjamin Kramer if (ICI.isEquality() && RHSV.getActiveBits() <= Ty->getBitWidth()) { 1133ffd0ae64c497d13956d16526c46245bfbf48e91fBenjamin Kramer Value *NewAnd = 1134ffd0ae64c497d13956d16526c46245bfbf48e91fBenjamin Kramer Builder->CreateAnd(Cast->getOperand(0), 1135ffd0ae64c497d13956d16526c46245bfbf48e91fBenjamin Kramer ConstantExpr::getTrunc(AndCST, Ty)); 1136ffd0ae64c497d13956d16526c46245bfbf48e91fBenjamin Kramer NewAnd->takeName(LHSI); 1137ffd0ae64c497d13956d16526c46245bfbf48e91fBenjamin Kramer return new ICmpInst(ICI.getPredicate(), NewAnd, 1138ffd0ae64c497d13956d16526c46245bfbf48e91fBenjamin Kramer ConstantExpr::getTrunc(RHS, Ty)); 1139ffd0ae64c497d13956d16526c46245bfbf48e91fBenjamin Kramer } 1140ffd0ae64c497d13956d16526c46245bfbf48e91fBenjamin Kramer } 1141ffd0ae64c497d13956d16526c46245bfbf48e91fBenjamin Kramer 114202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If this is: (X >> C1) & C2 != C3 (where any shift and any compare 114302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // could exist), turn it into (X & (C2 << C1)) != (C3 << C1). This 114402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // happens a LOT in code produced by the C front-end, for bitfield 114502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // access. 114602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner BinaryOperator *Shift = dyn_cast<BinaryOperator>(LHSI->getOperand(0)); 114702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Shift && !Shift->isShift()) 114802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Shift = 0; 11490cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 115002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt *ShAmt; 115102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ShAmt = Shift ? dyn_cast<ConstantInt>(Shift->getOperand(1)) : 0; 1152db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty = Shift ? Shift->getType() : 0; // Type of the shift. 1153db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *AndTy = AndCST->getType(); // Type of the and. 11540cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 115502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // We can fold this as long as we can't shift unknown bits 115602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // into the mask. This can only happen with signed shift 115702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // rights, as they sign-extend. 115802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ShAmt) { 115902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner bool CanFold = Shift->isLogicalShift(); 116002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!CanFold) { 116102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // To test for the bad case of the signed shr, see if any 116202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // of the bits shifted in could be tested after the mask. 116302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner uint32_t TyBits = Ty->getPrimitiveSizeInBits(); 116402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner int ShAmtVal = TyBits - ShAmt->getLimitedValue(TyBits); 11650cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 116602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner uint32_t BitWidth = AndTy->getPrimitiveSizeInBits(); 11670cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach if ((APInt::getHighBitsSet(BitWidth, BitWidth-ShAmtVal) & 116802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner AndCST->getValue()) == 0) 116902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner CanFold = true; 117002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 11710cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 117202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (CanFold) { 117302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant *NewCst; 117402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Shift->getOpcode() == Instruction::Shl) 117502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner NewCst = ConstantExpr::getLShr(RHS, ShAmt); 117602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner else 117702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner NewCst = ConstantExpr::getShl(RHS, ShAmt); 11780cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 117902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Check to see if we are shifting out any of the bits being 118002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // compared. 118102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ConstantExpr::get(Shift->getOpcode(), 118202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner NewCst, ShAmt) != RHS) { 118302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If we shifted bits out, the fold is not going to work out. 118402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // As a special case, check to see if this means that the 118502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // result is always true or false now. 118602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ICI.getPredicate() == ICmpInst::ICMP_EQ) 118702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return ReplaceInstUsesWith(ICI, 118802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt::getFalse(ICI.getContext())); 118902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ICI.getPredicate() == ICmpInst::ICMP_NE) 119002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return ReplaceInstUsesWith(ICI, 119102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt::getTrue(ICI.getContext())); 119202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else { 119302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ICI.setOperand(1, NewCst); 119402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant *NewAndCST; 119502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Shift->getOpcode() == Instruction::Shl) 119602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner NewAndCST = ConstantExpr::getLShr(AndCST, ShAmt); 119702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner else 119802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner NewAndCST = ConstantExpr::getShl(AndCST, ShAmt); 119902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner LHSI->setOperand(1, NewAndCST); 120002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner LHSI->setOperand(0, Shift->getOperand(0)); 120102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Worklist.Add(Shift); // Shift is dead. 120202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return &ICI; 120302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 120402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 120502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 12060cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 120702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Turn ((X >> Y) & C) == 0 into (X & (C << Y)) == 0. The later is 120802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // preferable because it allows the C<<Y expression to be hoisted out 120902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // of a loop if Y is invariant and X is not. 121002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Shift && Shift->hasOneUse() && RHSV == 0 && 121102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ICI.isEquality() && !Shift->isArithmeticShift() && 121202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner !isa<Constant>(Shift->getOperand(0))) { 121302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Compute C << Y. 121402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *NS; 121502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Shift->getOpcode() == Instruction::LShr) { 1216a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer NS = Builder->CreateShl(AndCST, Shift->getOperand(1)); 121702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else { 121802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Insert a logical shift. 1219a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer NS = Builder->CreateLShr(AndCST, Shift->getOperand(1)); 122002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 12210cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 122202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Compute X & (C << Y). 12230cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach Value *NewAnd = 122402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Builder->CreateAnd(Shift->getOperand(0), NS, LHSI->getName()); 12250cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 122602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ICI.setOperand(0, NewAnd); 122702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return &ICI; 122802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 12296da2e22dffe9dd0255e10a8934f2879eb7e87868Paul Redmond 12306da2e22dffe9dd0255e10a8934f2879eb7e87868Paul Redmond // Replace ((X & AndCST) > RHSV) with ((X & AndCST) != 0), if any 12316da2e22dffe9dd0255e10a8934f2879eb7e87868Paul Redmond // bit set in (X & AndCST) will produce a result greater than RHSV. 12326da2e22dffe9dd0255e10a8934f2879eb7e87868Paul Redmond if (ICI.getPredicate() == ICmpInst::ICMP_UGT) { 12336da2e22dffe9dd0255e10a8934f2879eb7e87868Paul Redmond unsigned NTZ = AndCST->getValue().countTrailingZeros(); 12346da2e22dffe9dd0255e10a8934f2879eb7e87868Paul Redmond if ((NTZ < AndCST->getBitWidth()) && 12356da2e22dffe9dd0255e10a8934f2879eb7e87868Paul Redmond APInt::getOneBitSet(AndCST->getBitWidth(), NTZ).ugt(RHSV)) 12366da2e22dffe9dd0255e10a8934f2879eb7e87868Paul Redmond return new ICmpInst(ICmpInst::ICMP_NE, LHSI, 12376da2e22dffe9dd0255e10a8934f2879eb7e87868Paul Redmond Constant::getNullValue(RHS->getType())); 12386da2e22dffe9dd0255e10a8934f2879eb7e87868Paul Redmond } 123902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 12400cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 124102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Try to optimize things like "A[i]&42 == 0" to index computations. 124202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (LoadInst *LI = dyn_cast<LoadInst>(LHSI->getOperand(0))) { 124302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (GetElementPtrInst *GEP = 124402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner dyn_cast<GetElementPtrInst>(LI->getOperand(0))) 124502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (GlobalVariable *GV = dyn_cast<GlobalVariable>(GEP->getOperand(0))) 124602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (GV->isConstant() && GV->hasDefinitiveInitializer() && 124702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner !LI->isVolatile() && isa<ConstantInt>(LHSI->getOperand(1))) { 124802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt *C = cast<ConstantInt>(LHSI->getOperand(1)); 124902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Instruction *Res = FoldCmpLoadFromIndexedGlobal(GEP, GV,ICI, C)) 125002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return Res; 125102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 125202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 125302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 125402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 125502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::Or: { 125602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!ICI.isEquality() || !RHS->isNullValue() || !LHSI->hasOneUse()) 125702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 125802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *P, *Q; 125902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (match(LHSI, m_Or(m_PtrToInt(m_Value(P)), m_PtrToInt(m_Value(Q))))) { 126002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Simplify icmp eq (or (ptrtoint P), (ptrtoint Q)), 0 126102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // -> and (icmp eq P, null), (icmp eq Q, null). 126202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *ICIP = Builder->CreateICmp(ICI.getPredicate(), P, 126302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant::getNullValue(P->getType())); 126402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *ICIQ = Builder->CreateICmp(ICI.getPredicate(), Q, 126502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant::getNullValue(Q->getType())); 126602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Instruction *Op; 126702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ICI.getPredicate() == ICmpInst::ICMP_EQ) 126802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Op = BinaryOperator::CreateAnd(ICIP, ICIQ); 126902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner else 127002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Op = BinaryOperator::CreateOr(ICIP, ICIQ); 127102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return Op; 127202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 127302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 127402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 12750cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 127602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::Shl: { // (icmp pred (shl X, ShAmt), CI) 127702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt *ShAmt = dyn_cast<ConstantInt>(LHSI->getOperand(1)); 127802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!ShAmt) break; 12790cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 128002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner uint32_t TypeBits = RHSV.getBitWidth(); 12810cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 128202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Check that the shift amount is in range. If not, don't perform 128302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // undefined shifts. When the shift is visited it will be 128402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // simplified. 128502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ShAmt->uge(TypeBits)) 128602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 12870cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 128802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ICI.isEquality()) { 128902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If we are comparing against bits always shifted out, the 129002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // comparison cannot succeed. 129102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant *Comp = 129202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantExpr::getShl(ConstantExpr::getLShr(RHS, ShAmt), 129302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ShAmt); 129402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Comp != RHS) {// Comparing against a bit that we know is zero. 129502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner bool IsICMP_NE = ICI.getPredicate() == ICmpInst::ICMP_NE; 129602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant *Cst = 129702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt::get(Type::getInt1Ty(ICI.getContext()), IsICMP_NE); 129802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return ReplaceInstUsesWith(ICI, Cst); 129902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 13000cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 1301b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner // If the shift is NUW, then it is just shifting out zeros, no need for an 1302b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner // AND. 1303b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner if (cast<BinaryOperator>(LHSI)->hasNoUnsignedWrap()) 1304b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner return new ICmpInst(ICI.getPredicate(), LHSI->getOperand(0), 1305b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner ConstantExpr::getLShr(RHS, ShAmt)); 13060cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 130702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (LHSI->hasOneUse()) { 130802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Otherwise strength reduce the shift into an and. 130902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner uint32_t ShAmtVal = (uint32_t)ShAmt->getLimitedValue(TypeBits); 131002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant *Mask = 13110cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach ConstantInt::get(ICI.getContext(), APInt::getLowBitsSet(TypeBits, 131202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner TypeBits-ShAmtVal)); 13130cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 131402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *And = 131502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Builder->CreateAnd(LHSI->getOperand(0),Mask, LHSI->getName()+".mask"); 131602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICI.getPredicate(), And, 1317b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner ConstantExpr::getLShr(RHS, ShAmt)); 131802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 131902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 13200cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 132102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Otherwise, if this is a comparison of the sign bit, simplify to and/test. 132202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner bool TrueIfSigned = false; 132302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (LHSI->hasOneUse() && 132402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner isSignBitCheck(ICI.getPredicate(), RHS, TrueIfSigned)) { 132502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (X << 31) <s 0 --> (X&1) != 0 1326bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner Constant *Mask = ConstantInt::get(LHSI->getOperand(0)->getType(), 13270cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach APInt::getOneBitSet(TypeBits, 1328bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner TypeBits-ShAmt->getZExtValue()-1)); 132902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *And = 133002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Builder->CreateAnd(LHSI->getOperand(0), Mask, LHSI->getName()+".mask"); 133102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(TrueIfSigned ? ICmpInst::ICMP_NE : ICmpInst::ICMP_EQ, 133202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner And, Constant::getNullValue(And->getType())); 133302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 13347c5c9b39c91d5f53284011c0ddbf458d553740daArnaud A. de Grandmaison 13357c5c9b39c91d5f53284011c0ddbf458d553740daArnaud A. de Grandmaison // Transform (icmp pred iM (shl iM %v, N), CI) 1336bdd2d981391bd9329aba669cffcdde0c39373cb1Arnaud A. de Grandmaison // -> (icmp pred i(M-N) (trunc %v iM to i(M-N)), (trunc (CI>>N)) 1337bdd2d981391bd9329aba669cffcdde0c39373cb1Arnaud A. de Grandmaison // Transform the shl to a trunc if (trunc (CI>>N)) has no loss and M-N. 13387c5c9b39c91d5f53284011c0ddbf458d553740daArnaud A. de Grandmaison // This enables to get rid of the shift in favor of a trunc which can be 13397c5c9b39c91d5f53284011c0ddbf458d553740daArnaud A. de Grandmaison // free on the target. It has the additional benefit of comparing to a 13407c5c9b39c91d5f53284011c0ddbf458d553740daArnaud A. de Grandmaison // smaller constant, which will be target friendly. 13417c5c9b39c91d5f53284011c0ddbf458d553740daArnaud A. de Grandmaison unsigned Amt = ShAmt->getLimitedValue(TypeBits-1); 1342bdd2d981391bd9329aba669cffcdde0c39373cb1Arnaud A. de Grandmaison if (LHSI->hasOneUse() && 1343bdd2d981391bd9329aba669cffcdde0c39373cb1Arnaud A. de Grandmaison Amt != 0 && RHSV.countTrailingZeros() >= Amt) { 13447c5c9b39c91d5f53284011c0ddbf458d553740daArnaud A. de Grandmaison Type *NTy = IntegerType::get(ICI.getContext(), TypeBits - Amt); 13457c5c9b39c91d5f53284011c0ddbf458d553740daArnaud A. de Grandmaison Constant *NCI = ConstantExpr::getTrunc( 13467c5c9b39c91d5f53284011c0ddbf458d553740daArnaud A. de Grandmaison ConstantExpr::getAShr(RHS, 13477c5c9b39c91d5f53284011c0ddbf458d553740daArnaud A. de Grandmaison ConstantInt::get(RHS->getType(), Amt)), 13487c5c9b39c91d5f53284011c0ddbf458d553740daArnaud A. de Grandmaison NTy); 13497c5c9b39c91d5f53284011c0ddbf458d553740daArnaud A. de Grandmaison return new ICmpInst(ICI.getPredicate(), 13507c5c9b39c91d5f53284011c0ddbf458d553740daArnaud A. de Grandmaison Builder->CreateTrunc(LHSI->getOperand(0), NTy), 1351ad079b274d6ecd3e36fb98099864baeeeb96ac82Arnaud A. de Grandmaison NCI); 13527c5c9b39c91d5f53284011c0ddbf458d553740daArnaud A. de Grandmaison } 13537c5c9b39c91d5f53284011c0ddbf458d553740daArnaud A. de Grandmaison 135402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 135502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 13560cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 135702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::LShr: // (icmp pred (shr X, ShAmt), CI) 1358b042f8e9699dd15d7ac48bb9b9475122b1673687Nick Lewycky case Instruction::AShr: { 1359b042f8e9699dd15d7ac48bb9b9475122b1673687Nick Lewycky // Handle equality comparisons of shift-by-constant. 1360b042f8e9699dd15d7ac48bb9b9475122b1673687Nick Lewycky BinaryOperator *BO = cast<BinaryOperator>(LHSI); 1361b042f8e9699dd15d7ac48bb9b9475122b1673687Nick Lewycky if (ConstantInt *ShAmt = dyn_cast<ConstantInt>(LHSI->getOperand(1))) { 1362b042f8e9699dd15d7ac48bb9b9475122b1673687Nick Lewycky if (Instruction *Res = FoldICmpShrCst(ICI, BO, ShAmt)) 136374542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner return Res; 1364b042f8e9699dd15d7ac48bb9b9475122b1673687Nick Lewycky } 1365b042f8e9699dd15d7ac48bb9b9475122b1673687Nick Lewycky 1366b042f8e9699dd15d7ac48bb9b9475122b1673687Nick Lewycky // Handle exact shr's. 1367b042f8e9699dd15d7ac48bb9b9475122b1673687Nick Lewycky if (ICI.isEquality() && BO->isExact() && BO->hasOneUse()) { 1368b042f8e9699dd15d7ac48bb9b9475122b1673687Nick Lewycky if (RHSV.isMinValue()) 1369b042f8e9699dd15d7ac48bb9b9475122b1673687Nick Lewycky return new ICmpInst(ICI.getPredicate(), BO->getOperand(0), RHS); 1370b042f8e9699dd15d7ac48bb9b9475122b1673687Nick Lewycky } 137102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 1372b042f8e9699dd15d7ac48bb9b9475122b1673687Nick Lewycky } 13730cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 137402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::SDiv: 137502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::UDiv: 137602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Fold: icmp pred ([us]div X, C1), C2 -> range test 13770cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // Fold this div into the comparison, producing a range check. 13780cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // Determine, based on the divide type, what the range is being 13790cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // checked. If there is an overflow on the low or high side, remember 138002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // it, otherwise compute the range [low, hi) bounding the new value. 138102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // See: InsertRangeTest above for the kinds of replacements possible. 138202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ConstantInt *DivRHS = dyn_cast<ConstantInt>(LHSI->getOperand(1))) 138302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Instruction *R = FoldICmpDivCst(ICI, cast<BinaryOperator>(LHSI), 138402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner DivRHS)) 138502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return R; 138602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 138702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 138802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::Add: 138902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Fold: icmp pred (add X, C1), C2 139002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!ICI.isEquality()) { 139102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt *LHSC = dyn_cast<ConstantInt>(LHSI->getOperand(1)); 139202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!LHSC) break; 139302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner const APInt &LHSV = LHSC->getValue(); 139402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 139502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantRange CR = ICI.makeConstantRange(ICI.getPredicate(), RHSV) 139602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner .subtract(LHSV); 139702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 139802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ICI.isSigned()) { 139902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (CR.getLower().isSignBit()) { 140002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_SLT, LHSI->getOperand(0), 140102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt::get(ICI.getContext(),CR.getUpper())); 140202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else if (CR.getUpper().isSignBit()) { 140302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_SGE, LHSI->getOperand(0), 140402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt::get(ICI.getContext(),CR.getLower())); 140502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 140602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else { 140702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (CR.getLower().isMinValue()) { 140802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_ULT, LHSI->getOperand(0), 140902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt::get(ICI.getContext(),CR.getUpper())); 141002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else if (CR.getUpper().isMinValue()) { 141102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_UGE, LHSI->getOperand(0), 141202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt::get(ICI.getContext(),CR.getLower())); 141302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 141402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 141502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 141602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 141702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 14180cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 141902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Simplify icmp_eq and icmp_ne instructions with integer constant RHS. 142002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ICI.isEquality()) { 142102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner bool isICMP_NE = ICI.getPredicate() == ICmpInst::ICMP_NE; 14220cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 14230cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // If the first operand is (add|sub|and|or|xor|rem) with a constant, and 142402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // the second operand is a constant, simplify a bit. 142502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (BinaryOperator *BO = dyn_cast<BinaryOperator>(LHSI)) { 142602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner switch (BO->getOpcode()) { 142702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::SRem: 142802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If we have a signed (X % (2^c)) == 0, turn it into an unsigned one. 142902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (RHSV == 0 && isa<ConstantInt>(BO->getOperand(1)) &&BO->hasOneUse()){ 143002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner const APInt &V = cast<ConstantInt>(BO->getOperand(1))->getValue(); 1431e05678132345eb8a632362dbd320ee7d36226e67Dan Gohman if (V.sgt(1) && V.isPowerOf2()) { 143202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *NewRem = 143302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Builder->CreateURem(BO->getOperand(0), BO->getOperand(1), 143402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner BO->getName()); 143502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICI.getPredicate(), NewRem, 143602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant::getNullValue(BO->getType())); 143702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 143802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 143902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 144002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::Add: 144102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Replace ((add A, B) != C) with (A != C-B) if B & C are constants. 144202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ConstantInt *BOp1C = dyn_cast<ConstantInt>(BO->getOperand(1))) { 144302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (BO->hasOneUse()) 144402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICI.getPredicate(), BO->getOperand(0), 144502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantExpr::getSub(RHS, BOp1C)); 144602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else if (RHSV == 0) { 144702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Replace ((add A, B) != 0) with (A != -B) if A or B is 144802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // efficiently invertible, or if the add has just this one use. 144902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *BOp0 = BO->getOperand(0), *BOp1 = BO->getOperand(1); 14500cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 145102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Value *NegVal = dyn_castNegVal(BOp1)) 145202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICI.getPredicate(), BOp0, NegVal); 14535036ce4a64caaeaff4b1f8f1c91836cc2e49a455Chris Lattner if (Value *NegVal = dyn_castNegVal(BOp0)) 145402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICI.getPredicate(), NegVal, BOp1); 14555036ce4a64caaeaff4b1f8f1c91836cc2e49a455Chris Lattner if (BO->hasOneUse()) { 145602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *Neg = Builder->CreateNeg(BOp1); 145702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Neg->takeName(BO); 145802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICI.getPredicate(), BOp0, Neg); 145902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 146002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 146102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 146202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::Xor: 146302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // For the xor case, we can xor two constants together, eliminating 146402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // the explicit xor. 1465e7fdcad2f2d82c81684cb9962327330786c35107Benjamin Kramer if (Constant *BOC = dyn_cast<Constant>(BO->getOperand(1))) { 1466e7fdcad2f2d82c81684cb9962327330786c35107Benjamin Kramer return new ICmpInst(ICI.getPredicate(), BO->getOperand(0), 146702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantExpr::getXor(RHS, BOC)); 1468e7fdcad2f2d82c81684cb9962327330786c35107Benjamin Kramer } else if (RHSV == 0) { 1469e7fdcad2f2d82c81684cb9962327330786c35107Benjamin Kramer // Replace ((xor A, B) != 0) with (A != B) 1470e7fdcad2f2d82c81684cb9962327330786c35107Benjamin Kramer return new ICmpInst(ICI.getPredicate(), BO->getOperand(0), 1471e7fdcad2f2d82c81684cb9962327330786c35107Benjamin Kramer BO->getOperand(1)); 1472e7fdcad2f2d82c81684cb9962327330786c35107Benjamin Kramer } 1473e7fdcad2f2d82c81684cb9962327330786c35107Benjamin Kramer break; 147402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::Sub: 1475e7fdcad2f2d82c81684cb9962327330786c35107Benjamin Kramer // Replace ((sub A, B) != C) with (B != A-C) if A & C are constants. 1476e7fdcad2f2d82c81684cb9962327330786c35107Benjamin Kramer if (ConstantInt *BOp0C = dyn_cast<ConstantInt>(BO->getOperand(0))) { 1477e7fdcad2f2d82c81684cb9962327330786c35107Benjamin Kramer if (BO->hasOneUse()) 1478e7fdcad2f2d82c81684cb9962327330786c35107Benjamin Kramer return new ICmpInst(ICI.getPredicate(), BO->getOperand(1), 1479e7fdcad2f2d82c81684cb9962327330786c35107Benjamin Kramer ConstantExpr::getSub(BOp0C, RHS)); 1480e7fdcad2f2d82c81684cb9962327330786c35107Benjamin Kramer } else if (RHSV == 0) { 1481e7fdcad2f2d82c81684cb9962327330786c35107Benjamin Kramer // Replace ((sub A, B) != 0) with (A != B) 148202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICI.getPredicate(), BO->getOperand(0), 148302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner BO->getOperand(1)); 1484e7fdcad2f2d82c81684cb9962327330786c35107Benjamin Kramer } 148502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 148602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::Or: 148702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If bits are being or'd in that are not present in the constant we 148802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // are comparing against, then the comparison could never succeed! 1489618898e933c6350f1f7976370f3822c086d70f0cEli Friedman if (ConstantInt *BOC = dyn_cast<ConstantInt>(BO->getOperand(1))) { 149002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant *NotCI = ConstantExpr::getNot(RHS); 149102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!ConstantExpr::getAnd(BOC, NotCI)->isNullValue()) 149202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return ReplaceInstUsesWith(ICI, 14930cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach ConstantInt::get(Type::getInt1Ty(ICI.getContext()), 149402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner isICMP_NE)); 149502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 149602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 14970cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 149802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::And: 149902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ConstantInt *BOC = dyn_cast<ConstantInt>(BO->getOperand(1))) { 150002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If bits are being compared against that are and'd out, then the 150102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // comparison can never succeed! 150202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if ((RHSV & ~BOC->getValue()) != 0) 150302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return ReplaceInstUsesWith(ICI, 150402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt::get(Type::getInt1Ty(ICI.getContext()), 150502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner isICMP_NE)); 15060cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 150702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If we have ((X & C) == C), turn it into ((X & C) != 0). 150802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (RHS == BOC && RHSV.isPowerOf2()) 150902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(isICMP_NE ? ICmpInst::ICMP_EQ : 151002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ICmpInst::ICMP_NE, LHSI, 151102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant::getNullValue(RHS->getType())); 1512fc87cdc1f4df357167a7cef91af92b5012934124Benjamin Kramer 1513fc87cdc1f4df357167a7cef91af92b5012934124Benjamin Kramer // Don't perform the following transforms if the AND has multiple uses 1514fc87cdc1f4df357167a7cef91af92b5012934124Benjamin Kramer if (!BO->hasOneUse()) 1515fc87cdc1f4df357167a7cef91af92b5012934124Benjamin Kramer break; 1516fc87cdc1f4df357167a7cef91af92b5012934124Benjamin Kramer 151702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Replace (and X, (1 << size(X)-1) != 0) with x s< 0 151802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (BOC->getValue().isSignBit()) { 151902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *X = BO->getOperand(0); 152002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant *Zero = Constant::getNullValue(X->getType()); 15210cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach ICmpInst::Predicate pred = isICMP_NE ? 152202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ICmpInst::ICMP_SLT : ICmpInst::ICMP_SGE; 152302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(pred, X, Zero); 152402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 15250cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 152602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // ((X & ~7) == 0) --> X < 8 152702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (RHSV == 0 && isHighOnes(BOC)) { 152802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *X = BO->getOperand(0); 152902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant *NegX = ConstantExpr::getNeg(BOC); 15300cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach ICmpInst::Predicate pred = isICMP_NE ? 153102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ICmpInst::ICMP_UGE : ICmpInst::ICMP_ULT; 153202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(pred, X, NegX); 153302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 153402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 153502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner default: break; 153602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 153702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(LHSI)) { 153802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Handle icmp {eq|ne} <intrinsic>, intcst. 1539033574074d3c980057a0cb989d272ec72a8f9523Chris Lattner switch (II->getIntrinsicID()) { 1540033574074d3c980057a0cb989d272ec72a8f9523Chris Lattner case Intrinsic::bswap: 154102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Worklist.Add(II); 1542caf70b31b0d8cbae0f05df404dd5935c27369690Gabor Greif ICI.setOperand(0, II->getArgOperand(0)); 154302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ICI.setOperand(1, ConstantInt::get(II->getContext(), RHSV.byteSwap())); 154402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return &ICI; 1545033574074d3c980057a0cb989d272ec72a8f9523Chris Lattner case Intrinsic::ctlz: 1546033574074d3c980057a0cb989d272ec72a8f9523Chris Lattner case Intrinsic::cttz: 1547033574074d3c980057a0cb989d272ec72a8f9523Chris Lattner // ctz(A) == bitwidth(a) -> A == 0 and likewise for != 1548033574074d3c980057a0cb989d272ec72a8f9523Chris Lattner if (RHSV == RHS->getType()->getBitWidth()) { 1549033574074d3c980057a0cb989d272ec72a8f9523Chris Lattner Worklist.Add(II); 1550caf70b31b0d8cbae0f05df404dd5935c27369690Gabor Greif ICI.setOperand(0, II->getArgOperand(0)); 1551033574074d3c980057a0cb989d272ec72a8f9523Chris Lattner ICI.setOperand(1, ConstantInt::get(RHS->getType(), 0)); 1552033574074d3c980057a0cb989d272ec72a8f9523Chris Lattner return &ICI; 1553033574074d3c980057a0cb989d272ec72a8f9523Chris Lattner } 1554033574074d3c980057a0cb989d272ec72a8f9523Chris Lattner break; 1555033574074d3c980057a0cb989d272ec72a8f9523Chris Lattner case Intrinsic::ctpop: 1556033574074d3c980057a0cb989d272ec72a8f9523Chris Lattner // popcount(A) == 0 -> A == 0 and likewise for != 1557033574074d3c980057a0cb989d272ec72a8f9523Chris Lattner if (RHS->isZero()) { 1558033574074d3c980057a0cb989d272ec72a8f9523Chris Lattner Worklist.Add(II); 1559caf70b31b0d8cbae0f05df404dd5935c27369690Gabor Greif ICI.setOperand(0, II->getArgOperand(0)); 1560033574074d3c980057a0cb989d272ec72a8f9523Chris Lattner ICI.setOperand(1, RHS); 1561033574074d3c980057a0cb989d272ec72a8f9523Chris Lattner return &ICI; 1562033574074d3c980057a0cb989d272ec72a8f9523Chris Lattner } 1563033574074d3c980057a0cb989d272ec72a8f9523Chris Lattner break; 1564033574074d3c980057a0cb989d272ec72a8f9523Chris Lattner default: 15653472766f9eb7d66f234c390ce1b3a8b76f0ee9ceDuncan Sands break; 156602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 156702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 156802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 156902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return 0; 157002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner} 157102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 157202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// visitICmpInstWithCastAndCast - Handle icmp (cast x to y), (cast/cst). 157302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// We only handle extending casts so far. 157402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// 157502446fc99abb06d3117d65c0b1f5fba4f906db2eChris LattnerInstruction *InstCombiner::visitICmpInstWithCastAndCast(ICmpInst &ICI) { 157602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner const CastInst *LHSCI = cast<CastInst>(ICI.getOperand(0)); 157702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *LHSCIOp = LHSCI->getOperand(0); 1578db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *SrcTy = LHSCIOp->getType(); 1579db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *DestTy = LHSCI->getType(); 158002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *RHSCIOp; 158102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 15820cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // Turn icmp (ptrtoint x), (ptrtoint/c) into a compare of the input if the 158302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // integer type is the same size as the pointer type. 158402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (TD && LHSCI->getOpcode() == Instruction::PtrToInt && 1585426c2bf5cdd2173e4a33aea8cb92cf684a724f4bChandler Carruth TD->getPointerSizeInBits() == 158602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner cast<IntegerType>(DestTy)->getBitWidth()) { 158702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *RHSOp = 0; 158802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Constant *RHSC = dyn_cast<Constant>(ICI.getOperand(1))) { 158902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner RHSOp = ConstantExpr::getIntToPtr(RHSC, SrcTy); 159002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else if (PtrToIntInst *RHSC = dyn_cast<PtrToIntInst>(ICI.getOperand(1))) { 159102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner RHSOp = RHSC->getOperand(0); 159202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If the pointer types don't match, insert a bitcast. 159302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (LHSCIOp->getType() != RHSOp->getType()) 159402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner RHSOp = Builder->CreateBitCast(RHSOp, LHSCIOp->getType()); 159502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 159602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 159702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (RHSOp) 159802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICI.getPredicate(), LHSCIOp, RHSOp); 159902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 16000cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 160102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // The code below only handles extension cast instructions, so far. 160202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Enforce this. 160302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (LHSCI->getOpcode() != Instruction::ZExt && 160402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner LHSCI->getOpcode() != Instruction::SExt) 160502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return 0; 160602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 160702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner bool isSignedExt = LHSCI->getOpcode() == Instruction::SExt; 160802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner bool isSignedCmp = ICI.isSigned(); 160902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 161002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (CastInst *CI = dyn_cast<CastInst>(ICI.getOperand(1))) { 161102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Not an extension from the same type? 161202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner RHSCIOp = CI->getOperand(0); 16130cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach if (RHSCIOp->getType() != LHSCIOp->getType()) 161402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return 0; 16150cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 161602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If the signedness of the two casts doesn't agree (i.e. one is a sext 161702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // and the other is a zext), then we can't handle this. 161802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (CI->getOpcode() != LHSCI->getOpcode()) 161902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return 0; 162002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 162102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Deal with equality cases early. 162202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ICI.isEquality()) 162302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICI.getPredicate(), LHSCIOp, RHSCIOp); 162402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 162502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // A signed comparison of sign extended values simplifies into a 162602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // signed comparison. 162702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (isSignedCmp && isSignedExt) 162802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICI.getPredicate(), LHSCIOp, RHSCIOp); 162902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 163002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // The other three cases all fold into an unsigned comparison. 163102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICI.getUnsignedPredicate(), LHSCIOp, RHSCIOp); 163202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 163302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 163402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If we aren't dealing with a constant on the RHS, exit early 163502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt *CI = dyn_cast<ConstantInt>(ICI.getOperand(1)); 163602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!CI) 163702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return 0; 163802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 163902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Compute the constant that would happen if we truncated to SrcTy then 164002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // reextended to DestTy. 164102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant *Res1 = ConstantExpr::getTrunc(CI, SrcTy); 164202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant *Res2 = ConstantExpr::getCast(LHSCI->getOpcode(), 164302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Res1, DestTy); 164402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 164502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If the re-extended constant didn't change... 164602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Res2 == CI) { 164702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Deal with equality cases early. 164802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ICI.isEquality()) 164902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICI.getPredicate(), LHSCIOp, Res1); 165002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 165102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // A signed comparison of sign extended values simplifies into a 165202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // signed comparison. 165302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (isSignedExt && isSignedCmp) 165402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICI.getPredicate(), LHSCIOp, Res1); 165502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 165602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // The other three cases all fold into an unsigned comparison. 165702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICI.getUnsignedPredicate(), LHSCIOp, Res1); 165802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 165902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 16600cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // The re-extended constant changed so the constant cannot be represented 166102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // in the shorter type. Consequently, we cannot emit a simple comparison. 16629d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // All the cases that fold to true or false will have already been handled 16639d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // by SimplifyICmpInst, so only deal with the tricky case. 166402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 16659d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (isSignedCmp || !isSignedExt) 16669d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return 0; 166702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 166802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Evaluate the comparison for LT (we invert for GT below). LE and GE cases 166902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // should have been folded away previously and not enter in here. 16709d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 16719d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // We're performing an unsigned comp with a sign extended value. 16729d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // This is true if the input is >= 0. [aka >s -1] 16739d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant *NegOne = Constant::getAllOnesValue(SrcTy); 16749d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Value *Result = Builder->CreateICmpSGT(LHSCIOp, NegOne, ICI.getName()); 167502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 167602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Finally, return the value computed. 16779d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (ICI.getPredicate() == ICmpInst::ICMP_ULT) 167802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return ReplaceInstUsesWith(ICI, Result); 167902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 16809d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands assert(ICI.getPredicate() == ICmpInst::ICMP_UGT && "ICmp should be folded!"); 168102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return BinaryOperator::CreateNot(Result); 168202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner} 168302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 1684f0f568b49e111da1258902b73a7b9266222e1842Chris Lattner/// ProcessUGT_ADDCST_ADD - The caller has matched a pattern of the form: 1685f0f568b49e111da1258902b73a7b9266222e1842Chris Lattner/// I = icmp ugt (add (add A, B), CI2), CI1 1686dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner/// If this is of the form: 1687dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner/// sum = a + b 1688dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner/// if (sum+128 >u 255) 1689dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner/// Then replace it with llvm.sadd.with.overflow.i8. 1690dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner/// 1691f0f568b49e111da1258902b73a7b9266222e1842Chris Lattnerstatic Instruction *ProcessUGT_ADDCST_ADD(ICmpInst &I, Value *A, Value *B, 1692f0f568b49e111da1258902b73a7b9266222e1842Chris Lattner ConstantInt *CI2, ConstantInt *CI1, 16930fe80bbbb6a017169d273c4824903b52a7ea2414Chris Lattner InstCombiner &IC) { 1694368397bb7de8318a4663fec846bda714ae78dd7aChris Lattner // The transformation we're trying to do here is to transform this into an 1695368397bb7de8318a4663fec846bda714ae78dd7aChris Lattner // llvm.sadd.with.overflow. To do this, we have to replace the original add 1696368397bb7de8318a4663fec846bda714ae78dd7aChris Lattner // with a narrower add, and discard the add-with-constant that is part of the 1697368397bb7de8318a4663fec846bda714ae78dd7aChris Lattner // range check (if we can't eliminate it, this isn't profitable). 16980cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 1699368397bb7de8318a4663fec846bda714ae78dd7aChris Lattner // In order to eliminate the add-with-constant, the compare can be its only 1700368397bb7de8318a4663fec846bda714ae78dd7aChris Lattner // use. 1701dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner Instruction *AddWithCst = cast<Instruction>(I.getOperand(0)); 1702368397bb7de8318a4663fec846bda714ae78dd7aChris Lattner if (!AddWithCst->hasOneUse()) return 0; 17030cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 1704dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner // If CI2 is 2^7, 2^15, 2^31, then it might be an sadd.with.overflow. 1705dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner if (!CI2->getValue().isPowerOf2()) return 0; 1706dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner unsigned NewWidth = CI2->getValue().countTrailingZeros(); 1707dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner if (NewWidth != 7 && NewWidth != 15 && NewWidth != 31) return 0; 17080cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 1709dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner // The width of the new add formed is 1 more than the bias. 1710dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner ++NewWidth; 17110cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 1712dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner // Check to see that CI1 is an all-ones value with NewWidth bits. 1713dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner if (CI1->getBitWidth() == NewWidth || 1714dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner CI1->getValue() != APInt::getLowBitsSet(CI1->getBitWidth(), NewWidth)) 1715dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner return 0; 17160cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 171754b92113e227db1d982172df18c4ad5058aae4e9Eli Friedman // This is only really a signed overflow check if the inputs have been 171854b92113e227db1d982172df18c4ad5058aae4e9Eli Friedman // sign-extended; check for that condition. For example, if CI2 is 2^31 and 171954b92113e227db1d982172df18c4ad5058aae4e9Eli Friedman // the operands of the add are 64 bits wide, we need at least 33 sign bits. 172054b92113e227db1d982172df18c4ad5058aae4e9Eli Friedman unsigned NeededSignBits = CI1->getBitWidth() - NewWidth + 1; 172154b92113e227db1d982172df18c4ad5058aae4e9Eli Friedman if (IC.ComputeNumSignBits(A) < NeededSignBits || 172254b92113e227db1d982172df18c4ad5058aae4e9Eli Friedman IC.ComputeNumSignBits(B) < NeededSignBits) 172354b92113e227db1d982172df18c4ad5058aae4e9Eli Friedman return 0; 172454b92113e227db1d982172df18c4ad5058aae4e9Eli Friedman 17250cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // In order to replace the original add with a narrower 1726dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner // llvm.sadd.with.overflow, the only uses allowed are the add-with-constant 1727dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner // and truncates that discard the high bits of the add. Verify that this is 1728dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner // the case. 1729dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner Instruction *OrigAdd = cast<Instruction>(AddWithCst->getOperand(0)); 1730dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner for (Value::use_iterator UI = OrigAdd->use_begin(), E = OrigAdd->use_end(); 1731dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner UI != E; ++UI) { 1732dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner if (*UI == AddWithCst) continue; 17330cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 1734dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner // Only accept truncates for now. We would really like a nice recursive 1735dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner // predicate like SimplifyDemandedBits, but which goes downwards the use-def 1736dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner // chain to see which bits of a value are actually demanded. If the 1737dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner // original add had another add which was then immediately truncated, we 1738dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner // could still do the transformation. 1739dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner TruncInst *TI = dyn_cast<TruncInst>(*UI); 1740dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner if (TI == 0 || 1741dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner TI->getType()->getPrimitiveSizeInBits() > NewWidth) return 0; 1742dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner } 17430cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 1744f0f568b49e111da1258902b73a7b9266222e1842Chris Lattner // If the pattern matches, truncate the inputs to the narrower type and 1745f0f568b49e111da1258902b73a7b9266222e1842Chris Lattner // use the sadd_with_overflow intrinsic to efficiently compute both the 1746f0f568b49e111da1258902b73a7b9266222e1842Chris Lattner // result and the overflow bit. 17470a62474830f50b423329470caeb9a4e4da14a607Chris Lattner Module *M = I.getParent()->getParent()->getParent(); 17480cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 17495fdd6c8793462549e3593890ec61573da06e3346Jay Foad Type *NewType = IntegerType::get(OrigAdd->getContext(), NewWidth); 17500a62474830f50b423329470caeb9a4e4da14a607Chris Lattner Value *F = Intrinsic::getDeclaration(M, Intrinsic::sadd_with_overflow, 1751eb9a85f09e18b3fe88499710404b38d3a9128f62Benjamin Kramer NewType); 17520a62474830f50b423329470caeb9a4e4da14a607Chris Lattner 17530fe80bbbb6a017169d273c4824903b52a7ea2414Chris Lattner InstCombiner::BuilderTy *Builder = IC.Builder; 17540cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 17550a62474830f50b423329470caeb9a4e4da14a607Chris Lattner // Put the new code above the original add, in case there are any uses of the 17560a62474830f50b423329470caeb9a4e4da14a607Chris Lattner // add between the add and the compare. 1757e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner Builder->SetInsertPoint(OrigAdd); 17580cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 17590a62474830f50b423329470caeb9a4e4da14a607Chris Lattner Value *TruncA = Builder->CreateTrunc(A, NewType, A->getName()+".trunc"); 17600a62474830f50b423329470caeb9a4e4da14a607Chris Lattner Value *TruncB = Builder->CreateTrunc(B, NewType, B->getName()+".trunc"); 17610a62474830f50b423329470caeb9a4e4da14a607Chris Lattner CallInst *Call = Builder->CreateCall2(F, TruncA, TruncB, "sadd"); 17620a62474830f50b423329470caeb9a4e4da14a607Chris Lattner Value *Add = Builder->CreateExtractValue(Call, 0, "sadd.result"); 17630a62474830f50b423329470caeb9a4e4da14a607Chris Lattner Value *ZExt = Builder->CreateZExt(Add, OrigAdd->getType()); 17640cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 1765f0f568b49e111da1258902b73a7b9266222e1842Chris Lattner // The inner add was the result of the narrow add, zero extended to the 1766f0f568b49e111da1258902b73a7b9266222e1842Chris Lattner // wider type. Replace it with the result computed by the intrinsic. 17670fe80bbbb6a017169d273c4824903b52a7ea2414Chris Lattner IC.ReplaceInstUsesWith(*OrigAdd, ZExt); 17680cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 17690a62474830f50b423329470caeb9a4e4da14a607Chris Lattner // The original icmp gets replaced with the overflow value. 17700a62474830f50b423329470caeb9a4e4da14a607Chris Lattner return ExtractValueInst::Create(Call, 1, "sadd.overflow"); 1771f0f568b49e111da1258902b73a7b9266222e1842Chris Lattner} 177202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 1773e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattnerstatic Instruction *ProcessUAddIdiom(Instruction &I, Value *OrigAddV, 1774e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner InstCombiner &IC) { 1775e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner // Don't bother doing this transformation for pointers, don't do it for 1776e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner // vectors. 1777e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner if (!isa<IntegerType>(OrigAddV->getType())) return 0; 17780cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 1779e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner // If the add is a constant expr, then we don't bother transforming it. 1780e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner Instruction *OrigAdd = dyn_cast<Instruction>(OrigAddV); 1781e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner if (OrigAdd == 0) return 0; 17820cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 1783e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner Value *LHS = OrigAdd->getOperand(0), *RHS = OrigAdd->getOperand(1); 17840cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 1785e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner // Put the new code above the original add, in case there are any uses of the 1786e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner // add between the add and the compare. 1787e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner InstCombiner::BuilderTy *Builder = IC.Builder; 1788e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner Builder->SetInsertPoint(OrigAdd); 1789e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner 1790e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner Module *M = I.getParent()->getParent()->getParent(); 17915fdd6c8793462549e3593890ec61573da06e3346Jay Foad Type *Ty = LHS->getType(); 1792eb9a85f09e18b3fe88499710404b38d3a9128f62Benjamin Kramer Value *F = Intrinsic::getDeclaration(M, Intrinsic::uadd_with_overflow, Ty); 1793e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner CallInst *Call = Builder->CreateCall2(F, LHS, RHS, "uadd"); 1794e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner Value *Add = Builder->CreateExtractValue(Call, 0); 1795e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner 1796e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner IC.ReplaceInstUsesWith(*OrigAdd, Add); 1797e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner 1798e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner // The original icmp gets replaced with the overflow value. 1799e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner return ExtractValueInst::Create(Call, 1, "uadd.overflow"); 1800e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner} 1801e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner 1802da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson// DemandedBitsLHSMask - When performing a comparison against a constant, 1803da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson// it is possible that not all the bits in the LHS are demanded. This helper 1804da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson// method computes the mask that IS demanded. 1805da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Andersonstatic APInt DemandedBitsLHSMask(ICmpInst &I, 1806da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson unsigned BitWidth, bool isSignCheck) { 1807da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson if (isSignCheck) 1808da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson return APInt::getSignBit(BitWidth); 18090cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 1810da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson ConstantInt *CI = dyn_cast<ConstantInt>(I.getOperand(1)); 1811da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson if (!CI) return APInt::getAllOnesValue(BitWidth); 1812a33b6254bb40488a9574533cadf4cd0b701e97d1Owen Anderson const APInt &RHS = CI->getValue(); 18130cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 1814da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson switch (I.getPredicate()) { 18150cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // For a UGT comparison, we don't care about any bits that 1816da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson // correspond to the trailing ones of the comparand. The value of these 1817da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson // bits doesn't impact the outcome of the comparison, because any value 1818da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson // greater than the RHS must differ in a bit higher than these due to carry. 1819da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson case ICmpInst::ICMP_UGT: { 1820da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson unsigned trailingOnes = RHS.countTrailingOnes(); 1821da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson APInt lowBitsSet = APInt::getLowBitsSet(BitWidth, trailingOnes); 1822da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson return ~lowBitsSet; 1823da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson } 18240cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 1825da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson // Similarly, for a ULT comparison, we don't care about the trailing zeros. 1826da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson // Any value less than the RHS must differ in a higher bit because of carries. 1827da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson case ICmpInst::ICMP_ULT: { 1828da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson unsigned trailingZeros = RHS.countTrailingZeros(); 1829da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson APInt lowBitsSet = APInt::getLowBitsSet(BitWidth, trailingZeros); 1830da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson return ~lowBitsSet; 1831da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson } 18320cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 1833da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson default: 1834da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson return APInt::getAllOnesValue(BitWidth); 1835da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson } 18360cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 1837da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson} 183802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 183902446fc99abb06d3117d65c0b1f5fba4f906db2eChris LattnerInstruction *InstCombiner::visitICmpInst(ICmpInst &I) { 184002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner bool Changed = false; 18415f670d41318368e2a5fdc6fe2d385f003c6db68dChris Lattner Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1); 18420cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 184302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner /// Orders the operands of the compare so that they are listed from most 184402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner /// complex to least complex. This puts constants before unary operators, 184502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner /// before binary operators. 18465f670d41318368e2a5fdc6fe2d385f003c6db68dChris Lattner if (getComplexity(Op0) < getComplexity(Op1)) { 184702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner I.swapOperands(); 18485f670d41318368e2a5fdc6fe2d385f003c6db68dChris Lattner std::swap(Op0, Op1); 184902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Changed = true; 185002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 18510cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 185202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Value *V = SimplifyICmpInst(I.getPredicate(), Op0, Op1, TD)) 185302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return ReplaceInstUsesWith(I, V); 18540cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 185565a6b57c330361d1075af146300d6aab9059659cPete Cooper // comparing -val or val with non-zero is the same as just comparing val 1856165695d26161912f528e0a8dca0f22e9b6cfa57bPete Cooper // ie, abs(val) != 0 -> val != 0 185765a6b57c330361d1075af146300d6aab9059659cPete Cooper if (I.getPredicate() == ICmpInst::ICMP_NE && match(Op1, m_Zero())) 185865a6b57c330361d1075af146300d6aab9059659cPete Cooper { 1859165695d26161912f528e0a8dca0f22e9b6cfa57bPete Cooper Value *Cond, *SelectTrue, *SelectFalse; 1860165695d26161912f528e0a8dca0f22e9b6cfa57bPete Cooper if (match(Op0, m_Select(m_Value(Cond), m_Value(SelectTrue), 186165a6b57c330361d1075af146300d6aab9059659cPete Cooper m_Value(SelectFalse)))) { 1862165695d26161912f528e0a8dca0f22e9b6cfa57bPete Cooper if (Value *V = dyn_castNegVal(SelectTrue)) { 1863165695d26161912f528e0a8dca0f22e9b6cfa57bPete Cooper if (V == SelectFalse) 1864165695d26161912f528e0a8dca0f22e9b6cfa57bPete Cooper return CmpInst::Create(Instruction::ICmp, I.getPredicate(), V, Op1); 1865165695d26161912f528e0a8dca0f22e9b6cfa57bPete Cooper } 1866165695d26161912f528e0a8dca0f22e9b6cfa57bPete Cooper else if (Value *V = dyn_castNegVal(SelectFalse)) { 1867165695d26161912f528e0a8dca0f22e9b6cfa57bPete Cooper if (V == SelectTrue) 1868165695d26161912f528e0a8dca0f22e9b6cfa57bPete Cooper return CmpInst::Create(Instruction::ICmp, I.getPredicate(), V, Op1); 186965a6b57c330361d1075af146300d6aab9059659cPete Cooper } 187065a6b57c330361d1075af146300d6aab9059659cPete Cooper } 187165a6b57c330361d1075af146300d6aab9059659cPete Cooper } 187265a6b57c330361d1075af146300d6aab9059659cPete Cooper 1873db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty = Op0->getType(); 187402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 187502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // icmp's with boolean values can always be turned into bitwise operations 1876b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands if (Ty->isIntegerTy(1)) { 187702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner switch (I.getPredicate()) { 187802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner default: llvm_unreachable("Invalid icmp instruction!"); 187902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_EQ: { // icmp eq i1 A, B -> ~(A^B) 188002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *Xor = Builder->CreateXor(Op0, Op1, I.getName()+"tmp"); 188102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return BinaryOperator::CreateNot(Xor); 188202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 188302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_NE: // icmp eq i1 A, B -> A^B 188402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return BinaryOperator::CreateXor(Op0, Op1); 188502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 188602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_UGT: 188702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner std::swap(Op0, Op1); // Change icmp ugt -> icmp ult 188802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // FALL THROUGH 188902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_ULT:{ // icmp ult i1 A, B -> ~A & B 189002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *Not = Builder->CreateNot(Op0, I.getName()+"tmp"); 189102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return BinaryOperator::CreateAnd(Not, Op1); 189202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 189302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_SGT: 189402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner std::swap(Op0, Op1); // Change icmp sgt -> icmp slt 189502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // FALL THROUGH 189602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_SLT: { // icmp slt i1 A, B -> A & ~B 189702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *Not = Builder->CreateNot(Op1, I.getName()+"tmp"); 189802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return BinaryOperator::CreateAnd(Not, Op0); 189902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 190002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_UGE: 190102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner std::swap(Op0, Op1); // Change icmp uge -> icmp ule 190202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // FALL THROUGH 190302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_ULE: { // icmp ule i1 A, B -> ~A | B 190402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *Not = Builder->CreateNot(Op0, I.getName()+"tmp"); 190502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return BinaryOperator::CreateOr(Not, Op1); 190602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 190702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_SGE: 190802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner std::swap(Op0, Op1); // Change icmp sge -> icmp sle 190902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // FALL THROUGH 191002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_SLE: { // icmp sle i1 A, B -> A | ~B 191102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *Not = Builder->CreateNot(Op1, I.getName()+"tmp"); 191202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return BinaryOperator::CreateOr(Not, Op0); 191302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 191402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 191502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 191602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 191702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner unsigned BitWidth = 0; 1918e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner if (Ty->isIntOrIntVectorTy()) 191902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner BitWidth = Ty->getScalarSizeInBits(); 1920e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner else if (TD) // Pointers require TD info to get their size. 1921e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner BitWidth = TD->getTypeSizeInBits(Ty->getScalarType()); 19220cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 192302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner bool isSignBit = false; 192402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 192502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // See if we are doing a comparison with a constant. 192602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(Op1)) { 192702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *A = 0, *B = 0; 19280cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 1929e63dda51c2b230215837063dba73e9299f8c0abaOwen Anderson // Match the following pattern, which is a common idiom when writing 1930e63dda51c2b230215837063dba73e9299f8c0abaOwen Anderson // overflow-safe integer arithmetic function. The source performs an 1931e63dda51c2b230215837063dba73e9299f8c0abaOwen Anderson // addition in wider type, and explicitly checks for overflow using 1932e63dda51c2b230215837063dba73e9299f8c0abaOwen Anderson // comparisons against INT_MIN and INT_MAX. Simplify this by using the 1933e63dda51c2b230215837063dba73e9299f8c0abaOwen Anderson // sadd_with_overflow intrinsic. 1934f0f568b49e111da1258902b73a7b9266222e1842Chris Lattner // 1935f0f568b49e111da1258902b73a7b9266222e1842Chris Lattner // TODO: This could probably be generalized to handle other overflow-safe 19360cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // operations if we worked out the formulas to compute the appropriate 1937e63dda51c2b230215837063dba73e9299f8c0abaOwen Anderson // magic constants. 19380cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // 1939f0f568b49e111da1258902b73a7b9266222e1842Chris Lattner // sum = a + b 1940f0f568b49e111da1258902b73a7b9266222e1842Chris Lattner // if (sum+128 >u 255) ... -> llvm.sadd.with.overflow.i8 1941e63dda51c2b230215837063dba73e9299f8c0abaOwen Anderson { 1942f0f568b49e111da1258902b73a7b9266222e1842Chris Lattner ConstantInt *CI2; // I = icmp ugt (add (add A, B), CI2), CI 1943e63dda51c2b230215837063dba73e9299f8c0abaOwen Anderson if (I.getPredicate() == ICmpInst::ICMP_UGT && 1944f0f568b49e111da1258902b73a7b9266222e1842Chris Lattner match(Op0, m_Add(m_Add(m_Value(A), m_Value(B)), m_ConstantInt(CI2)))) 19450fe80bbbb6a017169d273c4824903b52a7ea2414Chris Lattner if (Instruction *Res = ProcessUGT_ADDCST_ADD(I, A, B, CI2, CI, *this)) 1946f0f568b49e111da1258902b73a7b9266222e1842Chris Lattner return Res; 1947e63dda51c2b230215837063dba73e9299f8c0abaOwen Anderson } 19480cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 194902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (icmp ne/eq (sub A B) 0) -> (icmp ne/eq A, B) 195002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (I.isEquality() && CI->isZero() && 195102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner match(Op0, m_Sub(m_Value(A), m_Value(B)))) { 195202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (icmp cond A B) if cond is equality 195302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(I.getPredicate(), A, B); 195402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 19550cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 195602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If we have an icmp le or icmp ge instruction, turn it into the 195702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // appropriate icmp lt or icmp gt instruction. This allows us to rely on 195802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // them being folded in the code below. The SimplifyICmpInst code has 195902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // already handled the edge cases for us, so we just assert on them. 196002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner switch (I.getPredicate()) { 196102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner default: break; 196202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_ULE: 196302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner assert(!CI->isMaxValue(false)); // A <=u MAX -> TRUE 196402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_ULT, Op0, 196502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt::get(CI->getContext(), CI->getValue()+1)); 196602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_SLE: 196702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner assert(!CI->isMaxValue(true)); // A <=s MAX -> TRUE 196802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_SLT, Op0, 196902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt::get(CI->getContext(), CI->getValue()+1)); 197002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_UGE: 1971d8d1584c13c554349c235177b2b89cb5117347b2Nick Lewycky assert(!CI->isMinValue(false)); // A >=u MIN -> TRUE 197202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_UGT, Op0, 197302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt::get(CI->getContext(), CI->getValue()-1)); 197402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_SGE: 1975d8d1584c13c554349c235177b2b89cb5117347b2Nick Lewycky assert(!CI->isMinValue(true)); // A >=s MIN -> TRUE 197602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_SGT, Op0, 197702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt::get(CI->getContext(), CI->getValue()-1)); 197802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 19790cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 198002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If this comparison is a normal comparison, it demands all 198102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // bits, if it is a sign bit comparison, it only demands the sign bit. 198202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner bool UnusedBit; 198302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner isSignBit = isSignBitCheck(I.getPredicate(), CI, UnusedBit); 198402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 198502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 198602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // See if we can fold the comparison based on range information we can get 198702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // by checking whether bits are known to be zero or one in the input. 198802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (BitWidth != 0) { 198902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner APInt Op0KnownZero(BitWidth, 0), Op0KnownOne(BitWidth, 0); 199002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner APInt Op1KnownZero(BitWidth, 0), Op1KnownOne(BitWidth, 0); 199102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 199202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (SimplifyDemandedBits(I.getOperandUse(0), 1993da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson DemandedBitsLHSMask(I, BitWidth, isSignBit), 199402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Op0KnownZero, Op0KnownOne, 0)) 199502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return &I; 199602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (SimplifyDemandedBits(I.getOperandUse(1), 199702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner APInt::getAllOnesValue(BitWidth), 199802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Op1KnownZero, Op1KnownOne, 0)) 199902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return &I; 200002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 200102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Given the known and unknown bits, compute a range that the LHS could be 200202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // in. Compute the Min, Max and RHS values based on the known bits. For the 200302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // EQ and NE we use unsigned values. 200402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner APInt Op0Min(BitWidth, 0), Op0Max(BitWidth, 0); 200502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner APInt Op1Min(BitWidth, 0), Op1Max(BitWidth, 0); 200602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (I.isSigned()) { 200702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ComputeSignedMinMaxValuesFromKnownBits(Op0KnownZero, Op0KnownOne, 200802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Op0Min, Op0Max); 200902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ComputeSignedMinMaxValuesFromKnownBits(Op1KnownZero, Op1KnownOne, 201002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Op1Min, Op1Max); 201102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else { 201202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ComputeUnsignedMinMaxValuesFromKnownBits(Op0KnownZero, Op0KnownOne, 201302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Op0Min, Op0Max); 201402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ComputeUnsignedMinMaxValuesFromKnownBits(Op1KnownZero, Op1KnownOne, 201502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Op1Min, Op1Max); 201602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 201702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 201802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If Min and Max are known to be the same, then SimplifyDemandedBits 201902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // figured out that the LHS is a constant. Just constant fold this now so 202002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // that code below can assume that Min != Max. 202102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!isa<Constant>(Op0) && Op0Min == Op0Max) 202202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(I.getPredicate(), 2023d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky ConstantInt::get(Op0->getType(), Op0Min), Op1); 202402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!isa<Constant>(Op1) && Op1Min == Op1Max) 202502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(I.getPredicate(), Op0, 2026d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky ConstantInt::get(Op1->getType(), Op1Min)); 202702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 202802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Based on the range information we know about the LHS, see if we can 2029d8d1584c13c554349c235177b2b89cb5117347b2Nick Lewycky // simplify this comparison. For example, (x&4) < 8 is always true. 203002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner switch (I.getPredicate()) { 203102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner default: llvm_unreachable("Unknown icmp opcode!"); 203275d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner case ICmpInst::ICMP_EQ: { 203302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op0Max.ult(Op1Min) || Op0Min.ugt(Op1Max)) 2034d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ReplaceInstUsesWith(I, ConstantInt::getFalse(I.getType())); 20350cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 203675d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner // If all bits are known zero except for one, then we know at most one 203775d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner // bit is set. If the comparison is against zero, then this is a check 203875d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner // to see if *that* bit is set. 203975d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner APInt Op0KnownZeroInverted = ~Op0KnownZero; 204075d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner if (~Op1KnownZero == 0 && Op0KnownZeroInverted.isPowerOf2()) { 204175d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner // If the LHS is an AND with the same constant, look through it. 204275d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner Value *LHS = 0; 204375d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner ConstantInt *LHSC = 0; 204475d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner if (!match(Op0, m_And(m_Value(LHS), m_ConstantInt(LHSC))) || 204575d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner LHSC->getValue() != Op0KnownZeroInverted) 204675d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner LHS = Op0; 20470cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 204875d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner // If the LHS is 1 << x, and we know the result is a power of 2 like 8, 204979b967bd9fed0a3147d704ce269af6cc26aff391Chris Lattner // then turn "((1 << x)&8) == 0" into "x != 3". 205075d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner Value *X = 0; 205175d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner if (match(LHS, m_Shl(m_One(), m_Value(X)))) { 205275d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner unsigned CmpVal = Op0KnownZeroInverted.countTrailingZeros(); 205379b967bd9fed0a3147d704ce269af6cc26aff391Chris Lattner return new ICmpInst(ICmpInst::ICMP_NE, X, 205475d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner ConstantInt::get(X->getType(), CmpVal)); 205575d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner } 20560cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 205775d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner // If the LHS is 8 >>u x, and we know the result is a power of 2 like 1, 205879b967bd9fed0a3147d704ce269af6cc26aff391Chris Lattner // then turn "((8 >>u x)&1) == 0" into "x != 3". 2059b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner const APInt *CI; 206075d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner if (Op0KnownZeroInverted == 1 && 2061b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner match(LHS, m_LShr(m_Power2(CI), m_Value(X)))) 206279b967bd9fed0a3147d704ce269af6cc26aff391Chris Lattner return new ICmpInst(ICmpInst::ICMP_NE, X, 2063b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner ConstantInt::get(X->getType(), 2064b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner CI->countTrailingZeros())); 206575d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner } 20660cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 206702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 206875d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner } 206975d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner case ICmpInst::ICMP_NE: { 207002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op0Max.ult(Op1Min) || Op0Min.ugt(Op1Max)) 2071d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ReplaceInstUsesWith(I, ConstantInt::getTrue(I.getType())); 20720cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 207375d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner // If all bits are known zero except for one, then we know at most one 207475d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner // bit is set. If the comparison is against zero, then this is a check 207575d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner // to see if *that* bit is set. 207675d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner APInt Op0KnownZeroInverted = ~Op0KnownZero; 207775d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner if (~Op1KnownZero == 0 && Op0KnownZeroInverted.isPowerOf2()) { 207875d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner // If the LHS is an AND with the same constant, look through it. 207975d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner Value *LHS = 0; 208075d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner ConstantInt *LHSC = 0; 208175d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner if (!match(Op0, m_And(m_Value(LHS), m_ConstantInt(LHSC))) || 208275d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner LHSC->getValue() != Op0KnownZeroInverted) 208375d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner LHS = Op0; 20840cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 208575d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner // If the LHS is 1 << x, and we know the result is a power of 2 like 8, 208679b967bd9fed0a3147d704ce269af6cc26aff391Chris Lattner // then turn "((1 << x)&8) != 0" into "x == 3". 208775d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner Value *X = 0; 208875d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner if (match(LHS, m_Shl(m_One(), m_Value(X)))) { 208975d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner unsigned CmpVal = Op0KnownZeroInverted.countTrailingZeros(); 209079b967bd9fed0a3147d704ce269af6cc26aff391Chris Lattner return new ICmpInst(ICmpInst::ICMP_EQ, X, 209175d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner ConstantInt::get(X->getType(), CmpVal)); 209275d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner } 20930cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 209475d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner // If the LHS is 8 >>u x, and we know the result is a power of 2 like 1, 209579b967bd9fed0a3147d704ce269af6cc26aff391Chris Lattner // then turn "((8 >>u x)&1) != 0" into "x == 3". 2096b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner const APInt *CI; 209775d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner if (Op0KnownZeroInverted == 1 && 2098b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner match(LHS, m_LShr(m_Power2(CI), m_Value(X)))) 209979b967bd9fed0a3147d704ce269af6cc26aff391Chris Lattner return new ICmpInst(ICmpInst::ICMP_EQ, X, 2100b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner ConstantInt::get(X->getType(), 2101b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner CI->countTrailingZeros())); 210275d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner } 21030cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 210402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 210575d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner } 210602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_ULT: 210702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op0Max.ult(Op1Min)) // A <u B -> true if max(A) < min(B) 2108d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ReplaceInstUsesWith(I, ConstantInt::getTrue(I.getType())); 210902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op0Min.uge(Op1Max)) // A <u B -> false if min(A) >= max(B) 2110d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ReplaceInstUsesWith(I, ConstantInt::getFalse(I.getType())); 211102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op1Min == Op0Max) // A <u B -> A != B if max(A) == min(B) 211202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_NE, Op0, Op1); 211302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(Op1)) { 211402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op1Max == Op0Min+1) // A <u C -> A == C-1 if min(A)+1 == C 211502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_EQ, Op0, 211602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt::get(CI->getContext(), CI->getValue()-1)); 211702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 211802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (x <u 2147483648) -> (x >s -1) -> true if sign bit clear 211902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (CI->isMinValue(true)) 212002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_SGT, Op0, 212102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant::getAllOnesValue(Op0->getType())); 212202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 212302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 212402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_UGT: 212502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op0Min.ugt(Op1Max)) // A >u B -> true if min(A) > max(B) 2126d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ReplaceInstUsesWith(I, ConstantInt::getTrue(I.getType())); 212702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op0Max.ule(Op1Min)) // A >u B -> false if max(A) <= max(B) 2128d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ReplaceInstUsesWith(I, ConstantInt::getFalse(I.getType())); 212902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 213002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op1Max == Op0Min) // A >u B -> A != B if min(A) == max(B) 213102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_NE, Op0, Op1); 213202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(Op1)) { 213302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op1Min == Op0Max-1) // A >u C -> A == C+1 if max(a)-1 == C 213402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_EQ, Op0, 213502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt::get(CI->getContext(), CI->getValue()+1)); 213602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 213702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (x >u 2147483647) -> (x <s 0) -> true if sign bit set 213802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (CI->isMaxValue(true)) 213902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_SLT, Op0, 214002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant::getNullValue(Op0->getType())); 214102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 214202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 214302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_SLT: 214402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op0Max.slt(Op1Min)) // A <s B -> true if max(A) < min(C) 2145d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ReplaceInstUsesWith(I, ConstantInt::getTrue(I.getType())); 214602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op0Min.sge(Op1Max)) // A <s B -> false if min(A) >= max(C) 2147d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ReplaceInstUsesWith(I, ConstantInt::getFalse(I.getType())); 214802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op1Min == Op0Max) // A <s B -> A != B if max(A) == min(B) 214902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_NE, Op0, Op1); 215002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(Op1)) { 215102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op1Max == Op0Min+1) // A <s C -> A == C-1 if min(A)+1 == C 215202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_EQ, Op0, 215302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt::get(CI->getContext(), CI->getValue()-1)); 215402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 215502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 215602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_SGT: 215702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op0Min.sgt(Op1Max)) // A >s B -> true if min(A) > max(B) 2158d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ReplaceInstUsesWith(I, ConstantInt::getTrue(I.getType())); 215902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op0Max.sle(Op1Min)) // A >s B -> false if max(A) <= min(B) 2160d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ReplaceInstUsesWith(I, ConstantInt::getFalse(I.getType())); 216102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 216202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op1Max == Op0Min) // A >s B -> A != B if min(A) == max(B) 216302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_NE, Op0, Op1); 216402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(Op1)) { 216502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op1Min == Op0Max-1) // A >s C -> A == C+1 if max(A)-1 == C 216602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_EQ, Op0, 216702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt::get(CI->getContext(), CI->getValue()+1)); 216802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 216902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 217002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_SGE: 217102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner assert(!isa<ConstantInt>(Op1) && "ICMP_SGE with ConstantInt not folded!"); 217202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op0Min.sge(Op1Max)) // A >=s B -> true if min(A) >= max(B) 2173d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ReplaceInstUsesWith(I, ConstantInt::getTrue(I.getType())); 217402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op0Max.slt(Op1Min)) // A >=s B -> false if max(A) < min(B) 2175d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ReplaceInstUsesWith(I, ConstantInt::getFalse(I.getType())); 217602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 217702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_SLE: 217802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner assert(!isa<ConstantInt>(Op1) && "ICMP_SLE with ConstantInt not folded!"); 217902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op0Max.sle(Op1Min)) // A <=s B -> true if max(A) <= min(B) 2180d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ReplaceInstUsesWith(I, ConstantInt::getTrue(I.getType())); 218102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op0Min.sgt(Op1Max)) // A <=s B -> false if min(A) > max(B) 2182d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ReplaceInstUsesWith(I, ConstantInt::getFalse(I.getType())); 218302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 218402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_UGE: 218502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner assert(!isa<ConstantInt>(Op1) && "ICMP_UGE with ConstantInt not folded!"); 218602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op0Min.uge(Op1Max)) // A >=u B -> true if min(A) >= max(B) 2187d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ReplaceInstUsesWith(I, ConstantInt::getTrue(I.getType())); 218802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op0Max.ult(Op1Min)) // A >=u B -> false if max(A) < min(B) 2189d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ReplaceInstUsesWith(I, ConstantInt::getFalse(I.getType())); 219002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 219102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_ULE: 219202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner assert(!isa<ConstantInt>(Op1) && "ICMP_ULE with ConstantInt not folded!"); 219302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op0Max.ule(Op1Min)) // A <=u B -> true if max(A) <= min(B) 2194d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ReplaceInstUsesWith(I, ConstantInt::getTrue(I.getType())); 219502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op0Min.ugt(Op1Max)) // A <=u B -> false if min(A) > max(B) 2196d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ReplaceInstUsesWith(I, ConstantInt::getFalse(I.getType())); 219702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 219802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 219902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 220002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Turn a signed comparison into an unsigned one if both operands 220102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // are known to have the same sign. 220202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (I.isSigned() && 220302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ((Op0KnownZero.isNegative() && Op1KnownZero.isNegative()) || 220402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner (Op0KnownOne.isNegative() && Op1KnownOne.isNegative()))) 220502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(I.getUnsignedPredicate(), Op0, Op1); 220602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 220702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 220802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Test if the ICmpInst instruction is used exclusively by a select as 220902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // part of a minimum or maximum operation. If so, refrain from doing 221002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // any other folding. This helps out other analyses which understand 221102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // non-obfuscated minimum and maximum idioms, such as ScalarEvolution 221202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // and CodeGen. And in this case, at least one of the comparison 221302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // operands has at least one user besides the compare (the select), 221402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // which would often largely negate the benefit of folding anyway. 221502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (I.hasOneUse()) 221602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (SelectInst *SI = dyn_cast<SelectInst>(*I.use_begin())) 221702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if ((SI->getOperand(1) == Op0 && SI->getOperand(2) == Op1) || 221802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner (SI->getOperand(2) == Op0 && SI->getOperand(1) == Op1)) 221902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return 0; 222002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 222102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // See if we are doing a comparison between a constant and an instruction that 222202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // can be folded into the comparison. 222302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(Op1)) { 22240cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // Since the RHS is a ConstantInt (CI), if the left hand side is an 22250cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // instruction, see if that instruction also has constants so that the 22260cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // instruction can be folded into the icmp 222702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Instruction *LHSI = dyn_cast<Instruction>(Op0)) 222802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Instruction *Res = visitICmpInstWithInstAndIntCst(I, LHSI, CI)) 222902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return Res; 223002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 223102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 223202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Handle icmp with constant (but not simple integer constant) RHS 223302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Constant *RHSC = dyn_cast<Constant>(Op1)) { 223402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Instruction *LHSI = dyn_cast<Instruction>(Op0)) 223502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner switch (LHSI->getOpcode()) { 223602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::GetElementPtr: 223702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // icmp pred GEP (P, int 0, int 0, int 0), null -> icmp pred P, null 223802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (RHSC->isNullValue() && 223902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner cast<GetElementPtrInst>(LHSI)->hasAllZeroIndices()) 224002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(I.getPredicate(), LHSI->getOperand(0), 224102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant::getNullValue(LHSI->getOperand(0)->getType())); 224202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 224302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::PHI: 224402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Only fold icmp into the PHI if the phi and icmp are in the same 224502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // block. If in the same block, we're encouraging jump threading. If 224602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // not, we are just pessimizing the code by making an i1 phi. 224702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (LHSI->getParent() == I.getParent()) 22489922ccf4b483ce37524047879f9b2f9bb73e3ccbChris Lattner if (Instruction *NV = FoldOpIntoPhi(I)) 224902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return NV; 225002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 225102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::Select: { 225202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If either operand of the select is a constant, we can fold the 225302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // comparison into the select arms, which will cause one to be 225402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // constant folded and the select turned into a bitwise or. 225502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *Op1 = 0, *Op2 = 0; 225602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Constant *C = dyn_cast<Constant>(LHSI->getOperand(1))) 225702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Op1 = ConstantExpr::getICmp(I.getPredicate(), C, RHSC); 225802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Constant *C = dyn_cast<Constant>(LHSI->getOperand(2))) 225902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Op2 = ConstantExpr::getICmp(I.getPredicate(), C, RHSC); 226002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 226102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // We only want to perform this transformation if it will not lead to 226202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // additional code. This is true if either both sides of the select 226302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // fold to a constant (in which case the icmp is replaced with a select 226402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // which will usually simplify) or this is the only user of the 226502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // select (in which case we are trading a select+icmp for a simpler 226602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // select+icmp). 226702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if ((Op1 && Op2) || (LHSI->hasOneUse() && (Op1 || Op2))) { 226802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!Op1) 226902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Op1 = Builder->CreateICmp(I.getPredicate(), LHSI->getOperand(1), 227002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner RHSC, I.getName()); 227102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!Op2) 227202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Op2 = Builder->CreateICmp(I.getPredicate(), LHSI->getOperand(2), 227302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner RHSC, I.getName()); 227402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return SelectInst::Create(LHSI->getOperand(0), Op1, Op2); 227502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 227602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 227702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 227802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::IntToPtr: 227902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // icmp pred inttoptr(X), null -> icmp pred X, 0 228002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (RHSC->isNullValue() && TD && 2281ece6c6bb6329748b92403c06ac87f45c43485911Chandler Carruth TD->getIntPtrType(RHSC->getContext()) == 228202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner LHSI->getOperand(0)->getType()) 228302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(I.getPredicate(), LHSI->getOperand(0), 228402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant::getNullValue(LHSI->getOperand(0)->getType())); 228502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 228602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 228702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::Load: 228802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Try to optimize things like "A[i] > 4" to index computations. 228902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (GetElementPtrInst *GEP = 229002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner dyn_cast<GetElementPtrInst>(LHSI->getOperand(0))) { 229102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (GlobalVariable *GV = dyn_cast<GlobalVariable>(GEP->getOperand(0))) 229202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (GV->isConstant() && GV->hasDefinitiveInitializer() && 229302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner !cast<LoadInst>(LHSI)->isVolatile()) 229402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Instruction *Res = FoldCmpLoadFromIndexedGlobal(GEP, GV, I)) 229502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return Res; 229602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 229702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 229802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 229902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 230002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 230102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If we can optimize a 'icmp GEP, P' or 'icmp P, GEP', do so now. 230202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (GEPOperator *GEP = dyn_cast<GEPOperator>(Op0)) 230302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Instruction *NI = FoldGEPICmp(GEP, Op1, I.getPredicate(), I)) 230402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return NI; 230502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (GEPOperator *GEP = dyn_cast<GEPOperator>(Op1)) 230602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Instruction *NI = FoldGEPICmp(GEP, Op0, 230702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ICmpInst::getSwappedPredicate(I.getPredicate()), I)) 230802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return NI; 230902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 231002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Test to see if the operands of the icmp are casted versions of other 231102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // values. If the ptr->ptr cast can be stripped off both arguments, we do so 231202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // now. 231302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (BitCastInst *CI = dyn_cast<BitCastInst>(Op0)) { 23140cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach if (Op0->getType()->isPointerTy() && 23150cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach (isa<Constant>(Op1) || isa<BitCastInst>(Op1))) { 231602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // We keep moving the cast from the left operand over to the right 231702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // operand, where it can often be eliminated completely. 231802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Op0 = CI->getOperand(0); 231902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 232002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If operand #1 is a bitcast instruction, it must also be a ptr->ptr cast 232102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // so eliminate it as well. 232202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (BitCastInst *CI2 = dyn_cast<BitCastInst>(Op1)) 232302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Op1 = CI2->getOperand(0); 232402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 232502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If Op1 is a constant, we can fold the cast into the constant. 232602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op0->getType() != Op1->getType()) { 232702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Constant *Op1C = dyn_cast<Constant>(Op1)) { 232802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Op1 = ConstantExpr::getBitCast(Op1C, Op0->getType()); 232902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else { 233002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Otherwise, cast the RHS right before the icmp 233102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Op1 = Builder->CreateBitCast(Op1, Op0->getType()); 233202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 233302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 233402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(I.getPredicate(), Op0, Op1); 233502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 233602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 23370cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 233802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (isa<CastInst>(Op0)) { 233902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Handle the special case of: icmp (cast bool to X), <cst> 234002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // This comes up when you have code like 234102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // int X = A < B; 234202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // if (X) ... 234302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // For generality, we handle any zero-extension of any operand comparison 234402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // with a constant or another cast from the same type. 234502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (isa<Constant>(Op1) || isa<CastInst>(Op1)) 234602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Instruction *R = visitICmpInstWithCastAndCast(I)) 234702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return R; 234802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 2349a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands 2350a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands // Special logic for binary operators. 2351a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands BinaryOperator *BO0 = dyn_cast<BinaryOperator>(Op0); 2352a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands BinaryOperator *BO1 = dyn_cast<BinaryOperator>(Op1); 2353a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands if (BO0 || BO1) { 2354a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands CmpInst::Predicate Pred = I.getPredicate(); 2355a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands bool NoOp0WrapProblem = false, NoOp1WrapProblem = false; 2356a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands if (BO0 && isa<OverflowingBinaryOperator>(BO0)) 2357a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands NoOp0WrapProblem = ICmpInst::isEquality(Pred) || 2358a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands (CmpInst::isUnsigned(Pred) && BO0->hasNoUnsignedWrap()) || 2359a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands (CmpInst::isSigned(Pred) && BO0->hasNoSignedWrap()); 2360a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands if (BO1 && isa<OverflowingBinaryOperator>(BO1)) 2361a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands NoOp1WrapProblem = ICmpInst::isEquality(Pred) || 2362a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands (CmpInst::isUnsigned(Pred) && BO1->hasNoUnsignedWrap()) || 2363a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands (CmpInst::isSigned(Pred) && BO1->hasNoSignedWrap()); 2364a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands 2365a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands // Analyze the case when either Op0 or Op1 is an add instruction. 2366a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands // Op0 = A + B (or A and B are null); Op1 = C + D (or C and D are null). 2367a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands Value *A = 0, *B = 0, *C = 0, *D = 0; 2368a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands if (BO0 && BO0->getOpcode() == Instruction::Add) 2369a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands A = BO0->getOperand(0), B = BO0->getOperand(1); 2370a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands if (BO1 && BO1->getOpcode() == Instruction::Add) 2371a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands C = BO1->getOperand(0), D = BO1->getOperand(1); 2372a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands 2373a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands // icmp (X+Y), X -> icmp Y, 0 for equalities or if there is no overflow. 2374a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands if ((A == Op1 || B == Op1) && NoOp0WrapProblem) 2375a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands return new ICmpInst(Pred, A == Op1 ? B : A, 2376a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands Constant::getNullValue(Op1->getType())); 2377a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands 2378a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands // icmp X, (X+Y) -> icmp 0, Y for equalities or if there is no overflow. 2379a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands if ((C == Op0 || D == Op0) && NoOp1WrapProblem) 2380a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands return new ICmpInst(Pred, Constant::getNullValue(Op0->getType()), 2381a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands C == Op0 ? D : C); 2382a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands 238339a7de72c8b5013f32802ceacefaaf6697726c28Duncan Sands // icmp (X+Y), (X+Z) -> icmp Y, Z for equalities or if there is no overflow. 2384a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands if (A && C && (A == C || A == D || B == C || B == D) && 2385a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands NoOp0WrapProblem && NoOp1WrapProblem && 2386a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands // Try not to increase register pressure. 2387a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands BO0->hasOneUse() && BO1->hasOneUse()) { 2388a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands // Determine Y and Z in the form icmp (X+Y), (X+Z). 2389afe4539f8ea9e12404dce0d67b421d8decb2f0fbDuncan Sands Value *Y, *Z; 2390afe4539f8ea9e12404dce0d67b421d8decb2f0fbDuncan Sands if (A == C) { 23914f0dfbb454ea8110459e2d1ee5f92e74cb3e8a5cDuncan Sands // C + B == C + D -> B == D 2392afe4539f8ea9e12404dce0d67b421d8decb2f0fbDuncan Sands Y = B; 2393afe4539f8ea9e12404dce0d67b421d8decb2f0fbDuncan Sands Z = D; 2394afe4539f8ea9e12404dce0d67b421d8decb2f0fbDuncan Sands } else if (A == D) { 23954f0dfbb454ea8110459e2d1ee5f92e74cb3e8a5cDuncan Sands // D + B == C + D -> B == C 2396afe4539f8ea9e12404dce0d67b421d8decb2f0fbDuncan Sands Y = B; 2397afe4539f8ea9e12404dce0d67b421d8decb2f0fbDuncan Sands Z = C; 2398afe4539f8ea9e12404dce0d67b421d8decb2f0fbDuncan Sands } else if (B == C) { 23994f0dfbb454ea8110459e2d1ee5f92e74cb3e8a5cDuncan Sands // A + C == C + D -> A == D 2400afe4539f8ea9e12404dce0d67b421d8decb2f0fbDuncan Sands Y = A; 2401afe4539f8ea9e12404dce0d67b421d8decb2f0fbDuncan Sands Z = D; 24024f0dfbb454ea8110459e2d1ee5f92e74cb3e8a5cDuncan Sands } else { 24034f0dfbb454ea8110459e2d1ee5f92e74cb3e8a5cDuncan Sands assert(B == D); 24044f0dfbb454ea8110459e2d1ee5f92e74cb3e8a5cDuncan Sands // A + D == C + D -> A == C 2405afe4539f8ea9e12404dce0d67b421d8decb2f0fbDuncan Sands Y = A; 2406afe4539f8ea9e12404dce0d67b421d8decb2f0fbDuncan Sands Z = C; 2407afe4539f8ea9e12404dce0d67b421d8decb2f0fbDuncan Sands } 2408a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands return new ICmpInst(Pred, Y, Z); 2409a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands } 2410a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands 2411a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands // Analyze the case when either Op0 or Op1 is a sub instruction. 2412a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands // Op0 = A - B (or A and B are null); Op1 = C - D (or C and D are null). 2413a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands A = 0; B = 0; C = 0; D = 0; 2414a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands if (BO0 && BO0->getOpcode() == Instruction::Sub) 2415a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands A = BO0->getOperand(0), B = BO0->getOperand(1); 2416a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands if (BO1 && BO1->getOpcode() == Instruction::Sub) 2417a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands C = BO1->getOperand(0), D = BO1->getOperand(1); 2418a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands 241939a7de72c8b5013f32802ceacefaaf6697726c28Duncan Sands // icmp (X-Y), X -> icmp 0, Y for equalities or if there is no overflow. 242039a7de72c8b5013f32802ceacefaaf6697726c28Duncan Sands if (A == Op1 && NoOp0WrapProblem) 242139a7de72c8b5013f32802ceacefaaf6697726c28Duncan Sands return new ICmpInst(Pred, Constant::getNullValue(Op1->getType()), B); 242239a7de72c8b5013f32802ceacefaaf6697726c28Duncan Sands 242339a7de72c8b5013f32802ceacefaaf6697726c28Duncan Sands // icmp X, (X-Y) -> icmp Y, 0 for equalities or if there is no overflow. 242439a7de72c8b5013f32802ceacefaaf6697726c28Duncan Sands if (C == Op0 && NoOp1WrapProblem) 242539a7de72c8b5013f32802ceacefaaf6697726c28Duncan Sands return new ICmpInst(Pred, D, Constant::getNullValue(Op0->getType())); 242639a7de72c8b5013f32802ceacefaaf6697726c28Duncan Sands 242739a7de72c8b5013f32802ceacefaaf6697726c28Duncan Sands // icmp (Y-X), (Z-X) -> icmp Y, Z for equalities or if there is no overflow. 2428a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands if (B && D && B == D && NoOp0WrapProblem && NoOp1WrapProblem && 2429a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands // Try not to increase register pressure. 2430a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands BO0->hasOneUse() && BO1->hasOneUse()) 2431a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands return new ICmpInst(Pred, A, C); 2432a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands 243339a7de72c8b5013f32802ceacefaaf6697726c28Duncan Sands // icmp (X-Y), (X-Z) -> icmp Z, Y for equalities or if there is no overflow. 243439a7de72c8b5013f32802ceacefaaf6697726c28Duncan Sands if (A && C && A == C && NoOp0WrapProblem && NoOp1WrapProblem && 243539a7de72c8b5013f32802ceacefaaf6697726c28Duncan Sands // Try not to increase register pressure. 243639a7de72c8b5013f32802ceacefaaf6697726c28Duncan Sands BO0->hasOneUse() && BO1->hasOneUse()) 243739a7de72c8b5013f32802ceacefaaf6697726c28Duncan Sands return new ICmpInst(Pred, D, B); 243839a7de72c8b5013f32802ceacefaaf6697726c28Duncan Sands 24399feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky BinaryOperator *SRem = NULL; 2440dcf77575d25ad4841e585afa27bc5ee62b32d9fdNick Lewycky // icmp (srem X, Y), Y 24419feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky if (BO0 && BO0->getOpcode() == Instruction::SRem && 24429feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky Op1 == BO0->getOperand(1)) 24439feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky SRem = BO0; 2444dcf77575d25ad4841e585afa27bc5ee62b32d9fdNick Lewycky // icmp Y, (srem X, Y) 24459feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky else if (BO1 && BO1->getOpcode() == Instruction::SRem && 24469feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky Op0 == BO1->getOperand(1)) 24479feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky SRem = BO1; 24489feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky if (SRem) { 24499feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky // We don't check hasOneUse to avoid increasing register pressure because 24509feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky // the value we use is the same value this instruction was already using. 24519feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky switch (SRem == BO0 ? ICmpInst::getSwappedPredicate(Pred) : Pred) { 24529feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky default: break; 24539feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky case ICmpInst::ICMP_EQ: 2454d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ReplaceInstUsesWith(I, ConstantInt::getFalse(I.getType())); 24559feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky case ICmpInst::ICMP_NE: 2456d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ReplaceInstUsesWith(I, ConstantInt::getTrue(I.getType())); 24579feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky case ICmpInst::ICMP_SGT: 24589feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky case ICmpInst::ICMP_SGE: 24599feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky return new ICmpInst(ICmpInst::ICMP_SGT, SRem->getOperand(1), 24609feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky Constant::getAllOnesValue(SRem->getType())); 24619feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky case ICmpInst::ICMP_SLT: 24629feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky case ICmpInst::ICMP_SLE: 24639feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky return new ICmpInst(ICmpInst::ICMP_SLT, SRem->getOperand(1), 24649feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky Constant::getNullValue(SRem->getType())); 24659feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky } 24669feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky } 24679feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky 2468a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands if (BO0 && BO1 && BO0->getOpcode() == BO1->getOpcode() && 2469a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands BO0->hasOneUse() && BO1->hasOneUse() && 2470a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands BO0->getOperand(1) == BO1->getOperand(1)) { 2471a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands switch (BO0->getOpcode()) { 2472a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands default: break; 2473a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands case Instruction::Add: 2474a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands case Instruction::Sub: 2475a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands case Instruction::Xor: 2476a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands if (I.isEquality()) // a+x icmp eq/ne b+x --> a icmp b 2477a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands return new ICmpInst(I.getPredicate(), BO0->getOperand(0), 2478a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands BO1->getOperand(0)); 2479a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands // icmp u/s (a ^ signbit), (b ^ signbit) --> icmp s/u a, b 2480a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands if (ConstantInt *CI = dyn_cast<ConstantInt>(BO0->getOperand(1))) { 2481a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands if (CI->getValue().isSignBit()) { 2482a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands ICmpInst::Predicate Pred = I.isSigned() 2483a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands ? I.getUnsignedPredicate() 2484a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands : I.getSignedPredicate(); 2485a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands return new ICmpInst(Pred, BO0->getOperand(0), 2486a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands BO1->getOperand(0)); 2487a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands } 24880cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 2489c73b24db5f6226ed44ebc44ce1c25bb357206623Chris Lattner if (CI->isMaxValue(true)) { 2490a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands ICmpInst::Predicate Pred = I.isSigned() 2491a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands ? I.getUnsignedPredicate() 2492a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands : I.getSignedPredicate(); 2493a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands Pred = I.getSwappedPredicate(Pred); 2494a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands return new ICmpInst(Pred, BO0->getOperand(0), 2495a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands BO1->getOperand(0)); 249602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 2497a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands } 2498a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands break; 2499a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands case Instruction::Mul: 2500a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands if (!I.isEquality()) 250102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 250202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 2503a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands if (ConstantInt *CI = dyn_cast<ConstantInt>(BO0->getOperand(1))) { 2504a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands // a * Cst icmp eq/ne b * Cst --> a & Mask icmp b & Mask 2505a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands // Mask = -1 >> count-trailing-zeros(Cst). 2506a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands if (!CI->isZero() && !CI->isOne()) { 2507a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands const APInt &AP = CI->getValue(); 25080cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach ConstantInt *Mask = ConstantInt::get(I.getContext(), 2509a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands APInt::getLowBitsSet(AP.getBitWidth(), 2510a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands AP.getBitWidth() - 2511a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands AP.countTrailingZeros())); 2512a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands Value *And1 = Builder->CreateAnd(BO0->getOperand(0), Mask); 2513a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands Value *And2 = Builder->CreateAnd(BO1->getOperand(0), Mask); 2514a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands return new ICmpInst(I.getPredicate(), And1, And2); 251502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 251602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 2517a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands break; 251858bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::UDiv: 251958bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::LShr: 252058bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (I.isSigned()) 252158bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 252258bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky // fall-through 252358bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::SDiv: 252458bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::AShr: 2525b6e7cd655c6ee119dbeacc321ee92387f983edb0Eli Friedman if (!BO0->isExact() || !BO1->isExact()) 252658bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 252758bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky return new ICmpInst(I.getPredicate(), BO0->getOperand(0), 252858bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky BO1->getOperand(0)); 252958bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::Shl: { 253058bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky bool NUW = BO0->hasNoUnsignedWrap() && BO1->hasNoUnsignedWrap(); 253158bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky bool NSW = BO0->hasNoSignedWrap() && BO1->hasNoSignedWrap(); 253258bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (!NUW && !NSW) 253358bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 253458bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (!NSW && I.isSigned()) 253558bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 253658bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky return new ICmpInst(I.getPredicate(), BO0->getOperand(0), 253758bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky BO1->getOperand(0)); 253858bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky } 253902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 254002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 254102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 25420cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 254302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner { Value *A, *B; 2544fdb5b01df486f8fca44927a38dc9763e9d538e4cChris Lattner // ~x < ~y --> y < x 2545fdb5b01df486f8fca44927a38dc9763e9d538e4cChris Lattner // ~x < cst --> ~cst < x 2546fdb5b01df486f8fca44927a38dc9763e9d538e4cChris Lattner if (match(Op0, m_Not(m_Value(A)))) { 2547fdb5b01df486f8fca44927a38dc9763e9d538e4cChris Lattner if (match(Op1, m_Not(m_Value(B)))) 2548fdb5b01df486f8fca44927a38dc9763e9d538e4cChris Lattner return new ICmpInst(I.getPredicate(), B, A); 254927a98482bd70dd12eecd02ad600f78a2fc6c16a2Chris Lattner if (ConstantInt *RHSC = dyn_cast<ConstantInt>(Op1)) 2550fdb5b01df486f8fca44927a38dc9763e9d538e4cChris Lattner return new ICmpInst(I.getPredicate(), ConstantExpr::getNot(RHSC), A); 2551fdb5b01df486f8fca44927a38dc9763e9d538e4cChris Lattner } 2552e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner 2553e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner // (a+b) <u a --> llvm.uadd.with.overflow. 2554e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner // (a+b) <u b --> llvm.uadd.with.overflow. 2555e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner if (I.getPredicate() == ICmpInst::ICMP_ULT && 25560cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach match(Op0, m_Add(m_Value(A), m_Value(B))) && 2557e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner (Op1 == A || Op1 == B)) 2558e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner if (Instruction *R = ProcessUAddIdiom(I, Op0, *this)) 2559e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner return R; 25600cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 2561e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner // a >u (a+b) --> llvm.uadd.with.overflow. 2562e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner // b >u (a+b) --> llvm.uadd.with.overflow. 2563e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner if (I.getPredicate() == ICmpInst::ICMP_UGT && 2564e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner match(Op1, m_Add(m_Value(A), m_Value(B))) && 2565e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner (Op0 == A || Op0 == B)) 2566e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner if (Instruction *R = ProcessUAddIdiom(I, Op1, *this)) 2567e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner return R; 256802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 25690cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 257002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (I.isEquality()) { 257102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *A, *B, *C, *D; 257239a7de72c8b5013f32802ceacefaaf6697726c28Duncan Sands 257302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (match(Op0, m_Xor(m_Value(A), m_Value(B)))) { 257402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (A == Op1 || B == Op1) { // (A^B) == A -> B == 0 257502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *OtherVal = A == Op1 ? B : A; 257602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(I.getPredicate(), OtherVal, 257702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant::getNullValue(A->getType())); 257802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 257902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 258002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (match(Op1, m_Xor(m_Value(C), m_Value(D)))) { 258102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // A^c1 == C^c2 --> A == C^(c1^c2) 258202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt *C1, *C2; 258302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (match(B, m_ConstantInt(C1)) && 258402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner match(D, m_ConstantInt(C2)) && Op1->hasOneUse()) { 258502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant *NC = ConstantInt::get(I.getContext(), 258602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner C1->getValue() ^ C2->getValue()); 2587a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer Value *Xor = Builder->CreateXor(C, NC); 258802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(I.getPredicate(), A, Xor); 258902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 25900cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 259102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // A^B == A^D -> B == D 259202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (A == C) return new ICmpInst(I.getPredicate(), B, D); 259302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (A == D) return new ICmpInst(I.getPredicate(), B, C); 259402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (B == C) return new ICmpInst(I.getPredicate(), A, D); 259502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (B == D) return new ICmpInst(I.getPredicate(), A, C); 259602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 259702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 25980cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 259902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (match(Op1, m_Xor(m_Value(A), m_Value(B))) && 260002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner (A == Op0 || B == Op0)) { 260102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // A == (A^B) -> B == 0 260202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *OtherVal = A == Op0 ? B : A; 260302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(I.getPredicate(), OtherVal, 260402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant::getNullValue(A->getType())); 260502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 260602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 260702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (X&Z) == (Y&Z) -> (X^Y) & Z == 0 26080cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach if (match(Op0, m_OneUse(m_And(m_Value(A), m_Value(B)))) && 26095036ce4a64caaeaff4b1f8f1c91836cc2e49a455Chris Lattner match(Op1, m_OneUse(m_And(m_Value(C), m_Value(D))))) { 261002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *X = 0, *Y = 0, *Z = 0; 26110cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 261202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (A == C) { 261302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner X = B; Y = D; Z = A; 261402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else if (A == D) { 261502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner X = B; Y = C; Z = A; 261602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else if (B == C) { 261702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner X = A; Y = D; Z = B; 261802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else if (B == D) { 261902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner X = A; Y = C; Z = B; 262002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 26210cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 262202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (X) { // Build (X^Y) & Z 2623a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer Op1 = Builder->CreateXor(X, Y); 2624a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer Op1 = Builder->CreateAnd(Op1, Z); 262502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner I.setOperand(0, Op1); 262602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner I.setOperand(1, Constant::getNullValue(Op1->getType())); 262702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return &I; 262802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 262902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 26300cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 263166821d902040f838a97bf04a4b910fdc11ba49a9Benjamin Kramer // Transform (zext A) == (B & (1<<X)-1) --> A == (trunc B) 26327a99b467df7cf4505612a11109ed7f05ba40abf1Benjamin Kramer // and (B & (1<<X)-1) == (zext A) --> A == (trunc B) 263366821d902040f838a97bf04a4b910fdc11ba49a9Benjamin Kramer ConstantInt *Cst1; 26347a99b467df7cf4505612a11109ed7f05ba40abf1Benjamin Kramer if ((Op0->hasOneUse() && 26357a99b467df7cf4505612a11109ed7f05ba40abf1Benjamin Kramer match(Op0, m_ZExt(m_Value(A))) && 26367a99b467df7cf4505612a11109ed7f05ba40abf1Benjamin Kramer match(Op1, m_And(m_Value(B), m_ConstantInt(Cst1)))) || 26377a99b467df7cf4505612a11109ed7f05ba40abf1Benjamin Kramer (Op1->hasOneUse() && 26387a99b467df7cf4505612a11109ed7f05ba40abf1Benjamin Kramer match(Op0, m_And(m_Value(B), m_ConstantInt(Cst1))) && 26397a99b467df7cf4505612a11109ed7f05ba40abf1Benjamin Kramer match(Op1, m_ZExt(m_Value(A))))) { 264066821d902040f838a97bf04a4b910fdc11ba49a9Benjamin Kramer APInt Pow2 = Cst1->getValue() + 1; 264166821d902040f838a97bf04a4b910fdc11ba49a9Benjamin Kramer if (Pow2.isPowerOf2() && isa<IntegerType>(A->getType()) && 264266821d902040f838a97bf04a4b910fdc11ba49a9Benjamin Kramer Pow2.logBase2() == cast<IntegerType>(A->getType())->getBitWidth()) 264366821d902040f838a97bf04a4b910fdc11ba49a9Benjamin Kramer return new ICmpInst(I.getPredicate(), A, 264466821d902040f838a97bf04a4b910fdc11ba49a9Benjamin Kramer Builder->CreateTrunc(B, A->getType())); 264566821d902040f838a97bf04a4b910fdc11ba49a9Benjamin Kramer } 264666821d902040f838a97bf04a4b910fdc11ba49a9Benjamin Kramer 2647325eeb1cd7c3247ead1513204bc9cf4b6e883653Chris Lattner // Transform "icmp eq (trunc (lshr(X, cst1)), cst" to 2648325eeb1cd7c3247ead1513204bc9cf4b6e883653Chris Lattner // "icmp (and X, mask), cst" 2649325eeb1cd7c3247ead1513204bc9cf4b6e883653Chris Lattner uint64_t ShAmt = 0; 2650325eeb1cd7c3247ead1513204bc9cf4b6e883653Chris Lattner if (Op0->hasOneUse() && 2651325eeb1cd7c3247ead1513204bc9cf4b6e883653Chris Lattner match(Op0, m_Trunc(m_OneUse(m_LShr(m_Value(A), 2652325eeb1cd7c3247ead1513204bc9cf4b6e883653Chris Lattner m_ConstantInt(ShAmt))))) && 2653325eeb1cd7c3247ead1513204bc9cf4b6e883653Chris Lattner match(Op1, m_ConstantInt(Cst1)) && 2654325eeb1cd7c3247ead1513204bc9cf4b6e883653Chris Lattner // Only do this when A has multiple uses. This is most important to do 2655325eeb1cd7c3247ead1513204bc9cf4b6e883653Chris Lattner // when it exposes other optimizations. 2656325eeb1cd7c3247ead1513204bc9cf4b6e883653Chris Lattner !A->hasOneUse()) { 2657325eeb1cd7c3247ead1513204bc9cf4b6e883653Chris Lattner unsigned ASize =cast<IntegerType>(A->getType())->getPrimitiveSizeInBits(); 26580cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 2659325eeb1cd7c3247ead1513204bc9cf4b6e883653Chris Lattner if (ShAmt < ASize) { 2660325eeb1cd7c3247ead1513204bc9cf4b6e883653Chris Lattner APInt MaskV = 2661325eeb1cd7c3247ead1513204bc9cf4b6e883653Chris Lattner APInt::getLowBitsSet(ASize, Op0->getType()->getPrimitiveSizeInBits()); 2662325eeb1cd7c3247ead1513204bc9cf4b6e883653Chris Lattner MaskV <<= ShAmt; 26630cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 2664325eeb1cd7c3247ead1513204bc9cf4b6e883653Chris Lattner APInt CmpV = Cst1->getValue().zext(ASize); 2665325eeb1cd7c3247ead1513204bc9cf4b6e883653Chris Lattner CmpV <<= ShAmt; 26660cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 2667325eeb1cd7c3247ead1513204bc9cf4b6e883653Chris Lattner Value *Mask = Builder->CreateAnd(A, Builder->getInt(MaskV)); 2668325eeb1cd7c3247ead1513204bc9cf4b6e883653Chris Lattner return new ICmpInst(I.getPredicate(), Mask, Builder->getInt(CmpV)); 2669325eeb1cd7c3247ead1513204bc9cf4b6e883653Chris Lattner } 2670325eeb1cd7c3247ead1513204bc9cf4b6e883653Chris Lattner } 267102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 26720cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 267302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner { 267402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *X; ConstantInt *Cst; 267502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // icmp X+Cst, X 267602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (match(Op0, m_Add(m_Value(X), m_ConstantInt(Cst))) && Op1 == X) 267702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return FoldICmpAddOpCst(I, X, Cst, I.getPredicate(), Op0); 267802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 267902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // icmp X, X+Cst 268002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (match(Op1, m_Add(m_Value(X), m_ConstantInt(Cst))) && Op0 == X) 268102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return FoldICmpAddOpCst(I, X, Cst, I.getSwappedPredicate(), Op1); 268202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 268302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return Changed ? &I : 0; 268402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner} 268502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 268602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 268702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 268802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 268902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 269002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 269102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// FoldFCmp_IntToFP_Cst - Fold fcmp ([us]itofp x, cst) if possible. 269202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// 269302446fc99abb06d3117d65c0b1f5fba4f906db2eChris LattnerInstruction *InstCombiner::FoldFCmp_IntToFP_Cst(FCmpInst &I, 269402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Instruction *LHSI, 269502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant *RHSC) { 269602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!isa<ConstantFP>(RHSC)) return 0; 269702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner const APFloat &RHS = cast<ConstantFP>(RHSC)->getValueAPF(); 26980cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 269902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Get the width of the mantissa. We don't want to hack on conversions that 270002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // might lose information from the integer, e.g. "i64 -> float" 270102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner int MantissaWidth = LHSI->getType()->getFPMantissaWidth(); 270202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (MantissaWidth == -1) return 0; // Unknown. 27030cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 270402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Check to see that the input is converted from an integer type that is small 270502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // enough that preserves all bits. TODO: check here for "known" sign bits. 270602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // This would allow us to handle (fptosi (x >>s 62) to float) if x is i64 f.e. 270702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner unsigned InputSize = LHSI->getOperand(0)->getType()->getScalarSizeInBits(); 27080cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 270902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If this is a uitofp instruction, we need an extra bit to hold the sign. 271002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner bool LHSUnsigned = isa<UIToFPInst>(LHSI); 271102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (LHSUnsigned) 271202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ++InputSize; 27130cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 271402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If the conversion would lose info, don't hack on this. 271502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if ((int)InputSize > MantissaWidth) 271602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return 0; 27170cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 271802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Otherwise, we can potentially simplify the comparison. We know that it 271902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // will always come through as an integer value and we know the constant is 272002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // not a NAN (it would have been previously simplified). 272102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner assert(!RHS.isNaN() && "NaN comparison not already folded!"); 27220cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 272302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ICmpInst::Predicate Pred; 272402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner switch (I.getPredicate()) { 272502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner default: llvm_unreachable("Unexpected predicate!"); 272602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_UEQ: 272702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_OEQ: 272802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Pred = ICmpInst::ICMP_EQ; 272902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 273002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_UGT: 273102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_OGT: 273202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Pred = LHSUnsigned ? ICmpInst::ICMP_UGT : ICmpInst::ICMP_SGT; 273302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 273402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_UGE: 273502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_OGE: 273602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Pred = LHSUnsigned ? ICmpInst::ICMP_UGE : ICmpInst::ICMP_SGE; 273702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 273802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_ULT: 273902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_OLT: 274002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Pred = LHSUnsigned ? ICmpInst::ICMP_ULT : ICmpInst::ICMP_SLT; 274102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 274202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_ULE: 274302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_OLE: 274402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Pred = LHSUnsigned ? ICmpInst::ICMP_ULE : ICmpInst::ICMP_SLE; 274502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 274602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_UNE: 274702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_ONE: 274802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Pred = ICmpInst::ICMP_NE; 274902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 275002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_ORD: 275102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return ReplaceInstUsesWith(I, ConstantInt::getTrue(I.getContext())); 275202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_UNO: 275302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return ReplaceInstUsesWith(I, ConstantInt::getFalse(I.getContext())); 275402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 27550cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 2756db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner IntegerType *IntTy = cast<IntegerType>(LHSI->getOperand(0)->getType()); 27570cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 275802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Now we know that the APFloat is a normal number, zero or inf. 27590cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 276002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // See if the FP constant is too large for the integer. For example, 276102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // comparing an i8 to 300.0. 276202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner unsigned IntWidth = IntTy->getScalarSizeInBits(); 27630cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 276402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!LHSUnsigned) { 276502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If the RHS value is > SignedMax, fold the comparison. This handles +INF 276602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // and large values. 276702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner APFloat SMax(RHS.getSemantics(), APFloat::fcZero, false); 276802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner SMax.convertFromAPInt(APInt::getSignedMaxValue(IntWidth), true, 276902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner APFloat::rmNearestTiesToEven); 277002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (SMax.compare(RHS) == APFloat::cmpLessThan) { // smax < 13123.0 277102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Pred == ICmpInst::ICMP_NE || Pred == ICmpInst::ICMP_SLT || 277202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Pred == ICmpInst::ICMP_SLE) 277302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return ReplaceInstUsesWith(I, ConstantInt::getTrue(I.getContext())); 277402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return ReplaceInstUsesWith(I, ConstantInt::getFalse(I.getContext())); 277502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 277602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else { 277702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If the RHS value is > UnsignedMax, fold the comparison. This handles 277802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // +INF and large values. 277902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner APFloat UMax(RHS.getSemantics(), APFloat::fcZero, false); 278002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner UMax.convertFromAPInt(APInt::getMaxValue(IntWidth), false, 278102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner APFloat::rmNearestTiesToEven); 278202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (UMax.compare(RHS) == APFloat::cmpLessThan) { // umax < 13123.0 278302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Pred == ICmpInst::ICMP_NE || Pred == ICmpInst::ICMP_ULT || 278402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Pred == ICmpInst::ICMP_ULE) 278502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return ReplaceInstUsesWith(I, ConstantInt::getTrue(I.getContext())); 278602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return ReplaceInstUsesWith(I, ConstantInt::getFalse(I.getContext())); 278702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 278802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 27890cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 279002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!LHSUnsigned) { 279102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // See if the RHS value is < SignedMin. 279202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner APFloat SMin(RHS.getSemantics(), APFloat::fcZero, false); 279302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner SMin.convertFromAPInt(APInt::getSignedMinValue(IntWidth), true, 279402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner APFloat::rmNearestTiesToEven); 279502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (SMin.compare(RHS) == APFloat::cmpGreaterThan) { // smin > 12312.0 279602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Pred == ICmpInst::ICMP_NE || Pred == ICmpInst::ICMP_SGT || 279702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Pred == ICmpInst::ICMP_SGE) 279802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return ReplaceInstUsesWith(I, ConstantInt::getTrue(I.getContext())); 279902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return ReplaceInstUsesWith(I, ConstantInt::getFalse(I.getContext())); 280002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 2801a2e0f6b643e9cfbbd698dbc9eb0289e5e33f8dc9Devang Patel } else { 2802a2e0f6b643e9cfbbd698dbc9eb0289e5e33f8dc9Devang Patel // See if the RHS value is < UnsignedMin. 2803a2e0f6b643e9cfbbd698dbc9eb0289e5e33f8dc9Devang Patel APFloat SMin(RHS.getSemantics(), APFloat::fcZero, false); 2804a2e0f6b643e9cfbbd698dbc9eb0289e5e33f8dc9Devang Patel SMin.convertFromAPInt(APInt::getMinValue(IntWidth), true, 2805a2e0f6b643e9cfbbd698dbc9eb0289e5e33f8dc9Devang Patel APFloat::rmNearestTiesToEven); 2806a2e0f6b643e9cfbbd698dbc9eb0289e5e33f8dc9Devang Patel if (SMin.compare(RHS) == APFloat::cmpGreaterThan) { // umin > 12312.0 2807a2e0f6b643e9cfbbd698dbc9eb0289e5e33f8dc9Devang Patel if (Pred == ICmpInst::ICMP_NE || Pred == ICmpInst::ICMP_UGT || 2808a2e0f6b643e9cfbbd698dbc9eb0289e5e33f8dc9Devang Patel Pred == ICmpInst::ICMP_UGE) 2809a2e0f6b643e9cfbbd698dbc9eb0289e5e33f8dc9Devang Patel return ReplaceInstUsesWith(I, ConstantInt::getTrue(I.getContext())); 2810a2e0f6b643e9cfbbd698dbc9eb0289e5e33f8dc9Devang Patel return ReplaceInstUsesWith(I, ConstantInt::getFalse(I.getContext())); 2811a2e0f6b643e9cfbbd698dbc9eb0289e5e33f8dc9Devang Patel } 281202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 281302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 281402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Okay, now we know that the FP constant fits in the range [SMIN, SMAX] or 281502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // [0, UMAX], but it may still be fractional. See if it is fractional by 281602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // casting the FP value to the integer value and back, checking for equality. 281702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Don't do this for zero, because -0.0 is not fractional. 281802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant *RHSInt = LHSUnsigned 281902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ? ConstantExpr::getFPToUI(RHSC, IntTy) 282002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner : ConstantExpr::getFPToSI(RHSC, IntTy); 282102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!RHS.isZero()) { 282202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner bool Equal = LHSUnsigned 282302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ? ConstantExpr::getUIToFP(RHSInt, RHSC->getType()) == RHSC 282402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner : ConstantExpr::getSIToFP(RHSInt, RHSC->getType()) == RHSC; 282502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!Equal) { 282602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If we had a comparison against a fractional value, we have to adjust 282702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // the compare predicate and sometimes the value. RHSC is rounded towards 282802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // zero at this point. 282902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner switch (Pred) { 283002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner default: llvm_unreachable("Unexpected integer comparison!"); 283102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_NE: // (float)int != 4.4 --> true 283202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return ReplaceInstUsesWith(I, ConstantInt::getTrue(I.getContext())); 283302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_EQ: // (float)int == 4.4 --> false 283402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return ReplaceInstUsesWith(I, ConstantInt::getFalse(I.getContext())); 283502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_ULE: 283602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (float)int <= 4.4 --> int <= 4 283702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (float)int <= -4.4 --> false 283802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (RHS.isNegative()) 283902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return ReplaceInstUsesWith(I, ConstantInt::getFalse(I.getContext())); 284002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 284102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_SLE: 284202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (float)int <= 4.4 --> int <= 4 284302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (float)int <= -4.4 --> int < -4 284402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (RHS.isNegative()) 284502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Pred = ICmpInst::ICMP_SLT; 284602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 284702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_ULT: 284802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (float)int < -4.4 --> false 284902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (float)int < 4.4 --> int <= 4 285002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (RHS.isNegative()) 285102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return ReplaceInstUsesWith(I, ConstantInt::getFalse(I.getContext())); 285202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Pred = ICmpInst::ICMP_ULE; 285302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 285402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_SLT: 285502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (float)int < -4.4 --> int < -4 285602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (float)int < 4.4 --> int <= 4 285702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!RHS.isNegative()) 285802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Pred = ICmpInst::ICMP_SLE; 285902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 286002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_UGT: 286102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (float)int > 4.4 --> int > 4 286202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (float)int > -4.4 --> true 286302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (RHS.isNegative()) 286402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return ReplaceInstUsesWith(I, ConstantInt::getTrue(I.getContext())); 286502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 286602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_SGT: 286702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (float)int > 4.4 --> int > 4 286802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (float)int > -4.4 --> int >= -4 286902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (RHS.isNegative()) 287002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Pred = ICmpInst::ICMP_SGE; 287102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 287202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_UGE: 287302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (float)int >= -4.4 --> true 287402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (float)int >= 4.4 --> int > 4 2875f12c95a8af22771845fa16253ad04e90741f5602Bob Wilson if (RHS.isNegative()) 287602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return ReplaceInstUsesWith(I, ConstantInt::getTrue(I.getContext())); 287702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Pred = ICmpInst::ICMP_UGT; 287802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 287902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_SGE: 288002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (float)int >= -4.4 --> int >= -4 288102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (float)int >= 4.4 --> int > 4 288202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!RHS.isNegative()) 288302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Pred = ICmpInst::ICMP_SGT; 288402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 288502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 288602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 288702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 288802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 288902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Lower this FP comparison into an appropriate integer version of the 289002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // comparison. 289102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(Pred, LHSI->getOperand(0), RHSInt); 289202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner} 289302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 289402446fc99abb06d3117d65c0b1f5fba4f906db2eChris LattnerInstruction *InstCombiner::visitFCmpInst(FCmpInst &I) { 289502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner bool Changed = false; 28960cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 289702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner /// Orders the operands of the compare so that they are listed from most 289802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner /// complex to least complex. This puts constants before unary operators, 289902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner /// before binary operators. 290002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (getComplexity(I.getOperand(0)) < getComplexity(I.getOperand(1))) { 290102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner I.swapOperands(); 290202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Changed = true; 290302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 290402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 290502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1); 29060cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 290702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Value *V = SimplifyFCmpInst(I.getPredicate(), Op0, Op1, TD)) 290802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return ReplaceInstUsesWith(I, V); 290902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 291002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Simplify 'fcmp pred X, X' 291102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op0 == Op1) { 291202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner switch (I.getPredicate()) { 291302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner default: llvm_unreachable("Unknown predicate!"); 291402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_UNO: // True if unordered: isnan(X) | isnan(Y) 291502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_ULT: // True if unordered or less than 291602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_UGT: // True if unordered or greater than 291702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_UNE: // True if unordered or not equal 291802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Canonicalize these to be 'fcmp uno %X, 0.0'. 291902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner I.setPredicate(FCmpInst::FCMP_UNO); 292002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner I.setOperand(1, Constant::getNullValue(Op0->getType())); 292102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return &I; 29220cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 292302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_ORD: // True if ordered (no nans) 292402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_OEQ: // True if ordered and equal 292502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_OGE: // True if ordered and greater than or equal 292602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_OLE: // True if ordered and less than or equal 292702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Canonicalize these to be 'fcmp ord %X, 0.0'. 292802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner I.setPredicate(FCmpInst::FCMP_ORD); 292902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner I.setOperand(1, Constant::getNullValue(Op0->getType())); 293002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return &I; 293102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 293202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 29330cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 293402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Handle fcmp with constant RHS 293502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Constant *RHSC = dyn_cast<Constant>(Op1)) { 293602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Instruction *LHSI = dyn_cast<Instruction>(Op0)) 293702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner switch (LHSI->getOpcode()) { 2938b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer case Instruction::FPExt: { 2939b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer // fcmp (fpext x), C -> fcmp x, (fptrunc C) if fptrunc is lossless 2940b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer FPExtInst *LHSExt = cast<FPExtInst>(LHSI); 2941b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer ConstantFP *RHSF = dyn_cast<ConstantFP>(RHSC); 2942b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer if (!RHSF) 2943b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer break; 2944b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer 2945b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer const fltSemantics *Sem; 2946b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer // FIXME: This shouldn't be here. 2947ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman if (LHSExt->getSrcTy()->isHalfTy()) 2948ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman Sem = &APFloat::IEEEhalf; 2949ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman else if (LHSExt->getSrcTy()->isFloatTy()) 2950b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer Sem = &APFloat::IEEEsingle; 2951b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer else if (LHSExt->getSrcTy()->isDoubleTy()) 2952b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer Sem = &APFloat::IEEEdouble; 2953b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer else if (LHSExt->getSrcTy()->isFP128Ty()) 2954b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer Sem = &APFloat::IEEEquad; 2955b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer else if (LHSExt->getSrcTy()->isX86_FP80Ty()) 2956b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer Sem = &APFloat::x87DoubleExtended; 29573467b9fd5d0c4ebc726e96c2af96610e2d6915f9Ulrich Weigand else if (LHSExt->getSrcTy()->isPPC_FP128Ty()) 29583467b9fd5d0c4ebc726e96c2af96610e2d6915f9Ulrich Weigand Sem = &APFloat::PPCDoubleDouble; 2959b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer else 2960b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer break; 2961b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer 2962b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer bool Lossy; 2963b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer APFloat F = RHSF->getValueAPF(); 2964b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer F.convert(*Sem, APFloat::rmNearestTiesToEven, &Lossy); 2965b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer 2966cbf676b3ba907f72405a02938f5cd85fb3e6a46cJim Grosbach // Avoid lossy conversions and denormals. Zero is a special case 2967cbf676b3ba907f72405a02938f5cd85fb3e6a46cJim Grosbach // that's OK to convert. 296868e05fb3687ca68d5a5be49100c7c274a3185525Jim Grosbach APFloat Fabs = F; 296968e05fb3687ca68d5a5be49100c7c274a3185525Jim Grosbach Fabs.clearSign(); 2970b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer if (!Lossy && 297168e05fb3687ca68d5a5be49100c7c274a3185525Jim Grosbach ((Fabs.compare(APFloat::getSmallestNormalized(*Sem)) != 297268e05fb3687ca68d5a5be49100c7c274a3185525Jim Grosbach APFloat::cmpLessThan) || Fabs.isZero())) 2973cbf676b3ba907f72405a02938f5cd85fb3e6a46cJim Grosbach 2974b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer return new FCmpInst(I.getPredicate(), LHSExt->getOperand(0), 2975b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer ConstantFP::get(RHSC->getContext(), F)); 2976b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer break; 2977b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer } 297802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::PHI: 297902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Only fold fcmp into the PHI if the phi and fcmp are in the same 298002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // block. If in the same block, we're encouraging jump threading. If 298102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // not, we are just pessimizing the code by making an i1 phi. 298202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (LHSI->getParent() == I.getParent()) 29839922ccf4b483ce37524047879f9b2f9bb73e3ccbChris Lattner if (Instruction *NV = FoldOpIntoPhi(I)) 298402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return NV; 298502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 298602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::SIToFP: 298702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::UIToFP: 298802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Instruction *NV = FoldFCmp_IntToFP_Cst(I, LHSI, RHSC)) 298902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return NV; 299002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 299102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::Select: { 299202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If either operand of the select is a constant, we can fold the 299302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // comparison into the select arms, which will cause one to be 299402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // constant folded and the select turned into a bitwise or. 299502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *Op1 = 0, *Op2 = 0; 299602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (LHSI->hasOneUse()) { 299702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Constant *C = dyn_cast<Constant>(LHSI->getOperand(1))) { 299802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Fold the known value into the constant operand. 299902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Op1 = ConstantExpr::getCompare(I.getPredicate(), C, RHSC); 300002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Insert a new FCmp of the other select operand. 300102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Op2 = Builder->CreateFCmp(I.getPredicate(), 300202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner LHSI->getOperand(2), RHSC, I.getName()); 300302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else if (Constant *C = dyn_cast<Constant>(LHSI->getOperand(2))) { 300402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Fold the known value into the constant operand. 300502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Op2 = ConstantExpr::getCompare(I.getPredicate(), C, RHSC); 300602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Insert a new FCmp of the other select operand. 300702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Op1 = Builder->CreateFCmp(I.getPredicate(), LHSI->getOperand(1), 300802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner RHSC, I.getName()); 300902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 301002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 301102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 301202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op1) 301302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return SelectInst::Create(LHSI->getOperand(0), Op1, Op2); 301402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 301502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 30160db50189dcde3408134e9011052ed8b731ec303aBenjamin Kramer case Instruction::FSub: { 30170db50189dcde3408134e9011052ed8b731ec303aBenjamin Kramer // fcmp pred (fneg x), C -> fcmp swap(pred) x, -C 30180db50189dcde3408134e9011052ed8b731ec303aBenjamin Kramer Value *Op; 30190db50189dcde3408134e9011052ed8b731ec303aBenjamin Kramer if (match(LHSI, m_FNeg(m_Value(Op)))) 30200db50189dcde3408134e9011052ed8b731ec303aBenjamin Kramer return new FCmpInst(I.getSwappedPredicate(), Op, 30210db50189dcde3408134e9011052ed8b731ec303aBenjamin Kramer ConstantExpr::getFNeg(RHSC)); 30220db50189dcde3408134e9011052ed8b731ec303aBenjamin Kramer break; 30230db50189dcde3408134e9011052ed8b731ec303aBenjamin Kramer } 302439516a632385cb8103c94fceb6cfed13897a24b4Dan Gohman case Instruction::Load: 302539516a632385cb8103c94fceb6cfed13897a24b4Dan Gohman if (GetElementPtrInst *GEP = 302639516a632385cb8103c94fceb6cfed13897a24b4Dan Gohman dyn_cast<GetElementPtrInst>(LHSI->getOperand(0))) { 302739516a632385cb8103c94fceb6cfed13897a24b4Dan Gohman if (GlobalVariable *GV = dyn_cast<GlobalVariable>(GEP->getOperand(0))) 302839516a632385cb8103c94fceb6cfed13897a24b4Dan Gohman if (GV->isConstant() && GV->hasDefinitiveInitializer() && 302939516a632385cb8103c94fceb6cfed13897a24b4Dan Gohman !cast<LoadInst>(LHSI)->isVolatile()) 303039516a632385cb8103c94fceb6cfed13897a24b4Dan Gohman if (Instruction *Res = FoldCmpLoadFromIndexedGlobal(GEP, GV, I)) 303139516a632385cb8103c94fceb6cfed13897a24b4Dan Gohman return Res; 303239516a632385cb8103c94fceb6cfed13897a24b4Dan Gohman } 303339516a632385cb8103c94fceb6cfed13897a24b4Dan Gohman break; 303400abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer case Instruction::Call: { 303500abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer CallInst *CI = cast<CallInst>(LHSI); 303600abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer LibFunc::Func Func; 303700abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer // Various optimization for fabs compared with zero. 3038a4b5717ea7ea09afeb5cda2683f6e91a802f5906Benjamin Kramer if (RHSC->isNullValue() && CI->getCalledFunction() && 303900abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer TLI->getLibFunc(CI->getCalledFunction()->getName(), Func) && 304000abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer TLI->has(Func)) { 304100abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer if (Func == LibFunc::fabs || Func == LibFunc::fabsf || 304200abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer Func == LibFunc::fabsl) { 304300abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer switch (I.getPredicate()) { 304400abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer default: break; 304500abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer // fabs(x) < 0 --> false 304600abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer case FCmpInst::FCMP_OLT: 304700abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer return ReplaceInstUsesWith(I, Builder->getFalse()); 304800abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer // fabs(x) > 0 --> x != 0 304900abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer case FCmpInst::FCMP_OGT: 305000abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer return new FCmpInst(FCmpInst::FCMP_ONE, CI->getArgOperand(0), 305100abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer RHSC); 305200abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer // fabs(x) <= 0 --> x == 0 305300abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer case FCmpInst::FCMP_OLE: 305400abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer return new FCmpInst(FCmpInst::FCMP_OEQ, CI->getArgOperand(0), 305500abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer RHSC); 305600abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer // fabs(x) >= 0 --> !isnan(x) 305700abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer case FCmpInst::FCMP_OGE: 305800abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer return new FCmpInst(FCmpInst::FCMP_ORD, CI->getArgOperand(0), 305900abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer RHSC); 306000abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer // fabs(x) == 0 --> x == 0 306100abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer // fabs(x) != 0 --> x != 0 306200abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer case FCmpInst::FCMP_OEQ: 306300abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer case FCmpInst::FCMP_UEQ: 306400abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer case FCmpInst::FCMP_ONE: 306500abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer case FCmpInst::FCMP_UNE: 306600abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer return new FCmpInst(I.getPredicate(), CI->getArgOperand(0), 306700abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer RHSC); 306800abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer } 306900abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer } 307000abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer } 307100abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer } 307202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 307302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 307402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 307500e00d693c3991d85ffebf305ddbfd5dfb99ead6Benjamin Kramer // fcmp pred (fneg x), (fneg y) -> fcmp swap(pred) x, y 307668b4bd0a63156a9f57210243bc5a8959e93b24faBenjamin Kramer Value *X, *Y; 307768b4bd0a63156a9f57210243bc5a8959e93b24faBenjamin Kramer if (match(Op0, m_FNeg(m_Value(X))) && match(Op1, m_FNeg(m_Value(Y)))) 307800e00d693c3991d85ffebf305ddbfd5dfb99ead6Benjamin Kramer return new FCmpInst(I.getSwappedPredicate(), X, Y); 307968b4bd0a63156a9f57210243bc5a8959e93b24faBenjamin Kramer 3080cd0274ca189040a2fd883b00a678184afc2cda3aBenjamin Kramer // fcmp (fpext x), (fpext y) -> fcmp x, y 3081cd0274ca189040a2fd883b00a678184afc2cda3aBenjamin Kramer if (FPExtInst *LHSExt = dyn_cast<FPExtInst>(Op0)) 3082cd0274ca189040a2fd883b00a678184afc2cda3aBenjamin Kramer if (FPExtInst *RHSExt = dyn_cast<FPExtInst>(Op1)) 3083cd0274ca189040a2fd883b00a678184afc2cda3aBenjamin Kramer if (LHSExt->getSrcTy() == RHSExt->getSrcTy()) 3084cd0274ca189040a2fd883b00a678184afc2cda3aBenjamin Kramer return new FCmpInst(I.getPredicate(), LHSExt->getOperand(0), 3085cd0274ca189040a2fd883b00a678184afc2cda3aBenjamin Kramer RHSExt->getOperand(0)); 3086cd0274ca189040a2fd883b00a678184afc2cda3aBenjamin Kramer 308702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return Changed ? &I : 0; 308802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner} 3089