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 1421bb93a912199bda15214d1ee7f3c731b8e9b648dArnaud A. de Grandmaison/// Returns true if the exploded icmp can be expressed as a signed comparison 1431bb93a912199bda15214d1ee7f3c731b8e9b648dArnaud A. de Grandmaison/// to zero and updates the predicate accordingly. 1441bb93a912199bda15214d1ee7f3c731b8e9b648dArnaud A. de Grandmaison/// The signedness of the comparison is preserved. 14535763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaisonstatic bool isSignTest(ICmpInst::Predicate &pred, const ConstantInt *RHS) { 14635763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison if (!ICmpInst::isSigned(pred)) 14735763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison return false; 14835763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison 14935763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison if (RHS->isZero()) 1501bb93a912199bda15214d1ee7f3c731b8e9b648dArnaud A. de Grandmaison return ICmpInst::isRelational(pred); 15135763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison 1521bb93a912199bda15214d1ee7f3c731b8e9b648dArnaud A. de Grandmaison if (RHS->isOne()) { 1531bb93a912199bda15214d1ee7f3c731b8e9b648dArnaud A. de Grandmaison if (pred == ICmpInst::ICMP_SLT) { 15435763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison pred = ICmpInst::ICMP_SLE; 15535763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison return true; 15635763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison } 1571bb93a912199bda15214d1ee7f3c731b8e9b648dArnaud A. de Grandmaison } else if (RHS->isAllOnesValue()) { 1581bb93a912199bda15214d1ee7f3c731b8e9b648dArnaud A. de Grandmaison if (pred == ICmpInst::ICMP_SGT) { 15935763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison pred = ICmpInst::ICMP_SGE; 16035763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison return true; 16135763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison } 1621bb93a912199bda15214d1ee7f3c731b8e9b648dArnaud A. de Grandmaison } 16335763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison 16435763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison return false; 16535763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison} 16635763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison 16702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner// isHighOnes - Return true if the constant is of the form 1+0+. 16802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner// This is the same as lowones(~X). 16902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattnerstatic bool isHighOnes(const ConstantInt *CI) { 17002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return (~CI->getValue() + 1).isPowerOf2(); 17102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner} 17202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 1730cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach/// ComputeSignedMinMaxValuesFromKnownBits - Given a signed integer type and a 17402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// set of known zero and one bits, compute the maximum and minimum values that 17502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// could have the specified known zero and known one bits, returning them in 17602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// min/max. 17702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattnerstatic void ComputeSignedMinMaxValuesFromKnownBits(const APInt& KnownZero, 17802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner const APInt& KnownOne, 17902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner APInt& Min, APInt& Max) { 18002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner assert(KnownZero.getBitWidth() == KnownOne.getBitWidth() && 18102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner KnownZero.getBitWidth() == Min.getBitWidth() && 18202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner KnownZero.getBitWidth() == Max.getBitWidth() && 18302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner "KnownZero, KnownOne and Min, Max must have equal bitwidth."); 18402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner APInt UnknownBits = ~(KnownZero|KnownOne); 18502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 18602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // The minimum value is when all unknown bits are zeros, EXCEPT for the sign 18702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // bit if it is unknown. 18802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Min = KnownOne; 18902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Max = KnownOne|UnknownBits; 1900cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 19102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (UnknownBits.isNegative()) { // Sign bit is unknown 1927a874ddda037349184fbeb22838cc11a1a9bb78fJay Foad Min.setBit(Min.getBitWidth()-1); 1937a874ddda037349184fbeb22838cc11a1a9bb78fJay Foad Max.clearBit(Max.getBitWidth()-1); 19402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 19502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner} 19602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 19702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner// ComputeUnsignedMinMaxValuesFromKnownBits - Given an unsigned integer type and 19802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner// a set of known zero and one bits, compute the maximum and minimum values that 19902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner// could have the specified known zero and known one bits, returning them in 20002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner// min/max. 20102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattnerstatic void ComputeUnsignedMinMaxValuesFromKnownBits(const APInt &KnownZero, 20202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner const APInt &KnownOne, 20302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner APInt &Min, APInt &Max) { 20402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner assert(KnownZero.getBitWidth() == KnownOne.getBitWidth() && 20502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner KnownZero.getBitWidth() == Min.getBitWidth() && 20602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner KnownZero.getBitWidth() == Max.getBitWidth() && 20702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner "Ty, KnownZero, KnownOne and Min, Max must have equal bitwidth."); 20802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner APInt UnknownBits = ~(KnownZero|KnownOne); 2090cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 21002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // The minimum value is when the unknown bits are all zeros. 21102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Min = KnownOne; 21202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // The maximum value is when the unknown bits are all ones. 21302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Max = KnownOne|UnknownBits; 21402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner} 21502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 21602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 21702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 21802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// FoldCmpLoadFromIndexedGlobal - Called we see this pattern: 21902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// cmp pred (load (gep GV, ...)), cmpcst 22002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// where GV is a global variable with a constant initializer. Try to simplify 22102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// this into some simple computation that does not need the load. For example 22202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// we can optimize "icmp eq (load (gep "foo", 0, i)), 0" into "icmp eq i, 3". 22302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// 22402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// If AndCst is non-null, then the loaded value is masked with that constant 22502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// before doing the comparison. This handles cases like "A[i]&4 == 0". 22602446fc99abb06d3117d65c0b1f5fba4f906db2eChris LattnerInstruction *InstCombiner:: 22702446fc99abb06d3117d65c0b1f5fba4f906db2eChris LattnerFoldCmpLoadFromIndexedGlobal(GetElementPtrInst *GEP, GlobalVariable *GV, 22802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner CmpInst &ICI, ConstantInt *AndCst) { 229d7f5a588907f86ddc83fa29accea54a6c0e78e94Chris Lattner // We need TD information to know the pointer size unless this is inbounds. 230d7f5a588907f86ddc83fa29accea54a6c0e78e94Chris Lattner if (!GEP->isInBounds() && TD == 0) return 0; 2310cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 232c8d75c78ec5d30db0d5b75bd8bc85dd65106868fChris Lattner Constant *Init = GV->getInitializer(); 233c8d75c78ec5d30db0d5b75bd8bc85dd65106868fChris Lattner if (!isa<ConstantArray>(Init) && !isa<ConstantDataArray>(Init)) 234c8d75c78ec5d30db0d5b75bd8bc85dd65106868fChris Lattner return 0; 23503fceff6f69a0261a767aab8e62de8aa9301b86cJim Grosbach 236c8d75c78ec5d30db0d5b75bd8bc85dd65106868fChris Lattner uint64_t ArrayElementCount = Init->getType()->getArrayNumElements(); 237c8d75c78ec5d30db0d5b75bd8bc85dd65106868fChris Lattner if (ArrayElementCount > 1024) return 0; // Don't blow up on huge arrays. 2380cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 23902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // There are many forms of this optimization we can handle, for now, just do 24002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // the simple index into a single-dimensional array. 24102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // 24202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Require: GEP GV, 0, i {{, constant indices}} 24302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (GEP->getNumOperands() < 3 || 24402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner !isa<ConstantInt>(GEP->getOperand(1)) || 24502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner !cast<ConstantInt>(GEP->getOperand(1))->isZero() || 24602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner isa<Constant>(GEP->getOperand(2))) 24702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return 0; 24802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 24902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Check that indices after the variable are constants and in-range for the 25002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // type they index. Collect the indices. This is typically for arrays of 25102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // structs. 25202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner SmallVector<unsigned, 4> LaterIndices; 2530cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 254c8d75c78ec5d30db0d5b75bd8bc85dd65106868fChris Lattner Type *EltTy = Init->getType()->getArrayElementType(); 25502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner for (unsigned i = 3, e = GEP->getNumOperands(); i != e; ++i) { 25602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt *Idx = dyn_cast<ConstantInt>(GEP->getOperand(i)); 25702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Idx == 0) return 0; // Variable index. 2580cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 25902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner uint64_t IdxVal = Idx->getZExtValue(); 26002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if ((unsigned)IdxVal != IdxVal) return 0; // Too large array index. 2610cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 262db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (StructType *STy = dyn_cast<StructType>(EltTy)) 26302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner EltTy = STy->getElementType(IdxVal); 264db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner else if (ArrayType *ATy = dyn_cast<ArrayType>(EltTy)) { 26502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (IdxVal >= ATy->getNumElements()) return 0; 26602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner EltTy = ATy->getElementType(); 26702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else { 26802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return 0; // Unknown type. 26902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 2700cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 27102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner LaterIndices.push_back(IdxVal); 27202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 2730cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 27402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner enum { Overdefined = -3, Undefined = -2 }; 27502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 27602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Variables for our state machines. 2770cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 27802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // FirstTrueElement/SecondTrueElement - Used to emit a comparison of the form 27902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // "i == 47 | i == 87", where 47 is the first index the condition is true for, 28002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // and 87 is the second (and last) index. FirstTrueElement is -2 when 28102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // undefined, otherwise set to the first true element. SecondTrueElement is 28202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // -2 when undefined, -3 when overdefined and >= 0 when that index is true. 28302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner int FirstTrueElement = Undefined, SecondTrueElement = Undefined; 28402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 28502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // FirstFalseElement/SecondFalseElement - Used to emit a comparison of the 28602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // form "i != 47 & i != 87". Same state transitions as for true elements. 28702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner int FirstFalseElement = Undefined, SecondFalseElement = Undefined; 2880cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 28902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner /// TrueRangeEnd/FalseRangeEnd - In conjunction with First*Element, these 29002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner /// define a state machine that triggers for ranges of values that the index 29102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner /// is true or false for. This triggers on things like "abbbbc"[i] == 'b'. 29202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner /// This is -2 when undefined, -3 when overdefined, and otherwise the last 29302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner /// index in the range (inclusive). We use -2 for undefined here because we 29402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner /// use relative comparisons and don't want 0-1 to match -1. 29502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner int TrueRangeEnd = Undefined, FalseRangeEnd = Undefined; 2960cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 29702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // MagicBitvector - This is a magic bitvector where we set a bit if the 29802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // comparison is true for element 'i'. If there are 64 elements or less in 29902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // the array, this will fully represent all the comparison results. 30002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner uint64_t MagicBitvector = 0; 3010cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 3020cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 30302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Scan the array and see if one of our patterns matches. 30402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant *CompareRHS = cast<Constant>(ICI.getOperand(1)); 305c8d75c78ec5d30db0d5b75bd8bc85dd65106868fChris Lattner for (unsigned i = 0, e = ArrayElementCount; i != e; ++i) { 306c8d75c78ec5d30db0d5b75bd8bc85dd65106868fChris Lattner Constant *Elt = Init->getAggregateElement(i); 307c8d75c78ec5d30db0d5b75bd8bc85dd65106868fChris Lattner if (Elt == 0) return 0; 3080cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 30902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If this is indexing an array of structures, get the structure element. 31002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!LaterIndices.empty()) 311fc6d3a49867cd38954dc40936a88f1907252c6d2Jay Foad Elt = ConstantExpr::getExtractValue(Elt, LaterIndices); 3120cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 31302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If the element is masked, handle it. 31402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (AndCst) Elt = ConstantExpr::getAnd(Elt, AndCst); 3150cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 31602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Find out if the comparison would be true or false for the i'th element. 31702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant *C = ConstantFoldCompareInstOperands(ICI.getPredicate(), Elt, 318aab8e28d5e470711d80276bbf717408c3ab966fdChad Rosier CompareRHS, TD, TLI); 31902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If the result is undef for this element, ignore it. 32002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (isa<UndefValue>(C)) { 32102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Extend range state machines to cover this element in case there is an 32202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // undef in the middle of the range. 32302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (TrueRangeEnd == (int)i-1) 32402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner TrueRangeEnd = i; 32502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (FalseRangeEnd == (int)i-1) 32602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner FalseRangeEnd = i; 32702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner continue; 32802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 3290cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 33002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If we can't compute the result for any of the elements, we have to give 33102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // up evaluating the entire conditional. 33202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!isa<ConstantInt>(C)) return 0; 3330cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 33402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Otherwise, we know if the comparison is true or false for this element, 33502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // update our state machines. 33602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner bool IsTrueForElt = !cast<ConstantInt>(C)->isZero(); 3370cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 33802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // State machine for single/double/range index comparison. 33902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (IsTrueForElt) { 34002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Update the TrueElement state machine. 34102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (FirstTrueElement == Undefined) 34202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner FirstTrueElement = TrueRangeEnd = i; // First true element. 34302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner else { 34402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Update double-compare state machine. 34502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (SecondTrueElement == Undefined) 34602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner SecondTrueElement = i; 34702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner else 34802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner SecondTrueElement = Overdefined; 3490cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 35002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Update range state machine. 35102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (TrueRangeEnd == (int)i-1) 35202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner TrueRangeEnd = i; 35302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner else 35402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner TrueRangeEnd = Overdefined; 35502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 35602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else { 35702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Update the FalseElement state machine. 35802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (FirstFalseElement == Undefined) 35902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner FirstFalseElement = FalseRangeEnd = i; // First false element. 36002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner else { 36102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Update double-compare state machine. 36202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (SecondFalseElement == Undefined) 36302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner SecondFalseElement = i; 36402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner else 36502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner SecondFalseElement = Overdefined; 3660cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 36702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Update range state machine. 36802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (FalseRangeEnd == (int)i-1) 36902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner FalseRangeEnd = i; 37002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner else 37102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner FalseRangeEnd = Overdefined; 37202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 37302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 3740cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 3750cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 37602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If this element is in range, update our magic bitvector. 37702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (i < 64 && IsTrueForElt) 37802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner MagicBitvector |= 1ULL << i; 3790cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 38002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If all of our states become overdefined, bail out early. Since the 38102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // predicate is expensive, only check it every 8 elements. This is only 38202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // really useful for really huge arrays. 38302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if ((i & 8) == 0 && i >= 64 && SecondTrueElement == Overdefined && 38402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner SecondFalseElement == Overdefined && TrueRangeEnd == Overdefined && 38502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner FalseRangeEnd == Overdefined) 38602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return 0; 38702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 38802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 38902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Now that we've scanned the entire array, emit our new comparison(s). We 39002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // order the state machines in complexity of the generated code. 39102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *Idx = GEP->getOperand(2); 39202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 393d7f5a588907f86ddc83fa29accea54a6c0e78e94Chris Lattner // If the index is larger than the pointer size of the target, truncate the 394d7f5a588907f86ddc83fa29accea54a6c0e78e94Chris Lattner // index down like the GEP would do implicitly. We don't have to do this for 395d7f5a588907f86ddc83fa29accea54a6c0e78e94Chris Lattner // an inbounds GEP because the index can't be out of range. 396d7f5a588907f86ddc83fa29accea54a6c0e78e94Chris Lattner if (!GEP->isInBounds() && 397426c2bf5cdd2173e4a33aea8cb92cf684a724f4bChandler Carruth Idx->getType()->getPrimitiveSizeInBits() > TD->getPointerSizeInBits()) 398ece6c6bb6329748b92403c06ac87f45c43485911Chandler Carruth Idx = Builder->CreateTrunc(Idx, TD->getIntPtrType(Idx->getContext())); 3990cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 40002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If the comparison is only true for one or two elements, emit direct 40102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // comparisons. 40202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (SecondTrueElement != Overdefined) { 40302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // None true -> false. 40402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (FirstTrueElement == Undefined) 4053facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak return ReplaceInstUsesWith(ICI, Builder->getFalse()); 4060cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 40702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *FirstTrueIdx = ConstantInt::get(Idx->getType(), FirstTrueElement); 4080cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 40902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // True for one element -> 'i == 47'. 41002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (SecondTrueElement == Undefined) 41102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_EQ, Idx, FirstTrueIdx); 4120cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 41302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // True for two elements -> 'i == 47 | i == 72'. 41402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *C1 = Builder->CreateICmpEQ(Idx, FirstTrueIdx); 41502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *SecondTrueIdx = ConstantInt::get(Idx->getType(), SecondTrueElement); 41602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *C2 = Builder->CreateICmpEQ(Idx, SecondTrueIdx); 41702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return BinaryOperator::CreateOr(C1, C2); 41802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 41902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 42002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If the comparison is only false for one or two elements, emit direct 42102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // comparisons. 42202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (SecondFalseElement != Overdefined) { 42302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // None false -> true. 42402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (FirstFalseElement == Undefined) 4253facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak return ReplaceInstUsesWith(ICI, Builder->getTrue()); 4260cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 42702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *FirstFalseIdx = ConstantInt::get(Idx->getType(), FirstFalseElement); 42802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 42902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // False for one element -> 'i != 47'. 43002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (SecondFalseElement == Undefined) 43102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_NE, Idx, FirstFalseIdx); 4320cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 43302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // False for two elements -> 'i != 47 & i != 72'. 43402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *C1 = Builder->CreateICmpNE(Idx, FirstFalseIdx); 43502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *SecondFalseIdx = ConstantInt::get(Idx->getType(),SecondFalseElement); 43602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *C2 = Builder->CreateICmpNE(Idx, SecondFalseIdx); 43702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return BinaryOperator::CreateAnd(C1, C2); 43802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 4390cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 44002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If the comparison can be replaced with a range comparison for the elements 44102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // where it is true, emit the range check. 44202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (TrueRangeEnd != Overdefined) { 44302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner assert(TrueRangeEnd != FirstTrueElement && "Should emit single compare"); 4440cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 44502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Generate (i-FirstTrue) <u (TrueRangeEnd-FirstTrue+1). 44602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (FirstTrueElement) { 44702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *Offs = ConstantInt::get(Idx->getType(), -FirstTrueElement); 44802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Idx = Builder->CreateAdd(Idx, Offs); 44902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 4500cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 45102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *End = ConstantInt::get(Idx->getType(), 45202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner TrueRangeEnd-FirstTrueElement+1); 45302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_ULT, Idx, End); 45402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 4550cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 45602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // False range check. 45702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (FalseRangeEnd != Overdefined) { 45802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner assert(FalseRangeEnd != FirstFalseElement && "Should emit single compare"); 45902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Generate (i-FirstFalse) >u (FalseRangeEnd-FirstFalse). 46002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (FirstFalseElement) { 46102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *Offs = ConstantInt::get(Idx->getType(), -FirstFalseElement); 46202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Idx = Builder->CreateAdd(Idx, Offs); 46302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 4640cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 46502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *End = ConstantInt::get(Idx->getType(), 46602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner FalseRangeEnd-FirstFalseElement); 46702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_UGT, Idx, End); 46802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 4690cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 4700cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 4712be921adc41fb079ce25d36bdd6402ca70d56451Arnaud A. de Grandmaison // If a magic bitvector captures the entire comparison state 47202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // of this load, replace it with computation that does: 47302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // ((magic_cst >> i) & 1) != 0 4742be921adc41fb079ce25d36bdd6402ca70d56451Arnaud A. de Grandmaison { 4752be921adc41fb079ce25d36bdd6402ca70d56451Arnaud A. de Grandmaison Type *Ty = 0; 4762be921adc41fb079ce25d36bdd6402ca70d56451Arnaud A. de Grandmaison 4772be921adc41fb079ce25d36bdd6402ca70d56451Arnaud A. de Grandmaison // Look for an appropriate type: 4782be921adc41fb079ce25d36bdd6402ca70d56451Arnaud A. de Grandmaison // - The type of Idx if the magic fits 4792be921adc41fb079ce25d36bdd6402ca70d56451Arnaud A. de Grandmaison // - The smallest fitting legal type if we have a DataLayout 4802be921adc41fb079ce25d36bdd6402ca70d56451Arnaud A. de Grandmaison // - Default to i32 4812be921adc41fb079ce25d36bdd6402ca70d56451Arnaud A. de Grandmaison if (ArrayElementCount <= Idx->getType()->getIntegerBitWidth()) 4822be921adc41fb079ce25d36bdd6402ca70d56451Arnaud A. de Grandmaison Ty = Idx->getType(); 4832be921adc41fb079ce25d36bdd6402ca70d56451Arnaud A. de Grandmaison else if (TD) 4842be921adc41fb079ce25d36bdd6402ca70d56451Arnaud A. de Grandmaison Ty = TD->getSmallestLegalIntType(Init->getContext(), ArrayElementCount); 4852be921adc41fb079ce25d36bdd6402ca70d56451Arnaud A. de Grandmaison else if (ArrayElementCount <= 32) 48602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Ty = Type::getInt32Ty(Init->getContext()); 4872be921adc41fb079ce25d36bdd6402ca70d56451Arnaud A. de Grandmaison 4882be921adc41fb079ce25d36bdd6402ca70d56451Arnaud A. de Grandmaison if (Ty != 0) { 4892be921adc41fb079ce25d36bdd6402ca70d56451Arnaud A. de Grandmaison Value *V = Builder->CreateIntCast(Idx, Ty, false); 4902be921adc41fb079ce25d36bdd6402ca70d56451Arnaud A. de Grandmaison V = Builder->CreateLShr(ConstantInt::get(Ty, MagicBitvector), V); 4912be921adc41fb079ce25d36bdd6402ca70d56451Arnaud A. de Grandmaison V = Builder->CreateAnd(ConstantInt::get(Ty, 1), V); 4922be921adc41fb079ce25d36bdd6402ca70d56451Arnaud A. de Grandmaison return new ICmpInst(ICmpInst::ICMP_NE, V, ConstantInt::get(Ty, 0)); 4932be921adc41fb079ce25d36bdd6402ca70d56451Arnaud A. de Grandmaison } 49402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 4950cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 49602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return 0; 49702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner} 49802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 49902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 50002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// EvaluateGEPOffsetExpression - Return a value that can be used to compare 50102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// the *offset* implied by a GEP to zero. For example, if we have &A[i], we 50202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// want to return 'i' for "icmp ne i, 0". Note that, in general, indices can 50302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// be complex, and scales are involved. The above expression would also be 50402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// legal to codegen as "icmp ne (i*4), 0" (assuming A is a pointer to i32). 50502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// This later form is less amenable to optimization though, and we are allowed 50602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// to generate the first by knowing that pointer arithmetic doesn't overflow. 50702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// 50802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// If we can't emit an optimized form for this expression, this returns null. 5090cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach/// 510107ffd58f70651cc928416f6aaf267accc992c23Eli Friedmanstatic Value *EvaluateGEPOffsetExpression(User *GEP, InstCombiner &IC) { 5113574eca1b02600bac4e625297f4ecf745f4c4f32Micah Villmow DataLayout &TD = *IC.getDataLayout(); 51202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner gep_type_iterator GTI = gep_type_begin(GEP); 5130cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 51402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Check to see if this gep only has a single variable index. If so, and if 51502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // any constant indices are a multiple of its scale, then we can compute this 51602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // in terms of the scale of the variable index. For example, if the GEP 51702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // implies an offset of "12 + i*4", then we can codegen this as "3 + i", 51802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // because the expression will cross zero at the same point. 51902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner unsigned i, e = GEP->getNumOperands(); 52002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner int64_t Offset = 0; 52102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner for (i = 1; i != e; ++i, ++GTI) { 52202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(GEP->getOperand(i))) { 52302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Compute the aggregate offset of constant indices. 52402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (CI->isZero()) continue; 5250cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 52602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Handle a struct index, which adds its field offset to the pointer. 527db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (StructType *STy = dyn_cast<StructType>(*GTI)) { 52802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Offset += TD.getStructLayout(STy)->getElementOffset(CI->getZExtValue()); 52902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else { 53002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner uint64_t Size = TD.getTypeAllocSize(GTI.getIndexedType()); 53102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Offset += Size*CI->getSExtValue(); 53202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 53302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else { 53402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Found our variable index. 53502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 53602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 53702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 5380cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 53902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If there are no variable indices, we must have a constant offset, just 54002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // evaluate it the general way. 54102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (i == e) return 0; 5420cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 54302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *VariableIdx = GEP->getOperand(i); 54402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Determine the scale factor of the variable element. For example, this is 54502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // 4 if the variable index is into an array of i32. 54602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner uint64_t VariableScale = TD.getTypeAllocSize(GTI.getIndexedType()); 5470cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 54802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Verify that there are no other variable indices. If so, emit the hard way. 54902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner for (++i, ++GTI; i != e; ++i, ++GTI) { 55002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt *CI = dyn_cast<ConstantInt>(GEP->getOperand(i)); 55102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!CI) return 0; 5520cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 55302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Compute the aggregate offset of constant indices. 55402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (CI->isZero()) continue; 5550cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 55602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Handle a struct index, which adds its field offset to the pointer. 557db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (StructType *STy = dyn_cast<StructType>(*GTI)) { 55802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Offset += TD.getStructLayout(STy)->getElementOffset(CI->getZExtValue()); 55902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else { 56002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner uint64_t Size = TD.getTypeAllocSize(GTI.getIndexedType()); 56102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Offset += Size*CI->getSExtValue(); 56202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 56302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 5640cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 56502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Okay, we know we have a single variable index, which must be a 56602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // pointer/array/vector index. If there is no offset, life is simple, return 56702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // the index. 568426c2bf5cdd2173e4a33aea8cb92cf684a724f4bChandler Carruth unsigned IntPtrWidth = TD.getPointerSizeInBits(); 56902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Offset == 0) { 57002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Cast to intptrty in case a truncation occurs. If an extension is needed, 57102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // we don't need to bother extending: the extension won't affect where the 57202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // computation crosses zero. 573107ffd58f70651cc928416f6aaf267accc992c23Eli Friedman if (VariableIdx->getType()->getPrimitiveSizeInBits() > IntPtrWidth) { 574ece6c6bb6329748b92403c06ac87f45c43485911Chandler Carruth Type *IntPtrTy = TD.getIntPtrType(VariableIdx->getContext()); 575107ffd58f70651cc928416f6aaf267accc992c23Eli Friedman VariableIdx = IC.Builder->CreateTrunc(VariableIdx, IntPtrTy); 576107ffd58f70651cc928416f6aaf267accc992c23Eli Friedman } 57702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return VariableIdx; 57802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 5790cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 58002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Otherwise, there is an index. The computation we will do will be modulo 58102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // the pointer size, so get it. 58202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner uint64_t PtrSizeMask = ~0ULL >> (64-IntPtrWidth); 5830cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 58402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Offset &= PtrSizeMask; 58502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner VariableScale &= PtrSizeMask; 5860cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 58702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // To do this transformation, any constant index must be a multiple of the 58802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // variable scale factor. For example, we can evaluate "12 + 4*i" as "3 + i", 58902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // but we can't evaluate "10 + 3*i" in terms of i. Check that the offset is a 59002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // multiple of the variable scale. 59102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner int64_t NewOffs = Offset / (int64_t)VariableScale; 59202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Offset != NewOffs*(int64_t)VariableScale) 59302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return 0; 5940cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 59502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Okay, we can do this evaluation. Start by converting the index to intptr. 596ece6c6bb6329748b92403c06ac87f45c43485911Chandler Carruth Type *IntPtrTy = TD.getIntPtrType(VariableIdx->getContext()); 59702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (VariableIdx->getType() != IntPtrTy) 598107ffd58f70651cc928416f6aaf267accc992c23Eli Friedman VariableIdx = IC.Builder->CreateIntCast(VariableIdx, IntPtrTy, 599107ffd58f70651cc928416f6aaf267accc992c23Eli Friedman true /*Signed*/); 60002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant *OffsetVal = ConstantInt::get(IntPtrTy, NewOffs); 601107ffd58f70651cc928416f6aaf267accc992c23Eli Friedman return IC.Builder->CreateAdd(VariableIdx, OffsetVal, "offset"); 60202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner} 60302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 60402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// FoldGEPICmp - Fold comparisons between a GEP instruction and something 60502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// else. At this point we know that the GEP is on the LHS of the comparison. 60602446fc99abb06d3117d65c0b1f5fba4f906db2eChris LattnerInstruction *InstCombiner::FoldGEPICmp(GEPOperator *GEPLHS, Value *RHS, 60702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ICmpInst::Predicate Cond, 60802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Instruction &I) { 6098294eb5599092e3d8e95c9c4d323ffa139499acfBenjamin Kramer // Don't transform signed compares of GEPs into index compares. Even if the 6108294eb5599092e3d8e95c9c4d323ffa139499acfBenjamin Kramer // GEP is inbounds, the final add of the base pointer can have signed overflow 6118294eb5599092e3d8e95c9c4d323ffa139499acfBenjamin Kramer // and would change the result of the icmp. 6128294eb5599092e3d8e95c9c4d323ffa139499acfBenjamin Kramer // e.g. "&foo[0] <s &foo[1]" can't be folded to "true" because "foo" could be 613a42d5c425251b6f30d46744d494817f788c408beBenjamin Kramer // the maximum signed value for the pointer type. 6148294eb5599092e3d8e95c9c4d323ffa139499acfBenjamin Kramer if (ICmpInst::isSigned(Cond)) 6158294eb5599092e3d8e95c9c4d323ffa139499acfBenjamin Kramer return 0; 6168294eb5599092e3d8e95c9c4d323ffa139499acfBenjamin Kramer 61702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Look through bitcasts. 61802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (BitCastInst *BCI = dyn_cast<BitCastInst>(RHS)) 61902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner RHS = BCI->getOperand(0); 62002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 62102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *PtrBase = GEPLHS->getOperand(0); 62202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (TD && PtrBase == RHS && GEPLHS->isInBounds()) { 62302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // ((gep Ptr, OFFSET) cmp Ptr) ---> (OFFSET cmp 0). 62402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // This transformation (ignoring the base and scales) is valid because we 62502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // know pointers can't overflow since the gep is inbounds. See if we can 62602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // output an optimized form. 627107ffd58f70651cc928416f6aaf267accc992c23Eli Friedman Value *Offset = EvaluateGEPOffsetExpression(GEPLHS, *this); 6280cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 62902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If not, synthesize the offset the hard way. 63002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Offset == 0) 63102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Offset = EmitGEPOffset(GEPLHS); 63202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::getSignedPredicate(Cond), Offset, 63302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant::getNullValue(Offset->getType())); 63402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else if (GEPOperator *GEPRHS = dyn_cast<GEPOperator>(RHS)) { 63502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If the base pointers are different, but the indices are the same, just 63602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // compare the base pointer. 63702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (PtrBase != GEPRHS->getOperand(0)) { 63802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner bool IndicesTheSame = GEPLHS->getNumOperands()==GEPRHS->getNumOperands(); 63902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner IndicesTheSame &= GEPLHS->getOperand(0)->getType() == 64002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner GEPRHS->getOperand(0)->getType(); 64102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (IndicesTheSame) 64202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner for (unsigned i = 1, e = GEPLHS->getNumOperands(); i != e; ++i) 64302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (GEPLHS->getOperand(i) != GEPRHS->getOperand(i)) { 64402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner IndicesTheSame = false; 64502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 64602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 64702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 64802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If all indices are the same, just compare the base pointers. 64902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (IndicesTheSame) 650c22a4eeec6967454c73d1430398298259e468b92David Majnemer return new ICmpInst(Cond, GEPLHS->getOperand(0), GEPRHS->getOperand(0)); 65102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 6529bb40853eeef1d11b626bdc58e00121e35187866Benjamin Kramer // If we're comparing GEPs with two base pointers that only differ in type 6539bb40853eeef1d11b626bdc58e00121e35187866Benjamin Kramer // and both GEPs have only constant indices or just one use, then fold 6549bb40853eeef1d11b626bdc58e00121e35187866Benjamin Kramer // the compare with the adjusted indices. 6556ad48f413743366c91b088a8e39d7f882200429dBenjamin Kramer if (TD && GEPLHS->isInBounds() && GEPRHS->isInBounds() && 6569bb40853eeef1d11b626bdc58e00121e35187866Benjamin Kramer (GEPLHS->hasAllConstantIndices() || GEPLHS->hasOneUse()) && 6579bb40853eeef1d11b626bdc58e00121e35187866Benjamin Kramer (GEPRHS->hasAllConstantIndices() || GEPRHS->hasOneUse()) && 6589bb40853eeef1d11b626bdc58e00121e35187866Benjamin Kramer PtrBase->stripPointerCasts() == 6599bb40853eeef1d11b626bdc58e00121e35187866Benjamin Kramer GEPRHS->getOperand(0)->stripPointerCasts()) { 6609bb40853eeef1d11b626bdc58e00121e35187866Benjamin Kramer Value *Cmp = Builder->CreateICmp(ICmpInst::getSignedPredicate(Cond), 6619bb40853eeef1d11b626bdc58e00121e35187866Benjamin Kramer EmitGEPOffset(GEPLHS), 6629bb40853eeef1d11b626bdc58e00121e35187866Benjamin Kramer EmitGEPOffset(GEPRHS)); 6639bb40853eeef1d11b626bdc58e00121e35187866Benjamin Kramer return ReplaceInstUsesWith(I, Cmp); 6649bb40853eeef1d11b626bdc58e00121e35187866Benjamin Kramer } 6659bb40853eeef1d11b626bdc58e00121e35187866Benjamin Kramer 66602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Otherwise, the base pointers are different and the indices are 66702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // different, bail out. 66802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return 0; 66902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 67002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 67102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If one of the GEPs has all zero indices, recurse. 67202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner bool AllZeros = true; 67302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner for (unsigned i = 1, e = GEPLHS->getNumOperands(); i != e; ++i) 67402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!isa<Constant>(GEPLHS->getOperand(i)) || 67502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner !cast<Constant>(GEPLHS->getOperand(i))->isNullValue()) { 67602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner AllZeros = false; 67702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 67802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 67902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (AllZeros) 68002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return FoldGEPICmp(GEPRHS, GEPLHS->getOperand(0), 681df703257c1dafed4cdb803996a5c277d95780799David Majnemer ICmpInst::getSwappedPredicate(Cond), I); 68202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 68302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If the other GEP has all zero indices, recurse. 68402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner AllZeros = true; 68502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner for (unsigned i = 1, e = GEPRHS->getNumOperands(); i != e; ++i) 68602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!isa<Constant>(GEPRHS->getOperand(i)) || 68702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner !cast<Constant>(GEPRHS->getOperand(i))->isNullValue()) { 68802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner AllZeros = false; 68902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 69002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 69102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (AllZeros) 69202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return FoldGEPICmp(GEPLHS, GEPRHS->getOperand(0), Cond, I); 69302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 69467f071e69795dca1151cdb8d57d222b6f041d748Stuart Hastings bool GEPsInBounds = GEPLHS->isInBounds() && GEPRHS->isInBounds(); 69502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (GEPLHS->getNumOperands() == GEPRHS->getNumOperands()) { 69602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If the GEPs only differ by one index, compare it. 69702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner unsigned NumDifferences = 0; // Keep track of # differences. 69802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner unsigned DiffOperand = 0; // The operand that differs. 69902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner for (unsigned i = 1, e = GEPRHS->getNumOperands(); i != e; ++i) 70002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (GEPLHS->getOperand(i) != GEPRHS->getOperand(i)) { 70102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (GEPLHS->getOperand(i)->getType()->getPrimitiveSizeInBits() != 70202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner GEPRHS->getOperand(i)->getType()->getPrimitiveSizeInBits()) { 70302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Irreconcilable differences. 70402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner NumDifferences = 2; 70502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 70602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else { 70702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (NumDifferences++) break; 70802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner DiffOperand = i; 70902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 71002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 71102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 7127de80e04d9ced64a95316eec5155b52c163592c2Rafael Espindola if (NumDifferences == 0) // SAME GEP? 7137de80e04d9ced64a95316eec5155b52c163592c2Rafael Espindola return ReplaceInstUsesWith(I, // No comparison is needed here. 7143facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak Builder->getInt1(ICmpInst::isTrueWhenEqual(Cond))); 71502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 71667f071e69795dca1151cdb8d57d222b6f041d748Stuart Hastings else if (NumDifferences == 1 && GEPsInBounds) { 71702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *LHSV = GEPLHS->getOperand(DiffOperand); 71802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *RHSV = GEPRHS->getOperand(DiffOperand); 71902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Make sure we do a signed comparison here. 72002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::getSignedPredicate(Cond), LHSV, RHSV); 72102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 72202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 72302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 72402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Only lower this if the icmp is the only user of the GEP or if we expect 72502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // the result to fold to a constant! 72602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (TD && 72767f071e69795dca1151cdb8d57d222b6f041d748Stuart Hastings GEPsInBounds && 72802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner (isa<ConstantExpr>(GEPLHS) || GEPLHS->hasOneUse()) && 72902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner (isa<ConstantExpr>(GEPRHS) || GEPRHS->hasOneUse())) { 73002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // ((gep Ptr, OFFSET1) cmp (gep Ptr, OFFSET2) ---> (OFFSET1 cmp OFFSET2) 73102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *L = EmitGEPOffset(GEPLHS); 73202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *R = EmitGEPOffset(GEPRHS); 73302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::getSignedPredicate(Cond), L, R); 73402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 73502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 73602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return 0; 73702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner} 73802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 73902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// FoldICmpAddOpCst - Fold "icmp pred (X+CI), X". 74002446fc99abb06d3117d65c0b1f5fba4f906db2eChris LattnerInstruction *InstCombiner::FoldICmpAddOpCst(ICmpInst &ICI, 74102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *X, ConstantInt *CI, 74202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ICmpInst::Predicate Pred, 74302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *TheAdd) { 74402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If we have X+0, exit early (simplifying logic below) and let it get folded 74502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // elsewhere. icmp X+0, X -> icmp X, X 74602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (CI->isZero()) { 74702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner bool isTrue = ICmpInst::isTrueWhenEqual(Pred); 74802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return ReplaceInstUsesWith(ICI, ConstantInt::get(ICI.getType(), isTrue)); 74902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 7500cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 75102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (X+4) == X -> false. 75202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Pred == ICmpInst::ICMP_EQ) 7533facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak return ReplaceInstUsesWith(ICI, Builder->getFalse()); 75402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 75502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (X+4) != X -> true. 75602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Pred == ICmpInst::ICMP_NE) 7573facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak return ReplaceInstUsesWith(ICI, Builder->getTrue()); 75802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 75902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // From this point on, we know that (X+C <= X) --> (X+C < X) because C != 0, 7607a2bdde0a0eebcd2125055e0eacaca040f0b766cChris Lattner // so the values can never be equal. Similarly for all other "or equals" 76102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // operators. 7620cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 7639aa1e246dd15dfc73a2f6f44766ca97ba9573c9dChris Lattner // (X+1) <u X --> X >u (MAXUINT-1) --> X == 255 76402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (X+2) <u X --> X >u (MAXUINT-2) --> X > 253 76502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (X+MAXUINT) <u X --> X >u (MAXUINT-MAXUINT) --> X != 0 76602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Pred == ICmpInst::ICMP_ULT || Pred == ICmpInst::ICMP_ULE) { 7670cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach Value *R = 7689aa1e246dd15dfc73a2f6f44766ca97ba9573c9dChris Lattner ConstantExpr::getSub(ConstantInt::getAllOnesValue(CI->getType()), CI); 76902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_UGT, X, R); 77002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 7710cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 77202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (X+1) >u X --> X <u (0-1) --> X != 255 77302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (X+2) >u X --> X <u (0-2) --> X <u 254 77402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (X+MAXUINT) >u X --> X <u (0-MAXUINT) --> X <u 1 --> X == 0 775a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands if (Pred == ICmpInst::ICMP_UGT || Pred == ICmpInst::ICMP_UGE) 77602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_ULT, X, ConstantExpr::getNeg(CI)); 7770cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 77802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner unsigned BitWidth = CI->getType()->getPrimitiveSizeInBits(); 77902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt *SMax = ConstantInt::get(X->getContext(), 78002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner APInt::getSignedMaxValue(BitWidth)); 78102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 78202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (X+ 1) <s X --> X >s (MAXSINT-1) --> X == 127 78302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (X+ 2) <s X --> X >s (MAXSINT-2) --> X >s 125 78402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (X+MAXSINT) <s X --> X >s (MAXSINT-MAXSINT) --> X >s 0 78502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (X+MINSINT) <s X --> X >s (MAXSINT-MINSINT) --> X >s -1 78602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (X+ -2) <s X --> X >s (MAXSINT- -2) --> X >s 126 78702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (X+ -1) <s X --> X >s (MAXSINT- -1) --> X != 127 788a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands if (Pred == ICmpInst::ICMP_SLT || Pred == ICmpInst::ICMP_SLE) 78902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_SGT, X, ConstantExpr::getSub(SMax, CI)); 7900cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 79102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (X+ 1) >s X --> X <s (MAXSINT-(1-1)) --> X != 127 79202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (X+ 2) >s X --> X <s (MAXSINT-(2-1)) --> X <s 126 79302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (X+MAXSINT) >s X --> X <s (MAXSINT-(MAXSINT-1)) --> X <s 1 79402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (X+MINSINT) >s X --> X <s (MAXSINT-(MINSINT-1)) --> X <s -2 79502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (X+ -2) >s X --> X <s (MAXSINT-(-2-1)) --> X <s -126 79602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (X+ -1) >s X --> X <s (MAXSINT-(-1-1)) --> X == -128 7970cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 79802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner assert(Pred == ICmpInst::ICMP_SGT || Pred == ICmpInst::ICMP_SGE); 7993facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak Constant *C = Builder->getInt(CI->getValue()-1); 80002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_SLT, X, ConstantExpr::getSub(SMax, C)); 80102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner} 80202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 80302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// FoldICmpDivCst - Fold "icmp pred, ([su]div X, DivRHS), CmpRHS" where DivRHS 80402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// and CmpRHS are both known to be integer constants. 80502446fc99abb06d3117d65c0b1f5fba4f906db2eChris LattnerInstruction *InstCombiner::FoldICmpDivCst(ICmpInst &ICI, BinaryOperator *DivI, 80602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt *DivRHS) { 80702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt *CmpRHS = cast<ConstantInt>(ICI.getOperand(1)); 80802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner const APInt &CmpRHSV = CmpRHS->getValue(); 8090cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 8100cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // FIXME: If the operand types don't match the type of the divide 81102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // then don't attempt this transform. The code below doesn't have the 81202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // logic to deal with a signed divide and an unsigned compare (and 8130cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // vice versa). This is because (x /s C1) <s C2 produces different 81402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // results than (x /s C1) <u C2 or (x /u C1) <s C2 or even 8150cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // (x /u C1) <u C2. Simply casting the operands and result won't 8160cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // work. :( The if statement below tests that condition and bails 817b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner // if it finds it. 81802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner bool DivIsSigned = DivI->getOpcode() == Instruction::SDiv; 81902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!ICI.isEquality() && DivIsSigned != ICI.isSigned()) 82002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return 0; 82102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (DivRHS->isZero()) 82202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return 0; // The ProdOV computation fails on divide by zero. 82302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (DivIsSigned && DivRHS->isAllOnesValue()) 82402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return 0; // The overflow computation also screws up here 825bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner if (DivRHS->isOne()) { 826bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner // This eliminates some funny cases with INT_MIN. 827bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner ICI.setOperand(0, DivI->getOperand(0)); // X/1 == X. 828bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner return &ICI; 829bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner } 83002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 83102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Compute Prod = CI * DivRHS. We are essentially solving an equation 8320cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // of form X/C1=C2. We solve for X by multiplying C1 (DivRHS) and 8330cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // C2 (CI). By solving for X we can turn this into a range check 8340cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // instead of computing a divide. 83502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant *Prod = ConstantExpr::getMul(CmpRHS, DivRHS); 83602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 83702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Determine if the product overflows by seeing if the product is 83802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // not equal to the divide. Make sure we do the same kind of divide 8390cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // as in the LHS instruction that we're folding. 84002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner bool ProdOV = (DivIsSigned ? ConstantExpr::getSDiv(Prod, DivRHS) : 84102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantExpr::getUDiv(Prod, DivRHS)) != CmpRHS; 84202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 84302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Get the ICmp opcode 84402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ICmpInst::Predicate Pred = ICI.getPredicate(); 84502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 846b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner /// If the division is known to be exact, then there is no remainder from the 847b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner /// divide, so the covered range size is unit, otherwise it is the divisor. 848b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner ConstantInt *RangeSize = DivI->isExact() ? getOne(Prod) : DivRHS; 8490cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 85002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Figure out the interval that is being checked. For example, a comparison 8510cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // like "X /u 5 == 0" is really checking that X is in the interval [0, 5). 85202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Compute this interval based on the constants involved and the signedness of 85302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // the compare/divide. This computes a half-open interval, keeping track of 85402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // whether either value in the interval overflows. After analysis each 85502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // overflow variable is set to 0 if it's corresponding bound variable is valid 85602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // -1 if overflowed off the bottom end, or +1 if overflowed off the top end. 85702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner int LoOverflow = 0, HiOverflow = 0; 85802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant *LoBound = 0, *HiBound = 0; 859b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner 86002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!DivIsSigned) { // udiv 86102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // e.g. X/5 op 3 --> [15, 20) 86202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner LoBound = Prod; 86302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner HiOverflow = LoOverflow = ProdOV; 864b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner if (!HiOverflow) { 865b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner // If this is not an exact divide, then many values in the range collapse 866b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner // to the same result value. 867b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner HiOverflow = AddWithOverflow(HiBound, LoBound, RangeSize, false); 868b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner } 8690cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 87002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else if (DivRHS->getValue().isStrictlyPositive()) { // Divisor is > 0. 87102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (CmpRHSV == 0) { // (X / pos) op 0 87202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Can't overflow. e.g. X/2 op 0 --> [-1, 2) 873b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner LoBound = ConstantExpr::getNeg(SubOne(RangeSize)); 874b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner HiBound = RangeSize; 87502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else if (CmpRHSV.isStrictlyPositive()) { // (X / pos) op pos 87602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner LoBound = Prod; // e.g. X/5 op 3 --> [15, 20) 87702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner HiOverflow = LoOverflow = ProdOV; 87802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!HiOverflow) 879b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner HiOverflow = AddWithOverflow(HiBound, Prod, RangeSize, true); 88002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else { // (X / pos) op neg 88102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // e.g. X/5 op -3 --> [-15-4, -15+1) --> [-19, -14) 88202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner HiBound = AddOne(Prod); 88302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner LoOverflow = HiOverflow = ProdOV ? -1 : 0; 88402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!LoOverflow) { 885b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner ConstantInt *DivNeg =cast<ConstantInt>(ConstantExpr::getNeg(RangeSize)); 88602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner LoOverflow = AddWithOverflow(LoBound, HiBound, DivNeg, true) ? -1 : 0; 887b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner } 88802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 889c73b24db5f6226ed44ebc44ce1c25bb357206623Chris Lattner } else if (DivRHS->isNegative()) { // Divisor is < 0. 890b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner if (DivI->isExact()) 891b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner RangeSize = cast<ConstantInt>(ConstantExpr::getNeg(RangeSize)); 89202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (CmpRHSV == 0) { // (X / neg) op 0 89302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // e.g. X/-5 op 0 --> [-4, 5) 894b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner LoBound = AddOne(RangeSize); 895b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner HiBound = cast<ConstantInt>(ConstantExpr::getNeg(RangeSize)); 89602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (HiBound == DivRHS) { // -INTMIN = INTMIN 89702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner HiOverflow = 1; // [INTMIN+1, overflow) 89802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner HiBound = 0; // e.g. X/INTMIN = 0 --> X > INTMIN 89902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 90002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else if (CmpRHSV.isStrictlyPositive()) { // (X / neg) op pos 90102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // e.g. X/-5 op 3 --> [-19, -14) 90202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner HiBound = AddOne(Prod); 90302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner HiOverflow = LoOverflow = ProdOV ? -1 : 0; 90402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!LoOverflow) 905b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner LoOverflow = AddWithOverflow(LoBound, HiBound, RangeSize, true) ? -1:0; 90602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else { // (X / neg) op neg 90702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner LoBound = Prod; // e.g. X/-5 op -3 --> [15, 20) 90802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner LoOverflow = HiOverflow = ProdOV; 90902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!HiOverflow) 910b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner HiOverflow = SubWithOverflow(HiBound, Prod, RangeSize, true); 91102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 9120cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 91302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Dividing by a negative swaps the condition. LT <-> GT 91402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Pred = ICmpInst::getSwappedPredicate(Pred); 91502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 91602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 91702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *X = DivI->getOperand(0); 91802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner switch (Pred) { 91902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner default: llvm_unreachable("Unhandled icmp opcode!"); 92002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_EQ: 92102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (LoOverflow && HiOverflow) 9223facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak return ReplaceInstUsesWith(ICI, Builder->getFalse()); 923f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner if (HiOverflow) 92402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(DivIsSigned ? ICmpInst::ICMP_SGE : 92502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ICmpInst::ICMP_UGE, X, LoBound); 926f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner if (LoOverflow) 92702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(DivIsSigned ? ICmpInst::ICMP_SLT : 92802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ICmpInst::ICMP_ULT, X, HiBound); 929b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner return ReplaceInstUsesWith(ICI, InsertRangeTest(X, LoBound, HiBound, 930b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner DivIsSigned, true)); 93102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_NE: 93202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (LoOverflow && HiOverflow) 9333facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak return ReplaceInstUsesWith(ICI, Builder->getTrue()); 934f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner if (HiOverflow) 93502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(DivIsSigned ? ICmpInst::ICMP_SLT : 93602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ICmpInst::ICMP_ULT, X, LoBound); 937f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner if (LoOverflow) 93802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(DivIsSigned ? ICmpInst::ICMP_SGE : 93902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ICmpInst::ICMP_UGE, X, HiBound); 940f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner return ReplaceInstUsesWith(ICI, InsertRangeTest(X, LoBound, HiBound, 941f34f48c57870cf4eb4d48e23b11e29b95d1950c3Chris Lattner DivIsSigned, false)); 94202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_ULT: 94302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_SLT: 94402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (LoOverflow == +1) // Low bound is greater than input range. 9453facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak return ReplaceInstUsesWith(ICI, Builder->getTrue()); 94602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (LoOverflow == -1) // Low bound is less than input range. 9473facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak return ReplaceInstUsesWith(ICI, Builder->getFalse()); 94802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(Pred, X, LoBound); 94902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_UGT: 95002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_SGT: 95102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (HiOverflow == +1) // High bound greater than input range. 9523facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak return ReplaceInstUsesWith(ICI, Builder->getFalse()); 953b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner if (HiOverflow == -1) // High bound less than input range. 9543facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak return ReplaceInstUsesWith(ICI, Builder->getTrue()); 95502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Pred == ICmpInst::ICMP_UGT) 95602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_UGE, X, HiBound); 957b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner return new ICmpInst(ICmpInst::ICMP_SGE, X, HiBound); 95802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 95902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner} 96002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 96174542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner/// FoldICmpShrCst - Handle "icmp(([al]shr X, cst1), cst2)". 96274542aa5001fb6ff3d7d0958b5c391cde63df1caChris LattnerInstruction *InstCombiner::FoldICmpShrCst(ICmpInst &ICI, BinaryOperator *Shr, 96374542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner ConstantInt *ShAmt) { 96474542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner const APInt &CmpRHSV = cast<ConstantInt>(ICI.getOperand(1))->getValue(); 9650cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 96674542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner // Check that the shift amount is in range. If not, don't perform 96774542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner // undefined shifts. When the shift is visited it will be 96874542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner // simplified. 96974542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner uint32_t TypeBits = CmpRHSV.getBitWidth(); 97074542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner uint32_t ShAmtVal = (uint32_t)ShAmt->getLimitedValue(TypeBits); 971bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner if (ShAmtVal >= TypeBits || ShAmtVal == 0) 97274542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner return 0; 9730cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 974bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner if (!ICI.isEquality()) { 975bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner // If we have an unsigned comparison and an ashr, we can't simplify this. 976bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner // Similarly for signed comparisons with lshr. 977bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner if (ICI.isSigned() != (Shr->getOpcode() == Instruction::AShr)) 978bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner return 0; 9790cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 980a831a9b972f1b4fa4f3457acf303abbfc71c1edeEli Friedman // Otherwise, all lshr and most exact ashr's are equivalent to a udiv/sdiv 981a831a9b972f1b4fa4f3457acf303abbfc71c1edeEli Friedman // by a power of 2. Since we already have logic to simplify these, 982a831a9b972f1b4fa4f3457acf303abbfc71c1edeEli Friedman // transform to div and then simplify the resultant comparison. 983bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner if (Shr->getOpcode() == Instruction::AShr && 984a831a9b972f1b4fa4f3457acf303abbfc71c1edeEli Friedman (!Shr->isExact() || ShAmtVal == TypeBits - 1)) 985bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner return 0; 9860cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 987bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner // Revisit the shift (to delete it). 988bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner Worklist.Add(Shr); 9890cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 990bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner Constant *DivCst = 991bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner ConstantInt::get(Shr->getType(), APInt::getOneBitSet(TypeBits, ShAmtVal)); 9920cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 993bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner Value *Tmp = 994bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner Shr->getOpcode() == Instruction::AShr ? 995bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner Builder->CreateSDiv(Shr->getOperand(0), DivCst, "", Shr->isExact()) : 996bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner Builder->CreateUDiv(Shr->getOperand(0), DivCst, "", Shr->isExact()); 9970cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 998bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner ICI.setOperand(0, Tmp); 9990cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 1000bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner // If the builder folded the binop, just return it. 1001bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner BinaryOperator *TheDiv = dyn_cast<BinaryOperator>(Tmp); 1002bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner if (TheDiv == 0) 1003bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner return &ICI; 10040cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 1005bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner // Otherwise, fold this div/compare. 1006bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner assert(TheDiv->getOpcode() == Instruction::SDiv || 1007bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner TheDiv->getOpcode() == Instruction::UDiv); 10080cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 1009bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner Instruction *Res = FoldICmpDivCst(ICI, TheDiv, cast<ConstantInt>(DivCst)); 1010bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner assert(Res && "This div/cst should have folded!"); 1011bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner return Res; 1012bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner } 10130cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 10140cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 101574542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner // If we are comparing against bits always shifted out, the 101674542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner // comparison cannot succeed. 101774542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner APInt Comp = CmpRHSV << ShAmtVal; 10183facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak ConstantInt *ShiftedCmpRHS = Builder->getInt(Comp); 101974542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner if (Shr->getOpcode() == Instruction::LShr) 102074542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner Comp = Comp.lshr(ShAmtVal); 102174542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner else 102274542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner Comp = Comp.ashr(ShAmtVal); 10230cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 102474542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner if (Comp != CmpRHSV) { // Comparing against a bit that we know is zero. 102574542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner bool IsICMP_NE = ICI.getPredicate() == ICmpInst::ICMP_NE; 10263facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak Constant *Cst = Builder->getInt1(IsICMP_NE); 102774542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner return ReplaceInstUsesWith(ICI, Cst); 102874542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner } 10290cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 103074542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner // Otherwise, check to see if the bits shifted out are known to be zero. 103174542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner // If so, we can compare against the unshifted value: 103274542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner // (X & 4) >> 1 == 2 --> (X & 4) == 4. 1033e5116f840eedbc3cffa31adc683b4e37d53f2c7aChris Lattner if (Shr->hasOneUse() && Shr->isExact()) 103474542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner return new ICmpInst(ICI.getPredicate(), Shr->getOperand(0), ShiftedCmpRHS); 10350cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 103674542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner if (Shr->hasOneUse()) { 103774542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner // Otherwise strength reduce the shift into an and. 103874542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner APInt Val(APInt::getHighBitsSet(TypeBits, TypeBits - ShAmtVal)); 10393facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak Constant *Mask = Builder->getInt(Val); 10400cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 104174542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner Value *And = Builder->CreateAnd(Shr->getOperand(0), 104274542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner Mask, Shr->getName()+".mask"); 104374542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner return new ICmpInst(ICI.getPredicate(), And, ShiftedCmpRHS); 104474542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner } 104574542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner return 0; 104674542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner} 104774542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner 104802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 104902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// visitICmpInstWithInstAndIntCst - Handle "icmp (instr, intcst)". 105002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// 105102446fc99abb06d3117d65c0b1f5fba4f906db2eChris LattnerInstruction *InstCombiner::visitICmpInstWithInstAndIntCst(ICmpInst &ICI, 105202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Instruction *LHSI, 105302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt *RHS) { 105402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner const APInt &RHSV = RHS->getValue(); 10550cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 105602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner switch (LHSI->getOpcode()) { 105702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::Trunc: 105802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ICI.isEquality() && LHSI->hasOneUse()) { 105902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Simplify icmp eq (trunc x to i8), 42 -> icmp eq x, 42|highbits if all 106002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // of the high bits truncated out of x are known. 106102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner unsigned DstBits = LHSI->getType()->getPrimitiveSizeInBits(), 106202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner SrcBits = LHSI->getOperand(0)->getType()->getPrimitiveSizeInBits(); 106302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner APInt KnownZero(SrcBits, 0), KnownOne(SrcBits, 0); 106426c8dcc692fb2addd475446cfff24d6a4e958bcaRafael Espindola ComputeMaskedBits(LHSI->getOperand(0), KnownZero, KnownOne); 10650cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 106602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If all the high bits are known, we can do this xform. 106702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if ((KnownZero|KnownOne).countLeadingOnes() >= SrcBits-DstBits) { 106802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Pull in the high bits from known-ones set. 106940f8f6264d5af2c38e797e0dc59827cd231e8ff7Jay Foad APInt NewRHS = RHS->getValue().zext(SrcBits); 10705b6dfee28e86529030cabdc356e00b4d70747d65Eli Friedman NewRHS |= KnownOne & APInt::getHighBitsSet(SrcBits, SrcBits-DstBits); 107102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICI.getPredicate(), LHSI->getOperand(0), 10723facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak Builder->getInt(NewRHS)); 107302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 107402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 107502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 10760cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 107702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::Xor: // (icmp pred (xor X, XorCST), CI) 107802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ConstantInt *XorCST = dyn_cast<ConstantInt>(LHSI->getOperand(1))) { 107902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If this is a comparison that tests the signbit (X < 0) or (x > -1), 108002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // fold the xor. 108102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if ((ICI.getPredicate() == ICmpInst::ICMP_SLT && RHSV == 0) || 108202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner (ICI.getPredicate() == ICmpInst::ICMP_SGT && RHSV.isAllOnesValue())) { 108302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *CompareVal = LHSI->getOperand(0); 10840cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 108502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If the sign bit of the XorCST is not set, there is no change to 108602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // the operation, just stop using the Xor. 1087c73b24db5f6226ed44ebc44ce1c25bb357206623Chris Lattner if (!XorCST->isNegative()) { 108802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ICI.setOperand(0, CompareVal); 108902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Worklist.Add(LHSI); 109002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return &ICI; 109102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 10920cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 109302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Was the old condition true if the operand is positive? 109402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner bool isTrueIfPositive = ICI.getPredicate() == ICmpInst::ICMP_SGT; 10950cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 109602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If so, the new one isn't. 109702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner isTrueIfPositive ^= true; 10980cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 109902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (isTrueIfPositive) 110002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_SGT, CompareVal, 110102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner SubOne(RHS)); 110202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner else 110302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_SLT, CompareVal, 110402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner AddOne(RHS)); 110502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 110602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 110702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (LHSI->hasOneUse()) { 110802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (icmp u/s (xor A SignBit), C) -> (icmp s/u A, (xor C SignBit)) 110902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!ICI.isEquality() && XorCST->getValue().isSignBit()) { 111002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner const APInt &SignBit = XorCST->getValue(); 111102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ICmpInst::Predicate Pred = ICI.isSigned() 111202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ? ICI.getUnsignedPredicate() 111302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner : ICI.getSignedPredicate(); 111402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(Pred, LHSI->getOperand(0), 11153facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak Builder->getInt(RHSV ^ SignBit)); 111602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 111702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 111802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (icmp u/s (xor A ~SignBit), C) -> (icmp s/u (xor C ~SignBit), A) 1119c73b24db5f6226ed44ebc44ce1c25bb357206623Chris Lattner if (!ICI.isEquality() && XorCST->isMaxValue(true)) { 112002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner const APInt &NotSignBit = XorCST->getValue(); 112102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ICmpInst::Predicate Pred = ICI.isSigned() 112202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ? ICI.getUnsignedPredicate() 112302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner : ICI.getSignedPredicate(); 112402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Pred = ICI.getSwappedPredicate(Pred); 112502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(Pred, LHSI->getOperand(0), 11263facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak Builder->getInt(RHSV ^ NotSignBit)); 112702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 112802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 1129fecf0d7a0157011964b4f31a7a5374076b1b236cDavid Majnemer 1130fecf0d7a0157011964b4f31a7a5374076b1b236cDavid Majnemer // (icmp ugt (xor X, C), ~C) -> (icmp ult X, C) 1131fecf0d7a0157011964b4f31a7a5374076b1b236cDavid Majnemer // iff -C is a power of 2 1132fecf0d7a0157011964b4f31a7a5374076b1b236cDavid Majnemer if (ICI.getPredicate() == ICmpInst::ICMP_UGT && 1133fecf0d7a0157011964b4f31a7a5374076b1b236cDavid Majnemer XorCST->getValue() == ~RHSV && (RHSV + 1).isPowerOf2()) 1134fecf0d7a0157011964b4f31a7a5374076b1b236cDavid Majnemer return new ICmpInst(ICmpInst::ICMP_ULT, LHSI->getOperand(0), XorCST); 1135fecf0d7a0157011964b4f31a7a5374076b1b236cDavid Majnemer 1136fecf0d7a0157011964b4f31a7a5374076b1b236cDavid Majnemer // (icmp ult (xor X, C), -C) -> (icmp uge X, C) 1137fecf0d7a0157011964b4f31a7a5374076b1b236cDavid Majnemer // iff -C is a power of 2 1138fecf0d7a0157011964b4f31a7a5374076b1b236cDavid Majnemer if (ICI.getPredicate() == ICmpInst::ICMP_ULT && 1139fecf0d7a0157011964b4f31a7a5374076b1b236cDavid Majnemer XorCST->getValue() == -RHSV && RHSV.isPowerOf2()) 1140fecf0d7a0157011964b4f31a7a5374076b1b236cDavid Majnemer return new ICmpInst(ICmpInst::ICMP_UGE, LHSI->getOperand(0), XorCST); 114102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 114202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 114302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::And: // (icmp pred (and X, AndCST), RHS) 114402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (LHSI->hasOneUse() && isa<ConstantInt>(LHSI->getOperand(1)) && 114502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner LHSI->getOperand(0)->hasOneUse()) { 114602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt *AndCST = cast<ConstantInt>(LHSI->getOperand(1)); 11470cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 114802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If the LHS is an AND of a truncating cast, we can widen the 114902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // and/compare to be the input width without changing the value 115002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // produced, eliminating a cast. 115102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (TruncInst *Cast = dyn_cast<TruncInst>(LHSI->getOperand(0))) { 115202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // We can do this transformation if either the AND constant does not 11530cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // have its sign bit set or if it is an equality comparison. 115402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Extending a relational comparison when we're checking the sign 115502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // bit would not work. 11567e7c9cc31a9c0ca337235ae04fc268e58da1d01bBenjamin Kramer if (ICI.isEquality() || 1157c73b24db5f6226ed44ebc44ce1c25bb357206623Chris Lattner (!AndCST->isNegative() && RHSV.isNonNegative())) { 11587e7c9cc31a9c0ca337235ae04fc268e58da1d01bBenjamin Kramer Value *NewAnd = 115902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Builder->CreateAnd(Cast->getOperand(0), 11607e7c9cc31a9c0ca337235ae04fc268e58da1d01bBenjamin Kramer ConstantExpr::getZExt(AndCST, Cast->getSrcTy())); 11617e7c9cc31a9c0ca337235ae04fc268e58da1d01bBenjamin Kramer NewAnd->takeName(LHSI); 116202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICI.getPredicate(), NewAnd, 11637e7c9cc31a9c0ca337235ae04fc268e58da1d01bBenjamin Kramer ConstantExpr::getZExt(RHS, Cast->getSrcTy())); 116402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 116502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 1166ffd0ae64c497d13956d16526c46245bfbf48e91fBenjamin Kramer 1167ffd0ae64c497d13956d16526c46245bfbf48e91fBenjamin Kramer // If the LHS is an AND of a zext, and we have an equality compare, we can 1168ffd0ae64c497d13956d16526c46245bfbf48e91fBenjamin Kramer // shrink the and/compare to the smaller type, eliminating the cast. 1169ffd0ae64c497d13956d16526c46245bfbf48e91fBenjamin Kramer if (ZExtInst *Cast = dyn_cast<ZExtInst>(LHSI->getOperand(0))) { 1170db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner IntegerType *Ty = cast<IntegerType>(Cast->getSrcTy()); 1171ffd0ae64c497d13956d16526c46245bfbf48e91fBenjamin Kramer // Make sure we don't compare the upper bits, SimplifyDemandedBits 1172ffd0ae64c497d13956d16526c46245bfbf48e91fBenjamin Kramer // should fold the icmp to true/false in that case. 1173ffd0ae64c497d13956d16526c46245bfbf48e91fBenjamin Kramer if (ICI.isEquality() && RHSV.getActiveBits() <= Ty->getBitWidth()) { 1174ffd0ae64c497d13956d16526c46245bfbf48e91fBenjamin Kramer Value *NewAnd = 1175ffd0ae64c497d13956d16526c46245bfbf48e91fBenjamin Kramer Builder->CreateAnd(Cast->getOperand(0), 1176ffd0ae64c497d13956d16526c46245bfbf48e91fBenjamin Kramer ConstantExpr::getTrunc(AndCST, Ty)); 1177ffd0ae64c497d13956d16526c46245bfbf48e91fBenjamin Kramer NewAnd->takeName(LHSI); 1178ffd0ae64c497d13956d16526c46245bfbf48e91fBenjamin Kramer return new ICmpInst(ICI.getPredicate(), NewAnd, 1179ffd0ae64c497d13956d16526c46245bfbf48e91fBenjamin Kramer ConstantExpr::getTrunc(RHS, Ty)); 1180ffd0ae64c497d13956d16526c46245bfbf48e91fBenjamin Kramer } 1181ffd0ae64c497d13956d16526c46245bfbf48e91fBenjamin Kramer } 1182ffd0ae64c497d13956d16526c46245bfbf48e91fBenjamin Kramer 118302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If this is: (X >> C1) & C2 != C3 (where any shift and any compare 118402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // could exist), turn it into (X & (C2 << C1)) != (C3 << C1). This 118502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // happens a LOT in code produced by the C front-end, for bitfield 118602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // access. 118702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner BinaryOperator *Shift = dyn_cast<BinaryOperator>(LHSI->getOperand(0)); 118802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Shift && !Shift->isShift()) 118902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Shift = 0; 11900cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 119102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt *ShAmt; 119202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ShAmt = Shift ? dyn_cast<ConstantInt>(Shift->getOperand(1)) : 0; 1193db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty = Shift ? Shift->getType() : 0; // Type of the shift. 1194db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *AndTy = AndCST->getType(); // Type of the and. 11950cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 119602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // We can fold this as long as we can't shift unknown bits 119702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // into the mask. This can only happen with signed shift 119802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // rights, as they sign-extend. 119902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ShAmt) { 120002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner bool CanFold = Shift->isLogicalShift(); 120102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!CanFold) { 120202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // To test for the bad case of the signed shr, see if any 120302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // of the bits shifted in could be tested after the mask. 120402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner uint32_t TyBits = Ty->getPrimitiveSizeInBits(); 120502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner int ShAmtVal = TyBits - ShAmt->getLimitedValue(TyBits); 12060cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 120702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner uint32_t BitWidth = AndTy->getPrimitiveSizeInBits(); 12080cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach if ((APInt::getHighBitsSet(BitWidth, BitWidth-ShAmtVal) & 120902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner AndCST->getValue()) == 0) 121002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner CanFold = true; 121102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 12120cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 121302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (CanFold) { 121402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant *NewCst; 121502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Shift->getOpcode() == Instruction::Shl) 121602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner NewCst = ConstantExpr::getLShr(RHS, ShAmt); 121702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner else 121802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner NewCst = ConstantExpr::getShl(RHS, ShAmt); 12190cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 122002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Check to see if we are shifting out any of the bits being 122102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // compared. 122202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ConstantExpr::get(Shift->getOpcode(), 122302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner NewCst, ShAmt) != RHS) { 122402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If we shifted bits out, the fold is not going to work out. 122502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // As a special case, check to see if this means that the 122602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // result is always true or false now. 122702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ICI.getPredicate() == ICmpInst::ICMP_EQ) 12283facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak return ReplaceInstUsesWith(ICI, Builder->getFalse()); 122902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ICI.getPredicate() == ICmpInst::ICMP_NE) 12303facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak return ReplaceInstUsesWith(ICI, Builder->getTrue()); 123102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else { 123202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ICI.setOperand(1, NewCst); 123302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant *NewAndCST; 123402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Shift->getOpcode() == Instruction::Shl) 123502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner NewAndCST = ConstantExpr::getLShr(AndCST, ShAmt); 123602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner else 123702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner NewAndCST = ConstantExpr::getShl(AndCST, ShAmt); 123802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner LHSI->setOperand(1, NewAndCST); 123902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner LHSI->setOperand(0, Shift->getOperand(0)); 124002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Worklist.Add(Shift); // Shift is dead. 124102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return &ICI; 124202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 124302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 124402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 12450cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 124602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Turn ((X >> Y) & C) == 0 into (X & (C << Y)) == 0. The later is 124702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // preferable because it allows the C<<Y expression to be hoisted out 124802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // of a loop if Y is invariant and X is not. 124902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Shift && Shift->hasOneUse() && RHSV == 0 && 125002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ICI.isEquality() && !Shift->isArithmeticShift() && 125102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner !isa<Constant>(Shift->getOperand(0))) { 125202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Compute C << Y. 125302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *NS; 125402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Shift->getOpcode() == Instruction::LShr) { 1255a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer NS = Builder->CreateShl(AndCST, Shift->getOperand(1)); 125602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else { 125702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Insert a logical shift. 1258a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer NS = Builder->CreateLShr(AndCST, Shift->getOperand(1)); 125902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 12600cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 126102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Compute X & (C << Y). 12620cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach Value *NewAnd = 126302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Builder->CreateAnd(Shift->getOperand(0), NS, LHSI->getName()); 12640cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 126502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ICI.setOperand(0, NewAnd); 126602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return &ICI; 126702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 12686da2e22dffe9dd0255e10a8934f2879eb7e87868Paul Redmond 12696da2e22dffe9dd0255e10a8934f2879eb7e87868Paul Redmond // Replace ((X & AndCST) > RHSV) with ((X & AndCST) != 0), if any 12706da2e22dffe9dd0255e10a8934f2879eb7e87868Paul Redmond // bit set in (X & AndCST) will produce a result greater than RHSV. 12716da2e22dffe9dd0255e10a8934f2879eb7e87868Paul Redmond if (ICI.getPredicate() == ICmpInst::ICMP_UGT) { 12726da2e22dffe9dd0255e10a8934f2879eb7e87868Paul Redmond unsigned NTZ = AndCST->getValue().countTrailingZeros(); 12736da2e22dffe9dd0255e10a8934f2879eb7e87868Paul Redmond if ((NTZ < AndCST->getBitWidth()) && 12746da2e22dffe9dd0255e10a8934f2879eb7e87868Paul Redmond APInt::getOneBitSet(AndCST->getBitWidth(), NTZ).ugt(RHSV)) 12756da2e22dffe9dd0255e10a8934f2879eb7e87868Paul Redmond return new ICmpInst(ICmpInst::ICMP_NE, LHSI, 12766da2e22dffe9dd0255e10a8934f2879eb7e87868Paul Redmond Constant::getNullValue(RHS->getType())); 12776da2e22dffe9dd0255e10a8934f2879eb7e87868Paul Redmond } 127802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 12790cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 128002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Try to optimize things like "A[i]&42 == 0" to index computations. 128102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (LoadInst *LI = dyn_cast<LoadInst>(LHSI->getOperand(0))) { 128202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (GetElementPtrInst *GEP = 128302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner dyn_cast<GetElementPtrInst>(LI->getOperand(0))) 128402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (GlobalVariable *GV = dyn_cast<GlobalVariable>(GEP->getOperand(0))) 128502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (GV->isConstant() && GV->hasDefinitiveInitializer() && 128602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner !LI->isVolatile() && isa<ConstantInt>(LHSI->getOperand(1))) { 128702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt *C = cast<ConstantInt>(LHSI->getOperand(1)); 128802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Instruction *Res = FoldCmpLoadFromIndexedGlobal(GEP, GV,ICI, C)) 128902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return Res; 129002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 129102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 129236b6f7409d9f607317de9815ffc10656b608eab7David Majnemer 129336b6f7409d9f607317de9815ffc10656b608eab7David Majnemer // X & -C == -C -> X > u ~C 129436b6f7409d9f607317de9815ffc10656b608eab7David Majnemer // X & -C != -C -> X <= u ~C 129536b6f7409d9f607317de9815ffc10656b608eab7David Majnemer // iff C is a power of 2 129636b6f7409d9f607317de9815ffc10656b608eab7David Majnemer if (ICI.isEquality() && RHS == LHSI->getOperand(1) && (-RHSV).isPowerOf2()) 129736b6f7409d9f607317de9815ffc10656b608eab7David Majnemer return new ICmpInst( 129836b6f7409d9f607317de9815ffc10656b608eab7David Majnemer ICI.getPredicate() == ICmpInst::ICMP_EQ ? ICmpInst::ICMP_UGT 129936b6f7409d9f607317de9815ffc10656b608eab7David Majnemer : ICmpInst::ICMP_ULE, 130036b6f7409d9f607317de9815ffc10656b608eab7David Majnemer LHSI->getOperand(0), SubOne(RHS)); 130102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 130202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 130302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::Or: { 130402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!ICI.isEquality() || !RHS->isNullValue() || !LHSI->hasOneUse()) 130502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 130602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *P, *Q; 130702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (match(LHSI, m_Or(m_PtrToInt(m_Value(P)), m_PtrToInt(m_Value(Q))))) { 130802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Simplify icmp eq (or (ptrtoint P), (ptrtoint Q)), 0 130902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // -> and (icmp eq P, null), (icmp eq Q, null). 131002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *ICIP = Builder->CreateICmp(ICI.getPredicate(), P, 131102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant::getNullValue(P->getType())); 131202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *ICIQ = Builder->CreateICmp(ICI.getPredicate(), Q, 131302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant::getNullValue(Q->getType())); 131402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Instruction *Op; 131502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ICI.getPredicate() == ICmpInst::ICMP_EQ) 131602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Op = BinaryOperator::CreateAnd(ICIP, ICIQ); 131702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner else 131802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Op = BinaryOperator::CreateOr(ICIP, ICIQ); 131902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return Op; 132002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 132102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 132202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 13230cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 132435763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison case Instruction::Mul: { // (icmp pred (mul X, Val), CI) 132535763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison ConstantInt *Val = dyn_cast<ConstantInt>(LHSI->getOperand(1)); 132635763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison if (!Val) break; 132735763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison 13281bb93a912199bda15214d1ee7f3c731b8e9b648dArnaud A. de Grandmaison // If this is a signed comparison to 0 and the mul is sign preserving, 13291bb93a912199bda15214d1ee7f3c731b8e9b648dArnaud A. de Grandmaison // use the mul LHS operand instead. 13301bb93a912199bda15214d1ee7f3c731b8e9b648dArnaud A. de Grandmaison ICmpInst::Predicate pred = ICI.getPredicate(); 13311bb93a912199bda15214d1ee7f3c731b8e9b648dArnaud A. de Grandmaison if (isSignTest(pred, RHS) && !Val->isZero() && 13321bb93a912199bda15214d1ee7f3c731b8e9b648dArnaud A. de Grandmaison cast<BinaryOperator>(LHSI)->hasNoSignedWrap()) 13331bb93a912199bda15214d1ee7f3c731b8e9b648dArnaud A. de Grandmaison return new ICmpInst(Val->isNegative() ? 13341bb93a912199bda15214d1ee7f3c731b8e9b648dArnaud A. de Grandmaison ICmpInst::getSwappedPredicate(pred) : pred, 13351bb93a912199bda15214d1ee7f3c731b8e9b648dArnaud A. de Grandmaison LHSI->getOperand(0), 13361bb93a912199bda15214d1ee7f3c731b8e9b648dArnaud A. de Grandmaison Constant::getNullValue(RHS->getType())); 133735763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison 133835763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison break; 133935763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison } 134035763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison 134102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::Shl: { // (icmp pred (shl X, ShAmt), CI) 1342b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer uint32_t TypeBits = RHSV.getBitWidth(); 134302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt *ShAmt = dyn_cast<ConstantInt>(LHSI->getOperand(1)); 1344b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer if (!ShAmt) { 1345b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer Value *X; 1346b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer // (1 << X) pred P2 -> X pred Log2(P2) 1347b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer if (match(LHSI, m_Shl(m_One(), m_Value(X)))) { 1348b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer bool RHSVIsPowerOf2 = RHSV.isPowerOf2(); 1349b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer ICmpInst::Predicate Pred = ICI.getPredicate(); 1350b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer if (ICI.isUnsigned()) { 1351b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer if (!RHSVIsPowerOf2) { 1352b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer // (1 << X) < 30 -> X <= 4 1353b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer // (1 << X) <= 30 -> X <= 4 1354b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer // (1 << X) >= 30 -> X > 4 1355b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer // (1 << X) > 30 -> X > 4 1356b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer if (Pred == ICmpInst::ICMP_ULT) 1357b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer Pred = ICmpInst::ICMP_ULE; 1358b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer else if (Pred == ICmpInst::ICMP_UGE) 1359b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer Pred = ICmpInst::ICMP_UGT; 1360b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer } 1361b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer unsigned RHSLog2 = RHSV.logBase2(); 1362b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer 1363b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer // (1 << X) >= 2147483648 -> X >= 31 -> X == 31 1364b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer // (1 << X) > 2147483648 -> X > 31 -> false 1365b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer // (1 << X) <= 2147483648 -> X <= 31 -> true 1366b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer // (1 << X) < 2147483648 -> X < 31 -> X != 31 1367b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer if (RHSLog2 == TypeBits-1) { 1368b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer if (Pred == ICmpInst::ICMP_UGE) 1369b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer Pred = ICmpInst::ICMP_EQ; 1370b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer else if (Pred == ICmpInst::ICMP_UGT) 1371b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer return ReplaceInstUsesWith(ICI, Builder->getFalse()); 1372b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer else if (Pred == ICmpInst::ICMP_ULE) 1373b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer return ReplaceInstUsesWith(ICI, Builder->getTrue()); 1374b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer else if (Pred == ICmpInst::ICMP_ULT) 1375b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer Pred = ICmpInst::ICMP_NE; 1376b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer } 13770cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 1378b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer return new ICmpInst(Pred, X, 1379b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer ConstantInt::get(RHS->getType(), RHSLog2)); 1380b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer } else if (ICI.isSigned()) { 1381b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer if (RHSV.isAllOnesValue()) { 1382b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer // (1 << X) <= -1 -> X == 31 1383b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer if (Pred == ICmpInst::ICMP_SLE) 1384b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer return new ICmpInst(ICmpInst::ICMP_EQ, X, 1385b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer ConstantInt::get(RHS->getType(), TypeBits-1)); 1386b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer 1387b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer // (1 << X) > -1 -> X != 31 1388b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer if (Pred == ICmpInst::ICMP_SGT) 1389b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer return new ICmpInst(ICmpInst::ICMP_NE, X, 1390b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer ConstantInt::get(RHS->getType(), TypeBits-1)); 1391b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer } else if (!RHSV) { 1392b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer // (1 << X) < 0 -> X == 31 1393b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer // (1 << X) <= 0 -> X == 31 1394b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer if (Pred == ICmpInst::ICMP_SLT || Pred == ICmpInst::ICMP_SLE) 1395b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer return new ICmpInst(ICmpInst::ICMP_EQ, X, 1396b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer ConstantInt::get(RHS->getType(), TypeBits-1)); 1397b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer 1398b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer // (1 << X) >= 0 -> X != 31 1399b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer // (1 << X) > 0 -> X != 31 1400b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer if (Pred == ICmpInst::ICMP_SGT || Pred == ICmpInst::ICMP_SGE) 1401b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer return new ICmpInst(ICmpInst::ICMP_NE, X, 1402b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer ConstantInt::get(RHS->getType(), TypeBits-1)); 1403b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer } 1404b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer } else if (ICI.isEquality()) { 1405b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer if (RHSVIsPowerOf2) 1406b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer return new ICmpInst( 1407b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer Pred, X, ConstantInt::get(RHS->getType(), RHSV.logBase2())); 1408b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer 1409b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer return ReplaceInstUsesWith( 1410b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer ICI, Pred == ICmpInst::ICMP_EQ ? Builder->getFalse() 1411b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer : Builder->getTrue()); 1412b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer } 1413b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer } 1414b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer break; 1415b41f4bbfbd233fae70962a6b4049de2c08da2657David Majnemer } 14160cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 141702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Check that the shift amount is in range. If not, don't perform 141802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // undefined shifts. When the shift is visited it will be 141902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // simplified. 142002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ShAmt->uge(TypeBits)) 142102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 14220cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 142302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ICI.isEquality()) { 142402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If we are comparing against bits always shifted out, the 142502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // comparison cannot succeed. 142602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant *Comp = 142702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantExpr::getShl(ConstantExpr::getLShr(RHS, ShAmt), 142802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ShAmt); 142902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Comp != RHS) {// Comparing against a bit that we know is zero. 143002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner bool IsICMP_NE = ICI.getPredicate() == ICmpInst::ICMP_NE; 14313facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak Constant *Cst = Builder->getInt1(IsICMP_NE); 143202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return ReplaceInstUsesWith(ICI, Cst); 143302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 14340cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 1435b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner // If the shift is NUW, then it is just shifting out zeros, no need for an 1436b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner // AND. 1437b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner if (cast<BinaryOperator>(LHSI)->hasNoUnsignedWrap()) 1438b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner return new ICmpInst(ICI.getPredicate(), LHSI->getOperand(0), 1439b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner ConstantExpr::getLShr(RHS, ShAmt)); 14400cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 144135763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison // If the shift is NSW and we compare to 0, then it is just shifting out 144235763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison // sign bits, no need for an AND either. 144335763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison if (cast<BinaryOperator>(LHSI)->hasNoSignedWrap() && RHSV == 0) 144435763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison return new ICmpInst(ICI.getPredicate(), LHSI->getOperand(0), 144535763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison ConstantExpr::getLShr(RHS, ShAmt)); 144635763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison 144702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (LHSI->hasOneUse()) { 144802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Otherwise strength reduce the shift into an and. 144902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner uint32_t ShAmtVal = (uint32_t)ShAmt->getLimitedValue(TypeBits); 14503facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak Constant *Mask = Builder->getInt(APInt::getLowBitsSet(TypeBits, 14513facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak TypeBits - ShAmtVal)); 14520cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 145302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *And = 145402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Builder->CreateAnd(LHSI->getOperand(0),Mask, LHSI->getName()+".mask"); 145502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICI.getPredicate(), And, 1456b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner ConstantExpr::getLShr(RHS, ShAmt)); 145702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 145802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 14590cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 146035763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison // If this is a signed comparison to 0 and the shift is sign preserving, 146135763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison // use the shift LHS operand instead. 146235763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison ICmpInst::Predicate pred = ICI.getPredicate(); 146335763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison if (isSignTest(pred, RHS) && 146435763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison cast<BinaryOperator>(LHSI)->hasNoSignedWrap()) 146535763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison return new ICmpInst(pred, 146635763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison LHSI->getOperand(0), 146735763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison Constant::getNullValue(RHS->getType())); 146835763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison 146902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Otherwise, if this is a comparison of the sign bit, simplify to and/test. 147002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner bool TrueIfSigned = false; 147102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (LHSI->hasOneUse() && 147202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner isSignBitCheck(ICI.getPredicate(), RHS, TrueIfSigned)) { 147302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (X << 31) <s 0 --> (X&1) != 0 1474bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner Constant *Mask = ConstantInt::get(LHSI->getOperand(0)->getType(), 14750cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach APInt::getOneBitSet(TypeBits, 1476bb75d337c4d544692cd250acba8e3507aacb7b75Chris Lattner TypeBits-ShAmt->getZExtValue()-1)); 147702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *And = 147802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Builder->CreateAnd(LHSI->getOperand(0), Mask, LHSI->getName()+".mask"); 147902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(TrueIfSigned ? ICmpInst::ICMP_NE : ICmpInst::ICMP_EQ, 148002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner And, Constant::getNullValue(And->getType())); 148102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 14827c5c9b39c91d5f53284011c0ddbf458d553740daArnaud A. de Grandmaison 14837c5c9b39c91d5f53284011c0ddbf458d553740daArnaud A. de Grandmaison // Transform (icmp pred iM (shl iM %v, N), CI) 1484bdd2d981391bd9329aba669cffcdde0c39373cb1Arnaud A. de Grandmaison // -> (icmp pred i(M-N) (trunc %v iM to i(M-N)), (trunc (CI>>N)) 1485bdd2d981391bd9329aba669cffcdde0c39373cb1Arnaud A. de Grandmaison // Transform the shl to a trunc if (trunc (CI>>N)) has no loss and M-N. 14867c5c9b39c91d5f53284011c0ddbf458d553740daArnaud A. de Grandmaison // This enables to get rid of the shift in favor of a trunc which can be 14877c5c9b39c91d5f53284011c0ddbf458d553740daArnaud A. de Grandmaison // free on the target. It has the additional benefit of comparing to a 14887c5c9b39c91d5f53284011c0ddbf458d553740daArnaud A. de Grandmaison // smaller constant, which will be target friendly. 14897c5c9b39c91d5f53284011c0ddbf458d553740daArnaud A. de Grandmaison unsigned Amt = ShAmt->getLimitedValue(TypeBits-1); 1490bdd2d981391bd9329aba669cffcdde0c39373cb1Arnaud A. de Grandmaison if (LHSI->hasOneUse() && 1491bdd2d981391bd9329aba669cffcdde0c39373cb1Arnaud A. de Grandmaison Amt != 0 && RHSV.countTrailingZeros() >= Amt) { 14927c5c9b39c91d5f53284011c0ddbf458d553740daArnaud A. de Grandmaison Type *NTy = IntegerType::get(ICI.getContext(), TypeBits - Amt); 14937c5c9b39c91d5f53284011c0ddbf458d553740daArnaud A. de Grandmaison Constant *NCI = ConstantExpr::getTrunc( 14947c5c9b39c91d5f53284011c0ddbf458d553740daArnaud A. de Grandmaison ConstantExpr::getAShr(RHS, 14957c5c9b39c91d5f53284011c0ddbf458d553740daArnaud A. de Grandmaison ConstantInt::get(RHS->getType(), Amt)), 14967c5c9b39c91d5f53284011c0ddbf458d553740daArnaud A. de Grandmaison NTy); 14977c5c9b39c91d5f53284011c0ddbf458d553740daArnaud A. de Grandmaison return new ICmpInst(ICI.getPredicate(), 14987c5c9b39c91d5f53284011c0ddbf458d553740daArnaud A. de Grandmaison Builder->CreateTrunc(LHSI->getOperand(0), NTy), 1499ad079b274d6ecd3e36fb98099864baeeeb96ac82Arnaud A. de Grandmaison NCI); 15007c5c9b39c91d5f53284011c0ddbf458d553740daArnaud A. de Grandmaison } 15017c5c9b39c91d5f53284011c0ddbf458d553740daArnaud A. de Grandmaison 150202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 150302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 15040cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 150502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::LShr: // (icmp pred (shr X, ShAmt), CI) 1506b042f8e9699dd15d7ac48bb9b9475122b1673687Nick Lewycky case Instruction::AShr: { 1507b042f8e9699dd15d7ac48bb9b9475122b1673687Nick Lewycky // Handle equality comparisons of shift-by-constant. 1508b042f8e9699dd15d7ac48bb9b9475122b1673687Nick Lewycky BinaryOperator *BO = cast<BinaryOperator>(LHSI); 1509b042f8e9699dd15d7ac48bb9b9475122b1673687Nick Lewycky if (ConstantInt *ShAmt = dyn_cast<ConstantInt>(LHSI->getOperand(1))) { 1510b042f8e9699dd15d7ac48bb9b9475122b1673687Nick Lewycky if (Instruction *Res = FoldICmpShrCst(ICI, BO, ShAmt)) 151174542aa5001fb6ff3d7d0958b5c391cde63df1caChris Lattner return Res; 1512b042f8e9699dd15d7ac48bb9b9475122b1673687Nick Lewycky } 1513b042f8e9699dd15d7ac48bb9b9475122b1673687Nick Lewycky 1514b042f8e9699dd15d7ac48bb9b9475122b1673687Nick Lewycky // Handle exact shr's. 1515b042f8e9699dd15d7ac48bb9b9475122b1673687Nick Lewycky if (ICI.isEquality() && BO->isExact() && BO->hasOneUse()) { 1516b042f8e9699dd15d7ac48bb9b9475122b1673687Nick Lewycky if (RHSV.isMinValue()) 1517b042f8e9699dd15d7ac48bb9b9475122b1673687Nick Lewycky return new ICmpInst(ICI.getPredicate(), BO->getOperand(0), RHS); 1518b042f8e9699dd15d7ac48bb9b9475122b1673687Nick Lewycky } 151902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 1520b042f8e9699dd15d7ac48bb9b9475122b1673687Nick Lewycky } 15210cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 152202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::SDiv: 152302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::UDiv: 152402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Fold: icmp pred ([us]div X, C1), C2 -> range test 15250cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // Fold this div into the comparison, producing a range check. 15260cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // Determine, based on the divide type, what the range is being 15270cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // checked. If there is an overflow on the low or high side, remember 152802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // it, otherwise compute the range [low, hi) bounding the new value. 152902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // See: InsertRangeTest above for the kinds of replacements possible. 153002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ConstantInt *DivRHS = dyn_cast<ConstantInt>(LHSI->getOperand(1))) 153102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Instruction *R = FoldICmpDivCst(ICI, cast<BinaryOperator>(LHSI), 153202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner DivRHS)) 153302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return R; 153402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 153502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 1536377a5c1a87b879b7a05a635ed7bbf125b0b61e28David Majnemer case Instruction::Sub: { 1537377a5c1a87b879b7a05a635ed7bbf125b0b61e28David Majnemer ConstantInt *LHSC = dyn_cast<ConstantInt>(LHSI->getOperand(0)); 1538377a5c1a87b879b7a05a635ed7bbf125b0b61e28David Majnemer if (!LHSC) break; 1539377a5c1a87b879b7a05a635ed7bbf125b0b61e28David Majnemer const APInt &LHSV = LHSC->getValue(); 1540377a5c1a87b879b7a05a635ed7bbf125b0b61e28David Majnemer 1541377a5c1a87b879b7a05a635ed7bbf125b0b61e28David Majnemer // C1-X <u C2 -> (X|(C2-1)) == C1 1542377a5c1a87b879b7a05a635ed7bbf125b0b61e28David Majnemer // iff C1 & (C2-1) == C2-1 1543377a5c1a87b879b7a05a635ed7bbf125b0b61e28David Majnemer // C2 is a power of 2 1544377a5c1a87b879b7a05a635ed7bbf125b0b61e28David Majnemer if (ICI.getPredicate() == ICmpInst::ICMP_ULT && LHSI->hasOneUse() && 1545377a5c1a87b879b7a05a635ed7bbf125b0b61e28David Majnemer RHSV.isPowerOf2() && (LHSV & (RHSV - 1)) == (RHSV - 1)) 1546377a5c1a87b879b7a05a635ed7bbf125b0b61e28David Majnemer return new ICmpInst(ICmpInst::ICMP_EQ, 1547377a5c1a87b879b7a05a635ed7bbf125b0b61e28David Majnemer Builder->CreateOr(LHSI->getOperand(1), RHSV - 1), 1548377a5c1a87b879b7a05a635ed7bbf125b0b61e28David Majnemer LHSC); 1549377a5c1a87b879b7a05a635ed7bbf125b0b61e28David Majnemer 1550fcb7b97892dad5bc6ae55f513f8a111563078996David Majnemer // C1-X >u C2 -> (X|C2) != C1 1551377a5c1a87b879b7a05a635ed7bbf125b0b61e28David Majnemer // iff C1 & C2 == C2 1552377a5c1a87b879b7a05a635ed7bbf125b0b61e28David Majnemer // C2+1 is a power of 2 1553377a5c1a87b879b7a05a635ed7bbf125b0b61e28David Majnemer if (ICI.getPredicate() == ICmpInst::ICMP_UGT && LHSI->hasOneUse() && 1554377a5c1a87b879b7a05a635ed7bbf125b0b61e28David Majnemer (RHSV + 1).isPowerOf2() && (LHSV & RHSV) == RHSV) 1555377a5c1a87b879b7a05a635ed7bbf125b0b61e28David Majnemer return new ICmpInst(ICmpInst::ICMP_NE, 1556377a5c1a87b879b7a05a635ed7bbf125b0b61e28David Majnemer Builder->CreateOr(LHSI->getOperand(1), RHSV), LHSC); 1557377a5c1a87b879b7a05a635ed7bbf125b0b61e28David Majnemer break; 1558377a5c1a87b879b7a05a635ed7bbf125b0b61e28David Majnemer } 1559377a5c1a87b879b7a05a635ed7bbf125b0b61e28David Majnemer 156002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::Add: 156102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Fold: icmp pred (add X, C1), C2 156202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!ICI.isEquality()) { 156302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt *LHSC = dyn_cast<ConstantInt>(LHSI->getOperand(1)); 156402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!LHSC) break; 156502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner const APInt &LHSV = LHSC->getValue(); 156602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 156702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantRange CR = ICI.makeConstantRange(ICI.getPredicate(), RHSV) 156802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner .subtract(LHSV); 156902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 157002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ICI.isSigned()) { 157102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (CR.getLower().isSignBit()) { 157202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_SLT, LHSI->getOperand(0), 15733facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak Builder->getInt(CR.getUpper())); 157402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else if (CR.getUpper().isSignBit()) { 157502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_SGE, LHSI->getOperand(0), 15763facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak Builder->getInt(CR.getLower())); 157702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 157802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else { 157902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (CR.getLower().isMinValue()) { 158002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_ULT, LHSI->getOperand(0), 15813facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak Builder->getInt(CR.getUpper())); 158202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else if (CR.getUpper().isMinValue()) { 158302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_UGE, LHSI->getOperand(0), 15843facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak Builder->getInt(CR.getLower())); 158502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 158602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 158753fc39992df9c485ea45f28998c1ef99caed63f9David Majnemer 158811c29bafd584da2e39ee5d885ca2d53035bc1372David Majnemer // X-C1 <u C2 -> (X & -C2) == C1 158911c29bafd584da2e39ee5d885ca2d53035bc1372David Majnemer // iff C1 & (C2-1) == 0 159011c29bafd584da2e39ee5d885ca2d53035bc1372David Majnemer // C2 is a power of 2 159153fc39992df9c485ea45f28998c1ef99caed63f9David Majnemer if (ICI.getPredicate() == ICmpInst::ICMP_ULT && LHSI->hasOneUse() && 159211c29bafd584da2e39ee5d885ca2d53035bc1372David Majnemer RHSV.isPowerOf2() && (LHSV & (RHSV - 1)) == 0) 159353fc39992df9c485ea45f28998c1ef99caed63f9David Majnemer return new ICmpInst(ICmpInst::ICMP_EQ, 159453fc39992df9c485ea45f28998c1ef99caed63f9David Majnemer Builder->CreateAnd(LHSI->getOperand(0), -RHSV), 159553fc39992df9c485ea45f28998c1ef99caed63f9David Majnemer ConstantExpr::getNeg(LHSC)); 159611c29bafd584da2e39ee5d885ca2d53035bc1372David Majnemer 1597fcb7b97892dad5bc6ae55f513f8a111563078996David Majnemer // X-C1 >u C2 -> (X & ~C2) != C1 159811c29bafd584da2e39ee5d885ca2d53035bc1372David Majnemer // iff C1 & C2 == 0 159911c29bafd584da2e39ee5d885ca2d53035bc1372David Majnemer // C2+1 is a power of 2 160011c29bafd584da2e39ee5d885ca2d53035bc1372David Majnemer if (ICI.getPredicate() == ICmpInst::ICMP_UGT && LHSI->hasOneUse() && 160111c29bafd584da2e39ee5d885ca2d53035bc1372David Majnemer (RHSV + 1).isPowerOf2() && (LHSV & RHSV) == 0) 160211c29bafd584da2e39ee5d885ca2d53035bc1372David Majnemer return new ICmpInst(ICmpInst::ICMP_NE, 160311c29bafd584da2e39ee5d885ca2d53035bc1372David Majnemer Builder->CreateAnd(LHSI->getOperand(0), ~RHSV), 160411c29bafd584da2e39ee5d885ca2d53035bc1372David Majnemer ConstantExpr::getNeg(LHSC)); 160502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 160602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 160702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 16080cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 160902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Simplify icmp_eq and icmp_ne instructions with integer constant RHS. 161002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ICI.isEquality()) { 161102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner bool isICMP_NE = ICI.getPredicate() == ICmpInst::ICMP_NE; 16120cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 16130cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // If the first operand is (add|sub|and|or|xor|rem) with a constant, and 161402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // the second operand is a constant, simplify a bit. 161502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (BinaryOperator *BO = dyn_cast<BinaryOperator>(LHSI)) { 161602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner switch (BO->getOpcode()) { 161702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::SRem: 161802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If we have a signed (X % (2^c)) == 0, turn it into an unsigned one. 161902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (RHSV == 0 && isa<ConstantInt>(BO->getOperand(1)) &&BO->hasOneUse()){ 162002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner const APInt &V = cast<ConstantInt>(BO->getOperand(1))->getValue(); 1621e05678132345eb8a632362dbd320ee7d36226e67Dan Gohman if (V.sgt(1) && V.isPowerOf2()) { 162202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *NewRem = 162302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Builder->CreateURem(BO->getOperand(0), BO->getOperand(1), 162402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner BO->getName()); 162502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICI.getPredicate(), NewRem, 162602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant::getNullValue(BO->getType())); 162702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 162802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 162902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 163002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::Add: 163102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Replace ((add A, B) != C) with (A != C-B) if B & C are constants. 163202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ConstantInt *BOp1C = dyn_cast<ConstantInt>(BO->getOperand(1))) { 163302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (BO->hasOneUse()) 163402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICI.getPredicate(), BO->getOperand(0), 163502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantExpr::getSub(RHS, BOp1C)); 163602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else if (RHSV == 0) { 163702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Replace ((add A, B) != 0) with (A != -B) if A or B is 163802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // efficiently invertible, or if the add has just this one use. 163902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *BOp0 = BO->getOperand(0), *BOp1 = BO->getOperand(1); 16400cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 164102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Value *NegVal = dyn_castNegVal(BOp1)) 164202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICI.getPredicate(), BOp0, NegVal); 16435036ce4a64caaeaff4b1f8f1c91836cc2e49a455Chris Lattner if (Value *NegVal = dyn_castNegVal(BOp0)) 164402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICI.getPredicate(), NegVal, BOp1); 16455036ce4a64caaeaff4b1f8f1c91836cc2e49a455Chris Lattner if (BO->hasOneUse()) { 164602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *Neg = Builder->CreateNeg(BOp1); 164702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Neg->takeName(BO); 164802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICI.getPredicate(), BOp0, Neg); 164902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 165002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 165102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 165202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::Xor: 165302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // For the xor case, we can xor two constants together, eliminating 165402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // the explicit xor. 1655e7fdcad2f2d82c81684cb9962327330786c35107Benjamin Kramer if (Constant *BOC = dyn_cast<Constant>(BO->getOperand(1))) { 1656e7fdcad2f2d82c81684cb9962327330786c35107Benjamin Kramer return new ICmpInst(ICI.getPredicate(), BO->getOperand(0), 165702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantExpr::getXor(RHS, BOC)); 1658e7fdcad2f2d82c81684cb9962327330786c35107Benjamin Kramer } else if (RHSV == 0) { 1659e7fdcad2f2d82c81684cb9962327330786c35107Benjamin Kramer // Replace ((xor A, B) != 0) with (A != B) 1660e7fdcad2f2d82c81684cb9962327330786c35107Benjamin Kramer return new ICmpInst(ICI.getPredicate(), BO->getOperand(0), 1661e7fdcad2f2d82c81684cb9962327330786c35107Benjamin Kramer BO->getOperand(1)); 1662e7fdcad2f2d82c81684cb9962327330786c35107Benjamin Kramer } 1663e7fdcad2f2d82c81684cb9962327330786c35107Benjamin Kramer break; 166402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::Sub: 1665e7fdcad2f2d82c81684cb9962327330786c35107Benjamin Kramer // Replace ((sub A, B) != C) with (B != A-C) if A & C are constants. 1666e7fdcad2f2d82c81684cb9962327330786c35107Benjamin Kramer if (ConstantInt *BOp0C = dyn_cast<ConstantInt>(BO->getOperand(0))) { 1667e7fdcad2f2d82c81684cb9962327330786c35107Benjamin Kramer if (BO->hasOneUse()) 1668e7fdcad2f2d82c81684cb9962327330786c35107Benjamin Kramer return new ICmpInst(ICI.getPredicate(), BO->getOperand(1), 1669e7fdcad2f2d82c81684cb9962327330786c35107Benjamin Kramer ConstantExpr::getSub(BOp0C, RHS)); 1670e7fdcad2f2d82c81684cb9962327330786c35107Benjamin Kramer } else if (RHSV == 0) { 1671e7fdcad2f2d82c81684cb9962327330786c35107Benjamin Kramer // Replace ((sub A, B) != 0) with (A != B) 167202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICI.getPredicate(), BO->getOperand(0), 167302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner BO->getOperand(1)); 1674e7fdcad2f2d82c81684cb9962327330786c35107Benjamin Kramer } 167502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 167602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::Or: 167702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If bits are being or'd in that are not present in the constant we 167802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // are comparing against, then the comparison could never succeed! 1679618898e933c6350f1f7976370f3822c086d70f0cEli Friedman if (ConstantInt *BOC = dyn_cast<ConstantInt>(BO->getOperand(1))) { 168002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant *NotCI = ConstantExpr::getNot(RHS); 168102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!ConstantExpr::getAnd(BOC, NotCI)->isNullValue()) 16823facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak return ReplaceInstUsesWith(ICI, Builder->getInt1(isICMP_NE)); 168302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 168402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 16850cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 168602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::And: 168702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ConstantInt *BOC = dyn_cast<ConstantInt>(BO->getOperand(1))) { 168802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If bits are being compared against that are and'd out, then the 168902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // comparison can never succeed! 169002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if ((RHSV & ~BOC->getValue()) != 0) 16913facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak return ReplaceInstUsesWith(ICI, Builder->getInt1(isICMP_NE)); 16920cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 169302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If we have ((X & C) == C), turn it into ((X & C) != 0). 169402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (RHS == BOC && RHSV.isPowerOf2()) 169502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(isICMP_NE ? ICmpInst::ICMP_EQ : 169602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ICmpInst::ICMP_NE, LHSI, 169702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant::getNullValue(RHS->getType())); 1698fc87cdc1f4df357167a7cef91af92b5012934124Benjamin Kramer 1699fc87cdc1f4df357167a7cef91af92b5012934124Benjamin Kramer // Don't perform the following transforms if the AND has multiple uses 1700fc87cdc1f4df357167a7cef91af92b5012934124Benjamin Kramer if (!BO->hasOneUse()) 1701fc87cdc1f4df357167a7cef91af92b5012934124Benjamin Kramer break; 1702fc87cdc1f4df357167a7cef91af92b5012934124Benjamin Kramer 170302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Replace (and X, (1 << size(X)-1) != 0) with x s< 0 170402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (BOC->getValue().isSignBit()) { 170502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *X = BO->getOperand(0); 170602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant *Zero = Constant::getNullValue(X->getType()); 17070cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach ICmpInst::Predicate pred = isICMP_NE ? 170802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ICmpInst::ICMP_SLT : ICmpInst::ICMP_SGE; 170902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(pred, X, Zero); 171002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 17110cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 171202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // ((X & ~7) == 0) --> X < 8 171302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (RHSV == 0 && isHighOnes(BOC)) { 171402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *X = BO->getOperand(0); 171502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant *NegX = ConstantExpr::getNeg(BOC); 17160cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach ICmpInst::Predicate pred = isICMP_NE ? 171702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ICmpInst::ICMP_UGE : ICmpInst::ICMP_ULT; 171802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(pred, X, NegX); 171902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 172002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 172135763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison break; 172235763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison case Instruction::Mul: 17231bb93a912199bda15214d1ee7f3c731b8e9b648dArnaud A. de Grandmaison if (RHSV == 0 && BO->hasNoSignedWrap()) { 172435763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison if (ConstantInt *BOC = dyn_cast<ConstantInt>(BO->getOperand(1))) { 172535763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison // The trivial case (mul X, 0) is handled by InstSimplify 172635763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison // General case : (mul X, C) != 0 iff X != 0 172735763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison // (mul X, C) == 0 iff X == 0 172835763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison if (!BOC->isZero()) 172935763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison return new ICmpInst(ICI.getPredicate(), BO->getOperand(0), 173035763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison Constant::getNullValue(RHS->getType())); 173135763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison } 173235763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison } 173335763b1ee700cd29f057494a35095f06d983fe6eArnaud A. de Grandmaison break; 173402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner default: break; 173502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 173602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(LHSI)) { 173702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Handle icmp {eq|ne} <intrinsic>, intcst. 1738033574074d3c980057a0cb989d272ec72a8f9523Chris Lattner switch (II->getIntrinsicID()) { 1739033574074d3c980057a0cb989d272ec72a8f9523Chris Lattner case Intrinsic::bswap: 174002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Worklist.Add(II); 1741caf70b31b0d8cbae0f05df404dd5935c27369690Gabor Greif ICI.setOperand(0, II->getArgOperand(0)); 17423facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak ICI.setOperand(1, Builder->getInt(RHSV.byteSwap())); 174302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return &ICI; 1744033574074d3c980057a0cb989d272ec72a8f9523Chris Lattner case Intrinsic::ctlz: 1745033574074d3c980057a0cb989d272ec72a8f9523Chris Lattner case Intrinsic::cttz: 1746033574074d3c980057a0cb989d272ec72a8f9523Chris Lattner // ctz(A) == bitwidth(a) -> A == 0 and likewise for != 1747033574074d3c980057a0cb989d272ec72a8f9523Chris Lattner if (RHSV == RHS->getType()->getBitWidth()) { 1748033574074d3c980057a0cb989d272ec72a8f9523Chris Lattner Worklist.Add(II); 1749caf70b31b0d8cbae0f05df404dd5935c27369690Gabor Greif ICI.setOperand(0, II->getArgOperand(0)); 1750033574074d3c980057a0cb989d272ec72a8f9523Chris Lattner ICI.setOperand(1, ConstantInt::get(RHS->getType(), 0)); 1751033574074d3c980057a0cb989d272ec72a8f9523Chris Lattner return &ICI; 1752033574074d3c980057a0cb989d272ec72a8f9523Chris Lattner } 1753033574074d3c980057a0cb989d272ec72a8f9523Chris Lattner break; 1754033574074d3c980057a0cb989d272ec72a8f9523Chris Lattner case Intrinsic::ctpop: 1755033574074d3c980057a0cb989d272ec72a8f9523Chris Lattner // popcount(A) == 0 -> A == 0 and likewise for != 1756033574074d3c980057a0cb989d272ec72a8f9523Chris Lattner if (RHS->isZero()) { 1757033574074d3c980057a0cb989d272ec72a8f9523Chris Lattner Worklist.Add(II); 1758caf70b31b0d8cbae0f05df404dd5935c27369690Gabor Greif ICI.setOperand(0, II->getArgOperand(0)); 1759033574074d3c980057a0cb989d272ec72a8f9523Chris Lattner ICI.setOperand(1, RHS); 1760033574074d3c980057a0cb989d272ec72a8f9523Chris Lattner return &ICI; 1761033574074d3c980057a0cb989d272ec72a8f9523Chris Lattner } 1762033574074d3c980057a0cb989d272ec72a8f9523Chris Lattner break; 1763033574074d3c980057a0cb989d272ec72a8f9523Chris Lattner default: 17643472766f9eb7d66f234c390ce1b3a8b76f0ee9ceDuncan Sands break; 176502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 176602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 176702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 176802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return 0; 176902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner} 177002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 177102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// visitICmpInstWithCastAndCast - Handle icmp (cast x to y), (cast/cst). 177202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// We only handle extending casts so far. 177302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// 177402446fc99abb06d3117d65c0b1f5fba4f906db2eChris LattnerInstruction *InstCombiner::visitICmpInstWithCastAndCast(ICmpInst &ICI) { 177502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner const CastInst *LHSCI = cast<CastInst>(ICI.getOperand(0)); 177602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *LHSCIOp = LHSCI->getOperand(0); 1777db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *SrcTy = LHSCIOp->getType(); 1778db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *DestTy = LHSCI->getType(); 177902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *RHSCIOp; 178002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 17810cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // Turn icmp (ptrtoint x), (ptrtoint/c) into a compare of the input if the 178202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // integer type is the same size as the pointer type. 178302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (TD && LHSCI->getOpcode() == Instruction::PtrToInt && 1784426c2bf5cdd2173e4a33aea8cb92cf684a724f4bChandler Carruth TD->getPointerSizeInBits() == 178502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner cast<IntegerType>(DestTy)->getBitWidth()) { 178602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *RHSOp = 0; 178702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Constant *RHSC = dyn_cast<Constant>(ICI.getOperand(1))) { 178802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner RHSOp = ConstantExpr::getIntToPtr(RHSC, SrcTy); 178902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else if (PtrToIntInst *RHSC = dyn_cast<PtrToIntInst>(ICI.getOperand(1))) { 179002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner RHSOp = RHSC->getOperand(0); 179102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If the pointer types don't match, insert a bitcast. 179202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (LHSCIOp->getType() != RHSOp->getType()) 179302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner RHSOp = Builder->CreateBitCast(RHSOp, LHSCIOp->getType()); 179402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 179502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 179602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (RHSOp) 179702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICI.getPredicate(), LHSCIOp, RHSOp); 179802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 17990cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 180002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // The code below only handles extension cast instructions, so far. 180102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Enforce this. 180202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (LHSCI->getOpcode() != Instruction::ZExt && 180302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner LHSCI->getOpcode() != Instruction::SExt) 180402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return 0; 180502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 180602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner bool isSignedExt = LHSCI->getOpcode() == Instruction::SExt; 180702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner bool isSignedCmp = ICI.isSigned(); 180802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 180902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (CastInst *CI = dyn_cast<CastInst>(ICI.getOperand(1))) { 181002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Not an extension from the same type? 181102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner RHSCIOp = CI->getOperand(0); 18120cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach if (RHSCIOp->getType() != LHSCIOp->getType()) 181302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return 0; 18140cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 181502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If the signedness of the two casts doesn't agree (i.e. one is a sext 181602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // and the other is a zext), then we can't handle this. 181702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (CI->getOpcode() != LHSCI->getOpcode()) 181802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return 0; 181902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 182002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Deal with equality cases early. 182102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ICI.isEquality()) 182202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICI.getPredicate(), LHSCIOp, RHSCIOp); 182302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 182402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // A signed comparison of sign extended values simplifies into a 182502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // signed comparison. 182602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (isSignedCmp && isSignedExt) 182702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICI.getPredicate(), LHSCIOp, RHSCIOp); 182802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 182902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // The other three cases all fold into an unsigned comparison. 183002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICI.getUnsignedPredicate(), LHSCIOp, RHSCIOp); 183102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 183202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 183302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If we aren't dealing with a constant on the RHS, exit early 183402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt *CI = dyn_cast<ConstantInt>(ICI.getOperand(1)); 183502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!CI) 183602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return 0; 183702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 183802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Compute the constant that would happen if we truncated to SrcTy then 183902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // reextended to DestTy. 184002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant *Res1 = ConstantExpr::getTrunc(CI, SrcTy); 184102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant *Res2 = ConstantExpr::getCast(LHSCI->getOpcode(), 184202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Res1, DestTy); 184302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 184402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If the re-extended constant didn't change... 184502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Res2 == CI) { 184602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Deal with equality cases early. 184702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ICI.isEquality()) 184802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICI.getPredicate(), LHSCIOp, Res1); 184902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 185002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // A signed comparison of sign extended values simplifies into a 185102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // signed comparison. 185202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (isSignedExt && isSignedCmp) 185302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICI.getPredicate(), LHSCIOp, Res1); 185402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 185502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // The other three cases all fold into an unsigned comparison. 185602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICI.getUnsignedPredicate(), LHSCIOp, Res1); 185702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 185802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 18590cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // The re-extended constant changed so the constant cannot be represented 186002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // in the shorter type. Consequently, we cannot emit a simple comparison. 18619d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // All the cases that fold to true or false will have already been handled 18629d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // by SimplifyICmpInst, so only deal with the tricky case. 186302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 18649d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (isSignedCmp || !isSignedExt) 18659d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands return 0; 186602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 186702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Evaluate the comparison for LT (we invert for GT below). LE and GE cases 186802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // should have been folded away previously and not enter in here. 18699d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands 18709d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // We're performing an unsigned comp with a sign extended value. 18719d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands // This is true if the input is >= 0. [aka >s -1] 18729d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Constant *NegOne = Constant::getAllOnesValue(SrcTy); 18739d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands Value *Result = Builder->CreateICmpSGT(LHSCIOp, NegOne, ICI.getName()); 187402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 187502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Finally, return the value computed. 18769d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands if (ICI.getPredicate() == ICmpInst::ICMP_ULT) 187702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return ReplaceInstUsesWith(ICI, Result); 187802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 18799d32f60a6f7dbd8e83187481cd2ae0a2f3e726ceDuncan Sands assert(ICI.getPredicate() == ICmpInst::ICMP_UGT && "ICmp should be folded!"); 188002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return BinaryOperator::CreateNot(Result); 188102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner} 188202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 1883f0f568b49e111da1258902b73a7b9266222e1842Chris Lattner/// ProcessUGT_ADDCST_ADD - The caller has matched a pattern of the form: 1884f0f568b49e111da1258902b73a7b9266222e1842Chris Lattner/// I = icmp ugt (add (add A, B), CI2), CI1 1885dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner/// If this is of the form: 1886dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner/// sum = a + b 1887dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner/// if (sum+128 >u 255) 1888dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner/// Then replace it with llvm.sadd.with.overflow.i8. 1889dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner/// 1890f0f568b49e111da1258902b73a7b9266222e1842Chris Lattnerstatic Instruction *ProcessUGT_ADDCST_ADD(ICmpInst &I, Value *A, Value *B, 1891f0f568b49e111da1258902b73a7b9266222e1842Chris Lattner ConstantInt *CI2, ConstantInt *CI1, 18920fe80bbbb6a017169d273c4824903b52a7ea2414Chris Lattner InstCombiner &IC) { 1893368397bb7de8318a4663fec846bda714ae78dd7aChris Lattner // The transformation we're trying to do here is to transform this into an 1894368397bb7de8318a4663fec846bda714ae78dd7aChris Lattner // llvm.sadd.with.overflow. To do this, we have to replace the original add 1895368397bb7de8318a4663fec846bda714ae78dd7aChris Lattner // with a narrower add, and discard the add-with-constant that is part of the 1896368397bb7de8318a4663fec846bda714ae78dd7aChris Lattner // range check (if we can't eliminate it, this isn't profitable). 18970cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 1898368397bb7de8318a4663fec846bda714ae78dd7aChris Lattner // In order to eliminate the add-with-constant, the compare can be its only 1899368397bb7de8318a4663fec846bda714ae78dd7aChris Lattner // use. 1900dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner Instruction *AddWithCst = cast<Instruction>(I.getOperand(0)); 1901368397bb7de8318a4663fec846bda714ae78dd7aChris Lattner if (!AddWithCst->hasOneUse()) return 0; 19020cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 1903dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner // If CI2 is 2^7, 2^15, 2^31, then it might be an sadd.with.overflow. 1904dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner if (!CI2->getValue().isPowerOf2()) return 0; 1905dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner unsigned NewWidth = CI2->getValue().countTrailingZeros(); 1906dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner if (NewWidth != 7 && NewWidth != 15 && NewWidth != 31) return 0; 19070cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 1908dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner // The width of the new add formed is 1 more than the bias. 1909dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner ++NewWidth; 19100cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 1911dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner // Check to see that CI1 is an all-ones value with NewWidth bits. 1912dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner if (CI1->getBitWidth() == NewWidth || 1913dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner CI1->getValue() != APInt::getLowBitsSet(CI1->getBitWidth(), NewWidth)) 1914dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner return 0; 19150cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 191654b92113e227db1d982172df18c4ad5058aae4e9Eli Friedman // This is only really a signed overflow check if the inputs have been 191754b92113e227db1d982172df18c4ad5058aae4e9Eli Friedman // sign-extended; check for that condition. For example, if CI2 is 2^31 and 191854b92113e227db1d982172df18c4ad5058aae4e9Eli Friedman // the operands of the add are 64 bits wide, we need at least 33 sign bits. 191954b92113e227db1d982172df18c4ad5058aae4e9Eli Friedman unsigned NeededSignBits = CI1->getBitWidth() - NewWidth + 1; 192054b92113e227db1d982172df18c4ad5058aae4e9Eli Friedman if (IC.ComputeNumSignBits(A) < NeededSignBits || 192154b92113e227db1d982172df18c4ad5058aae4e9Eli Friedman IC.ComputeNumSignBits(B) < NeededSignBits) 192254b92113e227db1d982172df18c4ad5058aae4e9Eli Friedman return 0; 192354b92113e227db1d982172df18c4ad5058aae4e9Eli Friedman 19240cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // In order to replace the original add with a narrower 1925dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner // llvm.sadd.with.overflow, the only uses allowed are the add-with-constant 1926dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner // and truncates that discard the high bits of the add. Verify that this is 1927dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner // the case. 1928dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner Instruction *OrigAdd = cast<Instruction>(AddWithCst->getOperand(0)); 1929dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner for (Value::use_iterator UI = OrigAdd->use_begin(), E = OrigAdd->use_end(); 1930dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner UI != E; ++UI) { 1931dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner if (*UI == AddWithCst) continue; 19320cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 1933dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner // Only accept truncates for now. We would really like a nice recursive 1934dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner // predicate like SimplifyDemandedBits, but which goes downwards the use-def 1935dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner // chain to see which bits of a value are actually demanded. If the 1936dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner // original add had another add which was then immediately truncated, we 1937dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner // could still do the transformation. 1938dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner TruncInst *TI = dyn_cast<TruncInst>(*UI); 1939dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner if (TI == 0 || 1940dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner TI->getType()->getPrimitiveSizeInBits() > NewWidth) return 0; 1941dd7e83737491b14ebf98e09fa6cb9b515f9f2e3eChris Lattner } 19420cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 1943f0f568b49e111da1258902b73a7b9266222e1842Chris Lattner // If the pattern matches, truncate the inputs to the narrower type and 1944f0f568b49e111da1258902b73a7b9266222e1842Chris Lattner // use the sadd_with_overflow intrinsic to efficiently compute both the 1945f0f568b49e111da1258902b73a7b9266222e1842Chris Lattner // result and the overflow bit. 19460a62474830f50b423329470caeb9a4e4da14a607Chris Lattner Module *M = I.getParent()->getParent()->getParent(); 19470cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 19485fdd6c8793462549e3593890ec61573da06e3346Jay Foad Type *NewType = IntegerType::get(OrigAdd->getContext(), NewWidth); 19490a62474830f50b423329470caeb9a4e4da14a607Chris Lattner Value *F = Intrinsic::getDeclaration(M, Intrinsic::sadd_with_overflow, 1950eb9a85f09e18b3fe88499710404b38d3a9128f62Benjamin Kramer NewType); 19510a62474830f50b423329470caeb9a4e4da14a607Chris Lattner 19520fe80bbbb6a017169d273c4824903b52a7ea2414Chris Lattner InstCombiner::BuilderTy *Builder = IC.Builder; 19530cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 19540a62474830f50b423329470caeb9a4e4da14a607Chris Lattner // Put the new code above the original add, in case there are any uses of the 19550a62474830f50b423329470caeb9a4e4da14a607Chris Lattner // add between the add and the compare. 1956e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner Builder->SetInsertPoint(OrigAdd); 19570cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 19580a62474830f50b423329470caeb9a4e4da14a607Chris Lattner Value *TruncA = Builder->CreateTrunc(A, NewType, A->getName()+".trunc"); 19590a62474830f50b423329470caeb9a4e4da14a607Chris Lattner Value *TruncB = Builder->CreateTrunc(B, NewType, B->getName()+".trunc"); 19600a62474830f50b423329470caeb9a4e4da14a607Chris Lattner CallInst *Call = Builder->CreateCall2(F, TruncA, TruncB, "sadd"); 19610a62474830f50b423329470caeb9a4e4da14a607Chris Lattner Value *Add = Builder->CreateExtractValue(Call, 0, "sadd.result"); 19620a62474830f50b423329470caeb9a4e4da14a607Chris Lattner Value *ZExt = Builder->CreateZExt(Add, OrigAdd->getType()); 19630cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 1964f0f568b49e111da1258902b73a7b9266222e1842Chris Lattner // The inner add was the result of the narrow add, zero extended to the 1965f0f568b49e111da1258902b73a7b9266222e1842Chris Lattner // wider type. Replace it with the result computed by the intrinsic. 19660fe80bbbb6a017169d273c4824903b52a7ea2414Chris Lattner IC.ReplaceInstUsesWith(*OrigAdd, ZExt); 19670cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 19680a62474830f50b423329470caeb9a4e4da14a607Chris Lattner // The original icmp gets replaced with the overflow value. 19690a62474830f50b423329470caeb9a4e4da14a607Chris Lattner return ExtractValueInst::Create(Call, 1, "sadd.overflow"); 1970f0f568b49e111da1258902b73a7b9266222e1842Chris Lattner} 197102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 1972e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattnerstatic Instruction *ProcessUAddIdiom(Instruction &I, Value *OrigAddV, 1973e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner InstCombiner &IC) { 1974e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner // Don't bother doing this transformation for pointers, don't do it for 1975e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner // vectors. 1976e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner if (!isa<IntegerType>(OrigAddV->getType())) return 0; 19770cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 1978e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner // If the add is a constant expr, then we don't bother transforming it. 1979e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner Instruction *OrigAdd = dyn_cast<Instruction>(OrigAddV); 1980e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner if (OrigAdd == 0) return 0; 19810cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 1982e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner Value *LHS = OrigAdd->getOperand(0), *RHS = OrigAdd->getOperand(1); 19830cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 1984e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner // Put the new code above the original add, in case there are any uses of the 1985e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner // add between the add and the compare. 1986e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner InstCombiner::BuilderTy *Builder = IC.Builder; 1987e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner Builder->SetInsertPoint(OrigAdd); 1988e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner 1989e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner Module *M = I.getParent()->getParent()->getParent(); 19905fdd6c8793462549e3593890ec61573da06e3346Jay Foad Type *Ty = LHS->getType(); 1991eb9a85f09e18b3fe88499710404b38d3a9128f62Benjamin Kramer Value *F = Intrinsic::getDeclaration(M, Intrinsic::uadd_with_overflow, Ty); 1992e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner CallInst *Call = Builder->CreateCall2(F, LHS, RHS, "uadd"); 1993e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner Value *Add = Builder->CreateExtractValue(Call, 0); 1994e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner 1995e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner IC.ReplaceInstUsesWith(*OrigAdd, Add); 1996e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner 1997e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner // The original icmp gets replaced with the overflow value. 1998e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner return ExtractValueInst::Create(Call, 1, "uadd.overflow"); 1999e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner} 2000e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner 2001da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson// DemandedBitsLHSMask - When performing a comparison against a constant, 2002da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson// it is possible that not all the bits in the LHS are demanded. This helper 2003da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson// method computes the mask that IS demanded. 2004da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Andersonstatic APInt DemandedBitsLHSMask(ICmpInst &I, 2005da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson unsigned BitWidth, bool isSignCheck) { 2006da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson if (isSignCheck) 2007da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson return APInt::getSignBit(BitWidth); 20080cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 2009da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson ConstantInt *CI = dyn_cast<ConstantInt>(I.getOperand(1)); 2010da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson if (!CI) return APInt::getAllOnesValue(BitWidth); 2011a33b6254bb40488a9574533cadf4cd0b701e97d1Owen Anderson const APInt &RHS = CI->getValue(); 20120cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 2013da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson switch (I.getPredicate()) { 20140cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // For a UGT comparison, we don't care about any bits that 2015da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson // correspond to the trailing ones of the comparand. The value of these 2016da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson // bits doesn't impact the outcome of the comparison, because any value 2017da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson // greater than the RHS must differ in a bit higher than these due to carry. 2018da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson case ICmpInst::ICMP_UGT: { 2019da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson unsigned trailingOnes = RHS.countTrailingOnes(); 2020da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson APInt lowBitsSet = APInt::getLowBitsSet(BitWidth, trailingOnes); 2021da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson return ~lowBitsSet; 2022da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson } 20230cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 2024da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson // Similarly, for a ULT comparison, we don't care about the trailing zeros. 2025da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson // Any value less than the RHS must differ in a higher bit because of carries. 2026da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson case ICmpInst::ICMP_ULT: { 2027da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson unsigned trailingZeros = RHS.countTrailingZeros(); 2028da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson APInt lowBitsSet = APInt::getLowBitsSet(BitWidth, trailingZeros); 2029da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson return ~lowBitsSet; 2030da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson } 20310cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 2032da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson default: 2033da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson return APInt::getAllOnesValue(BitWidth); 2034da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson } 20350cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 2036da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson} 203702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 203802446fc99abb06d3117d65c0b1f5fba4f906db2eChris LattnerInstruction *InstCombiner::visitICmpInst(ICmpInst &I) { 203902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner bool Changed = false; 20405f670d41318368e2a5fdc6fe2d385f003c6db68dChris Lattner Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1); 20410cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 204202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner /// Orders the operands of the compare so that they are listed from most 204302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner /// complex to least complex. This puts constants before unary operators, 204402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner /// before binary operators. 20455f670d41318368e2a5fdc6fe2d385f003c6db68dChris Lattner if (getComplexity(Op0) < getComplexity(Op1)) { 204602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner I.swapOperands(); 20475f670d41318368e2a5fdc6fe2d385f003c6db68dChris Lattner std::swap(Op0, Op1); 204802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Changed = true; 204902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 20500cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 205102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Value *V = SimplifyICmpInst(I.getPredicate(), Op0, Op1, TD)) 205202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return ReplaceInstUsesWith(I, V); 20530cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 205465a6b57c330361d1075af146300d6aab9059659cPete Cooper // comparing -val or val with non-zero is the same as just comparing val 2055165695d26161912f528e0a8dca0f22e9b6cfa57bPete Cooper // ie, abs(val) != 0 -> val != 0 205665a6b57c330361d1075af146300d6aab9059659cPete Cooper if (I.getPredicate() == ICmpInst::ICMP_NE && match(Op1, m_Zero())) 205765a6b57c330361d1075af146300d6aab9059659cPete Cooper { 2058165695d26161912f528e0a8dca0f22e9b6cfa57bPete Cooper Value *Cond, *SelectTrue, *SelectFalse; 2059165695d26161912f528e0a8dca0f22e9b6cfa57bPete Cooper if (match(Op0, m_Select(m_Value(Cond), m_Value(SelectTrue), 206065a6b57c330361d1075af146300d6aab9059659cPete Cooper m_Value(SelectFalse)))) { 2061165695d26161912f528e0a8dca0f22e9b6cfa57bPete Cooper if (Value *V = dyn_castNegVal(SelectTrue)) { 2062165695d26161912f528e0a8dca0f22e9b6cfa57bPete Cooper if (V == SelectFalse) 2063165695d26161912f528e0a8dca0f22e9b6cfa57bPete Cooper return CmpInst::Create(Instruction::ICmp, I.getPredicate(), V, Op1); 2064165695d26161912f528e0a8dca0f22e9b6cfa57bPete Cooper } 2065165695d26161912f528e0a8dca0f22e9b6cfa57bPete Cooper else if (Value *V = dyn_castNegVal(SelectFalse)) { 2066165695d26161912f528e0a8dca0f22e9b6cfa57bPete Cooper if (V == SelectTrue) 2067165695d26161912f528e0a8dca0f22e9b6cfa57bPete Cooper return CmpInst::Create(Instruction::ICmp, I.getPredicate(), V, Op1); 206865a6b57c330361d1075af146300d6aab9059659cPete Cooper } 206965a6b57c330361d1075af146300d6aab9059659cPete Cooper } 207065a6b57c330361d1075af146300d6aab9059659cPete Cooper } 207165a6b57c330361d1075af146300d6aab9059659cPete Cooper 2072db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty = Op0->getType(); 207302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 207402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // icmp's with boolean values can always be turned into bitwise operations 2075b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands if (Ty->isIntegerTy(1)) { 207602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner switch (I.getPredicate()) { 207702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner default: llvm_unreachable("Invalid icmp instruction!"); 207802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_EQ: { // icmp eq i1 A, B -> ~(A^B) 207902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *Xor = Builder->CreateXor(Op0, Op1, I.getName()+"tmp"); 208002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return BinaryOperator::CreateNot(Xor); 208102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 208202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_NE: // icmp eq i1 A, B -> A^B 208302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return BinaryOperator::CreateXor(Op0, Op1); 208402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 208502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_UGT: 208602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner std::swap(Op0, Op1); // Change icmp ugt -> icmp ult 208702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // FALL THROUGH 208802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_ULT:{ // icmp ult i1 A, B -> ~A & B 208902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *Not = Builder->CreateNot(Op0, I.getName()+"tmp"); 209002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return BinaryOperator::CreateAnd(Not, Op1); 209102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 209202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_SGT: 209302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner std::swap(Op0, Op1); // Change icmp sgt -> icmp slt 209402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // FALL THROUGH 209502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_SLT: { // icmp slt i1 A, B -> A & ~B 209602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *Not = Builder->CreateNot(Op1, I.getName()+"tmp"); 209702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return BinaryOperator::CreateAnd(Not, Op0); 209802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 209902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_UGE: 210002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner std::swap(Op0, Op1); // Change icmp uge -> icmp ule 210102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // FALL THROUGH 210202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_ULE: { // icmp ule i1 A, B -> ~A | B 210302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *Not = Builder->CreateNot(Op0, I.getName()+"tmp"); 210402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return BinaryOperator::CreateOr(Not, Op1); 210502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 210602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_SGE: 210702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner std::swap(Op0, Op1); // Change icmp sge -> icmp sle 210802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // FALL THROUGH 210902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_SLE: { // icmp sle i1 A, B -> A | ~B 211002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *Not = Builder->CreateNot(Op1, I.getName()+"tmp"); 211102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return BinaryOperator::CreateOr(Not, Op0); 211202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 211302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 211402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 211502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 211602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner unsigned BitWidth = 0; 2117e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner if (Ty->isIntOrIntVectorTy()) 211802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner BitWidth = Ty->getScalarSizeInBits(); 2119e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner else if (TD) // Pointers require TD info to get their size. 2120e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner BitWidth = TD->getTypeSizeInBits(Ty->getScalarType()); 21210cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 212202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner bool isSignBit = false; 212302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 212402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // See if we are doing a comparison with a constant. 212502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(Op1)) { 212602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *A = 0, *B = 0; 21270cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 2128e63dda51c2b230215837063dba73e9299f8c0abaOwen Anderson // Match the following pattern, which is a common idiom when writing 2129e63dda51c2b230215837063dba73e9299f8c0abaOwen Anderson // overflow-safe integer arithmetic function. The source performs an 2130e63dda51c2b230215837063dba73e9299f8c0abaOwen Anderson // addition in wider type, and explicitly checks for overflow using 2131e63dda51c2b230215837063dba73e9299f8c0abaOwen Anderson // comparisons against INT_MIN and INT_MAX. Simplify this by using the 2132e63dda51c2b230215837063dba73e9299f8c0abaOwen Anderson // sadd_with_overflow intrinsic. 2133f0f568b49e111da1258902b73a7b9266222e1842Chris Lattner // 2134f0f568b49e111da1258902b73a7b9266222e1842Chris Lattner // TODO: This could probably be generalized to handle other overflow-safe 21350cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // operations if we worked out the formulas to compute the appropriate 2136e63dda51c2b230215837063dba73e9299f8c0abaOwen Anderson // magic constants. 21370cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // 2138f0f568b49e111da1258902b73a7b9266222e1842Chris Lattner // sum = a + b 2139f0f568b49e111da1258902b73a7b9266222e1842Chris Lattner // if (sum+128 >u 255) ... -> llvm.sadd.with.overflow.i8 2140e63dda51c2b230215837063dba73e9299f8c0abaOwen Anderson { 2141f0f568b49e111da1258902b73a7b9266222e1842Chris Lattner ConstantInt *CI2; // I = icmp ugt (add (add A, B), CI2), CI 2142e63dda51c2b230215837063dba73e9299f8c0abaOwen Anderson if (I.getPredicate() == ICmpInst::ICMP_UGT && 2143f0f568b49e111da1258902b73a7b9266222e1842Chris Lattner match(Op0, m_Add(m_Add(m_Value(A), m_Value(B)), m_ConstantInt(CI2)))) 21440fe80bbbb6a017169d273c4824903b52a7ea2414Chris Lattner if (Instruction *Res = ProcessUGT_ADDCST_ADD(I, A, B, CI2, CI, *this)) 2145f0f568b49e111da1258902b73a7b9266222e1842Chris Lattner return Res; 2146e63dda51c2b230215837063dba73e9299f8c0abaOwen Anderson } 21470cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 214802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (icmp ne/eq (sub A B) 0) -> (icmp ne/eq A, B) 214902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (I.isEquality() && CI->isZero() && 215002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner match(Op0, m_Sub(m_Value(A), m_Value(B)))) { 215102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (icmp cond A B) if cond is equality 215202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(I.getPredicate(), A, B); 215302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 21540cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 215502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If we have an icmp le or icmp ge instruction, turn it into the 215602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // appropriate icmp lt or icmp gt instruction. This allows us to rely on 215702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // them being folded in the code below. The SimplifyICmpInst code has 215802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // already handled the edge cases for us, so we just assert on them. 215902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner switch (I.getPredicate()) { 216002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner default: break; 216102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_ULE: 216202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner assert(!CI->isMaxValue(false)); // A <=u MAX -> TRUE 216302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_ULT, Op0, 21643facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak Builder->getInt(CI->getValue()+1)); 216502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_SLE: 216602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner assert(!CI->isMaxValue(true)); // A <=s MAX -> TRUE 216702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_SLT, Op0, 21683facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak Builder->getInt(CI->getValue()+1)); 216902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_UGE: 2170d8d1584c13c554349c235177b2b89cb5117347b2Nick Lewycky assert(!CI->isMinValue(false)); // A >=u MIN -> TRUE 217102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_UGT, Op0, 21723facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak Builder->getInt(CI->getValue()-1)); 217302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_SGE: 2174d8d1584c13c554349c235177b2b89cb5117347b2Nick Lewycky assert(!CI->isMinValue(true)); // A >=s MIN -> TRUE 217502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_SGT, Op0, 21763facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak Builder->getInt(CI->getValue()-1)); 217702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 21780cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 217902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If this comparison is a normal comparison, it demands all 218002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // bits, if it is a sign bit comparison, it only demands the sign bit. 218102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner bool UnusedBit; 218202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner isSignBit = isSignBitCheck(I.getPredicate(), CI, UnusedBit); 218302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 218402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 218502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // See if we can fold the comparison based on range information we can get 218602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // by checking whether bits are known to be zero or one in the input. 218702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (BitWidth != 0) { 218802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner APInt Op0KnownZero(BitWidth, 0), Op0KnownOne(BitWidth, 0); 218902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner APInt Op1KnownZero(BitWidth, 0), Op1KnownOne(BitWidth, 0); 219002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 219102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (SimplifyDemandedBits(I.getOperandUse(0), 2192da1c122da5e1a86c8c2bf20e47a43f5c8fefc4e2Owen Anderson DemandedBitsLHSMask(I, BitWidth, isSignBit), 219302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Op0KnownZero, Op0KnownOne, 0)) 219402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return &I; 219502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (SimplifyDemandedBits(I.getOperandUse(1), 219602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner APInt::getAllOnesValue(BitWidth), 219702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Op1KnownZero, Op1KnownOne, 0)) 219802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return &I; 219902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 220002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Given the known and unknown bits, compute a range that the LHS could be 220102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // in. Compute the Min, Max and RHS values based on the known bits. For the 220202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // EQ and NE we use unsigned values. 220302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner APInt Op0Min(BitWidth, 0), Op0Max(BitWidth, 0); 220402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner APInt Op1Min(BitWidth, 0), Op1Max(BitWidth, 0); 220502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (I.isSigned()) { 220602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ComputeSignedMinMaxValuesFromKnownBits(Op0KnownZero, Op0KnownOne, 220702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Op0Min, Op0Max); 220802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ComputeSignedMinMaxValuesFromKnownBits(Op1KnownZero, Op1KnownOne, 220902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Op1Min, Op1Max); 221002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else { 221102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ComputeUnsignedMinMaxValuesFromKnownBits(Op0KnownZero, Op0KnownOne, 221202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Op0Min, Op0Max); 221302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ComputeUnsignedMinMaxValuesFromKnownBits(Op1KnownZero, Op1KnownOne, 221402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Op1Min, Op1Max); 221502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 221602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 221702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If Min and Max are known to be the same, then SimplifyDemandedBits 221802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // figured out that the LHS is a constant. Just constant fold this now so 221902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // that code below can assume that Min != Max. 222002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!isa<Constant>(Op0) && Op0Min == Op0Max) 222102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(I.getPredicate(), 2222d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky ConstantInt::get(Op0->getType(), Op0Min), Op1); 222302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!isa<Constant>(Op1) && Op1Min == Op1Max) 222402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(I.getPredicate(), Op0, 2225d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky ConstantInt::get(Op1->getType(), Op1Min)); 222602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 222702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Based on the range information we know about the LHS, see if we can 2228d8d1584c13c554349c235177b2b89cb5117347b2Nick Lewycky // simplify this comparison. For example, (x&4) < 8 is always true. 222902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner switch (I.getPredicate()) { 223002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner default: llvm_unreachable("Unknown icmp opcode!"); 223175d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner case ICmpInst::ICMP_EQ: { 223202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op0Max.ult(Op1Min) || Op0Min.ugt(Op1Max)) 2233d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ReplaceInstUsesWith(I, ConstantInt::getFalse(I.getType())); 22340cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 223575d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner // If all bits are known zero except for one, then we know at most one 223675d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner // bit is set. If the comparison is against zero, then this is a check 223775d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner // to see if *that* bit is set. 223875d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner APInt Op0KnownZeroInverted = ~Op0KnownZero; 223975d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner if (~Op1KnownZero == 0 && Op0KnownZeroInverted.isPowerOf2()) { 224075d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner // If the LHS is an AND with the same constant, look through it. 224175d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner Value *LHS = 0; 224275d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner ConstantInt *LHSC = 0; 224375d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner if (!match(Op0, m_And(m_Value(LHS), m_ConstantInt(LHSC))) || 224475d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner LHSC->getValue() != Op0KnownZeroInverted) 224575d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner LHS = Op0; 22460cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 224775d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner // If the LHS is 1 << x, and we know the result is a power of 2 like 8, 224879b967bd9fed0a3147d704ce269af6cc26aff391Chris Lattner // then turn "((1 << x)&8) == 0" into "x != 3". 224975d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner Value *X = 0; 225075d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner if (match(LHS, m_Shl(m_One(), m_Value(X)))) { 225175d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner unsigned CmpVal = Op0KnownZeroInverted.countTrailingZeros(); 225279b967bd9fed0a3147d704ce269af6cc26aff391Chris Lattner return new ICmpInst(ICmpInst::ICMP_NE, X, 225375d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner ConstantInt::get(X->getType(), CmpVal)); 225475d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner } 22550cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 225675d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner // If the LHS is 8 >>u x, and we know the result is a power of 2 like 1, 225779b967bd9fed0a3147d704ce269af6cc26aff391Chris Lattner // then turn "((8 >>u x)&1) == 0" into "x != 3". 2258b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner const APInt *CI; 225975d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner if (Op0KnownZeroInverted == 1 && 2260b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner match(LHS, m_LShr(m_Power2(CI), m_Value(X)))) 226179b967bd9fed0a3147d704ce269af6cc26aff391Chris Lattner return new ICmpInst(ICmpInst::ICMP_NE, X, 2262b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner ConstantInt::get(X->getType(), 2263b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner CI->countTrailingZeros())); 226475d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner } 22650cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 226602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 226775d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner } 226875d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner case ICmpInst::ICMP_NE: { 226902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op0Max.ult(Op1Min) || Op0Min.ugt(Op1Max)) 2270d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ReplaceInstUsesWith(I, ConstantInt::getTrue(I.getType())); 22710cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 227275d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner // If all bits are known zero except for one, then we know at most one 227375d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner // bit is set. If the comparison is against zero, then this is a check 227475d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner // to see if *that* bit is set. 227575d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner APInt Op0KnownZeroInverted = ~Op0KnownZero; 227675d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner if (~Op1KnownZero == 0 && Op0KnownZeroInverted.isPowerOf2()) { 227775d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner // If the LHS is an AND with the same constant, look through it. 227875d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner Value *LHS = 0; 227975d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner ConstantInt *LHSC = 0; 228075d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner if (!match(Op0, m_And(m_Value(LHS), m_ConstantInt(LHSC))) || 228175d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner LHSC->getValue() != Op0KnownZeroInverted) 228275d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner LHS = Op0; 22830cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 228475d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner // If the LHS is 1 << x, and we know the result is a power of 2 like 8, 228579b967bd9fed0a3147d704ce269af6cc26aff391Chris Lattner // then turn "((1 << x)&8) != 0" into "x == 3". 228675d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner Value *X = 0; 228775d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner if (match(LHS, m_Shl(m_One(), m_Value(X)))) { 228875d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner unsigned CmpVal = Op0KnownZeroInverted.countTrailingZeros(); 228979b967bd9fed0a3147d704ce269af6cc26aff391Chris Lattner return new ICmpInst(ICmpInst::ICMP_EQ, X, 229075d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner ConstantInt::get(X->getType(), CmpVal)); 229175d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner } 22920cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 229375d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner // If the LHS is 8 >>u x, and we know the result is a power of 2 like 1, 229479b967bd9fed0a3147d704ce269af6cc26aff391Chris Lattner // then turn "((8 >>u x)&1) != 0" into "x == 3". 2295b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner const APInt *CI; 229675d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner if (Op0KnownZeroInverted == 1 && 2297b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner match(LHS, m_LShr(m_Power2(CI), m_Value(X)))) 229879b967bd9fed0a3147d704ce269af6cc26aff391Chris Lattner return new ICmpInst(ICmpInst::ICMP_EQ, X, 2299b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner ConstantInt::get(X->getType(), 2300b20c0b5092f11ff349855ec1e732590160aeba23Chris Lattner CI->countTrailingZeros())); 230175d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner } 23020cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 230302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 230475d8f599e72c151df48a28bebc6e4e342f469b8aChris Lattner } 230502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_ULT: 230602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op0Max.ult(Op1Min)) // A <u B -> true if max(A) < min(B) 2307d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ReplaceInstUsesWith(I, ConstantInt::getTrue(I.getType())); 230802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op0Min.uge(Op1Max)) // A <u B -> false if min(A) >= max(B) 2309d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ReplaceInstUsesWith(I, ConstantInt::getFalse(I.getType())); 231002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op1Min == Op0Max) // A <u B -> A != B if max(A) == min(B) 231102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_NE, Op0, Op1); 231202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(Op1)) { 231302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op1Max == Op0Min+1) // A <u C -> A == C-1 if min(A)+1 == C 231402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_EQ, Op0, 23153facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak Builder->getInt(CI->getValue()-1)); 231602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 231702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (x <u 2147483648) -> (x >s -1) -> true if sign bit clear 231802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (CI->isMinValue(true)) 231902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_SGT, Op0, 232002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant::getAllOnesValue(Op0->getType())); 232102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 232202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 232302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_UGT: 232402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op0Min.ugt(Op1Max)) // A >u B -> true if min(A) > max(B) 2325d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ReplaceInstUsesWith(I, ConstantInt::getTrue(I.getType())); 232602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op0Max.ule(Op1Min)) // A >u B -> false if max(A) <= max(B) 2327d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ReplaceInstUsesWith(I, ConstantInt::getFalse(I.getType())); 232802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 232902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op1Max == Op0Min) // A >u B -> A != B if min(A) == max(B) 233002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_NE, Op0, Op1); 233102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(Op1)) { 233202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op1Min == Op0Max-1) // A >u C -> A == C+1 if max(a)-1 == C 233302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_EQ, Op0, 23343facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak Builder->getInt(CI->getValue()+1)); 233502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 233602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (x >u 2147483647) -> (x <s 0) -> true if sign bit set 233702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (CI->isMaxValue(true)) 233802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_SLT, Op0, 233902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant::getNullValue(Op0->getType())); 234002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 234102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 234202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_SLT: 234302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op0Max.slt(Op1Min)) // A <s B -> true if max(A) < min(C) 2344d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ReplaceInstUsesWith(I, ConstantInt::getTrue(I.getType())); 234502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op0Min.sge(Op1Max)) // A <s B -> false if min(A) >= max(C) 2346d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ReplaceInstUsesWith(I, ConstantInt::getFalse(I.getType())); 234702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op1Min == Op0Max) // A <s B -> A != B if max(A) == min(B) 234802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_NE, Op0, Op1); 234902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(Op1)) { 235002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op1Max == Op0Min+1) // A <s C -> A == C-1 if min(A)+1 == C 235102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_EQ, Op0, 23523facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak Builder->getInt(CI->getValue()-1)); 235302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 235402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 235502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_SGT: 235602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op0Min.sgt(Op1Max)) // A >s B -> true if min(A) > max(B) 2357d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ReplaceInstUsesWith(I, ConstantInt::getTrue(I.getType())); 235802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op0Max.sle(Op1Min)) // A >s B -> false if max(A) <= min(B) 2359d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ReplaceInstUsesWith(I, ConstantInt::getFalse(I.getType())); 236002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 236102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op1Max == Op0Min) // A >s B -> A != B if min(A) == max(B) 236202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_NE, Op0, Op1); 236302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(Op1)) { 236402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op1Min == Op0Max-1) // A >s C -> A == C+1 if max(A)-1 == C 236502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(ICmpInst::ICMP_EQ, Op0, 23663facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak Builder->getInt(CI->getValue()+1)); 236702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 236802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 236902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_SGE: 237002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner assert(!isa<ConstantInt>(Op1) && "ICMP_SGE with ConstantInt not folded!"); 237102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op0Min.sge(Op1Max)) // A >=s B -> true if min(A) >= max(B) 2372d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ReplaceInstUsesWith(I, ConstantInt::getTrue(I.getType())); 237302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op0Max.slt(Op1Min)) // A >=s B -> false if max(A) < min(B) 2374d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ReplaceInstUsesWith(I, ConstantInt::getFalse(I.getType())); 237502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 237602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_SLE: 237702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner assert(!isa<ConstantInt>(Op1) && "ICMP_SLE with ConstantInt not folded!"); 237802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op0Max.sle(Op1Min)) // A <=s B -> true if max(A) <= min(B) 2379d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ReplaceInstUsesWith(I, ConstantInt::getTrue(I.getType())); 238002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op0Min.sgt(Op1Max)) // A <=s B -> false if min(A) > max(B) 2381d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ReplaceInstUsesWith(I, ConstantInt::getFalse(I.getType())); 238202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 238302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_UGE: 238402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner assert(!isa<ConstantInt>(Op1) && "ICMP_UGE with ConstantInt not folded!"); 238502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op0Min.uge(Op1Max)) // A >=u B -> true if min(A) >= max(B) 2386d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ReplaceInstUsesWith(I, ConstantInt::getTrue(I.getType())); 238702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op0Max.ult(Op1Min)) // A >=u B -> false if max(A) < min(B) 2388d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ReplaceInstUsesWith(I, ConstantInt::getFalse(I.getType())); 238902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 239002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_ULE: 239102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner assert(!isa<ConstantInt>(Op1) && "ICMP_ULE with ConstantInt not folded!"); 239202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op0Max.ule(Op1Min)) // A <=u B -> true if max(A) <= min(B) 2393d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ReplaceInstUsesWith(I, ConstantInt::getTrue(I.getType())); 239402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op0Min.ugt(Op1Max)) // A <=u B -> false if min(A) > max(B) 2395d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ReplaceInstUsesWith(I, ConstantInt::getFalse(I.getType())); 239602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 239702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 239802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 239902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Turn a signed comparison into an unsigned one if both operands 240002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // are known to have the same sign. 240102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (I.isSigned() && 240202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ((Op0KnownZero.isNegative() && Op1KnownZero.isNegative()) || 240302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner (Op0KnownOne.isNegative() && Op1KnownOne.isNegative()))) 240402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(I.getUnsignedPredicate(), Op0, Op1); 240502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 240602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 240702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Test if the ICmpInst instruction is used exclusively by a select as 240802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // part of a minimum or maximum operation. If so, refrain from doing 240902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // any other folding. This helps out other analyses which understand 241002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // non-obfuscated minimum and maximum idioms, such as ScalarEvolution 241102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // and CodeGen. And in this case, at least one of the comparison 241202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // operands has at least one user besides the compare (the select), 241302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // which would often largely negate the benefit of folding anyway. 241402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (I.hasOneUse()) 241502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (SelectInst *SI = dyn_cast<SelectInst>(*I.use_begin())) 241602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if ((SI->getOperand(1) == Op0 && SI->getOperand(2) == Op1) || 241702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner (SI->getOperand(2) == Op0 && SI->getOperand(1) == Op1)) 241802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return 0; 241902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 242002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // See if we are doing a comparison between a constant and an instruction that 242102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // can be folded into the comparison. 242202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(Op1)) { 24230cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // Since the RHS is a ConstantInt (CI), if the left hand side is an 24240cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // instruction, see if that instruction also has constants so that the 24250cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach // instruction can be folded into the icmp 242602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Instruction *LHSI = dyn_cast<Instruction>(Op0)) 242702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Instruction *Res = visitICmpInstWithInstAndIntCst(I, LHSI, CI)) 242802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return Res; 242902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 243002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 243102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Handle icmp with constant (but not simple integer constant) RHS 243202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Constant *RHSC = dyn_cast<Constant>(Op1)) { 243302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Instruction *LHSI = dyn_cast<Instruction>(Op0)) 243402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner switch (LHSI->getOpcode()) { 243502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::GetElementPtr: 243602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // icmp pred GEP (P, int 0, int 0, int 0), null -> icmp pred P, null 243702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (RHSC->isNullValue() && 243802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner cast<GetElementPtrInst>(LHSI)->hasAllZeroIndices()) 243902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(I.getPredicate(), LHSI->getOperand(0), 244002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant::getNullValue(LHSI->getOperand(0)->getType())); 244102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 244202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::PHI: 244302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Only fold icmp into the PHI if the phi and icmp are in the same 244402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // block. If in the same block, we're encouraging jump threading. If 244502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // not, we are just pessimizing the code by making an i1 phi. 244602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (LHSI->getParent() == I.getParent()) 24479922ccf4b483ce37524047879f9b2f9bb73e3ccbChris Lattner if (Instruction *NV = FoldOpIntoPhi(I)) 244802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return NV; 244902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 245002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::Select: { 245102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If either operand of the select is a constant, we can fold the 245202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // comparison into the select arms, which will cause one to be 245302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // constant folded and the select turned into a bitwise or. 245402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *Op1 = 0, *Op2 = 0; 245502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Constant *C = dyn_cast<Constant>(LHSI->getOperand(1))) 245602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Op1 = ConstantExpr::getICmp(I.getPredicate(), C, RHSC); 245702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Constant *C = dyn_cast<Constant>(LHSI->getOperand(2))) 245802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Op2 = ConstantExpr::getICmp(I.getPredicate(), C, RHSC); 245902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 246002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // We only want to perform this transformation if it will not lead to 246102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // additional code. This is true if either both sides of the select 246202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // fold to a constant (in which case the icmp is replaced with a select 246302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // which will usually simplify) or this is the only user of the 246402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // select (in which case we are trading a select+icmp for a simpler 246502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // select+icmp). 246602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if ((Op1 && Op2) || (LHSI->hasOneUse() && (Op1 || Op2))) { 246702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!Op1) 246802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Op1 = Builder->CreateICmp(I.getPredicate(), LHSI->getOperand(1), 246902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner RHSC, I.getName()); 247002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!Op2) 247102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Op2 = Builder->CreateICmp(I.getPredicate(), LHSI->getOperand(2), 247202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner RHSC, I.getName()); 247302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return SelectInst::Create(LHSI->getOperand(0), Op1, Op2); 247402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 247502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 247602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 247702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::IntToPtr: 247802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // icmp pred inttoptr(X), null -> icmp pred X, 0 247902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (RHSC->isNullValue() && TD && 2480ece6c6bb6329748b92403c06ac87f45c43485911Chandler Carruth TD->getIntPtrType(RHSC->getContext()) == 248102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner LHSI->getOperand(0)->getType()) 248202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(I.getPredicate(), LHSI->getOperand(0), 248302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant::getNullValue(LHSI->getOperand(0)->getType())); 248402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 248502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 248602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::Load: 248702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Try to optimize things like "A[i] > 4" to index computations. 248802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (GetElementPtrInst *GEP = 248902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner dyn_cast<GetElementPtrInst>(LHSI->getOperand(0))) { 249002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (GlobalVariable *GV = dyn_cast<GlobalVariable>(GEP->getOperand(0))) 249102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (GV->isConstant() && GV->hasDefinitiveInitializer() && 249202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner !cast<LoadInst>(LHSI)->isVolatile()) 249302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Instruction *Res = FoldCmpLoadFromIndexedGlobal(GEP, GV, I)) 249402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return Res; 249502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 249602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 249702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 249802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 249902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 250002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If we can optimize a 'icmp GEP, P' or 'icmp P, GEP', do so now. 250102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (GEPOperator *GEP = dyn_cast<GEPOperator>(Op0)) 250202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Instruction *NI = FoldGEPICmp(GEP, Op1, I.getPredicate(), I)) 250302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return NI; 250402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (GEPOperator *GEP = dyn_cast<GEPOperator>(Op1)) 250502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Instruction *NI = FoldGEPICmp(GEP, Op0, 250602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ICmpInst::getSwappedPredicate(I.getPredicate()), I)) 250702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return NI; 250802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 250902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Test to see if the operands of the icmp are casted versions of other 251002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // values. If the ptr->ptr cast can be stripped off both arguments, we do so 251102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // now. 251202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (BitCastInst *CI = dyn_cast<BitCastInst>(Op0)) { 25130cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach if (Op0->getType()->isPointerTy() && 25140cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach (isa<Constant>(Op1) || isa<BitCastInst>(Op1))) { 251502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // We keep moving the cast from the left operand over to the right 251602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // operand, where it can often be eliminated completely. 251702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Op0 = CI->getOperand(0); 251802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 251902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If operand #1 is a bitcast instruction, it must also be a ptr->ptr cast 252002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // so eliminate it as well. 252102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (BitCastInst *CI2 = dyn_cast<BitCastInst>(Op1)) 252202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Op1 = CI2->getOperand(0); 252302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 252402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If Op1 is a constant, we can fold the cast into the constant. 252502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op0->getType() != Op1->getType()) { 252602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Constant *Op1C = dyn_cast<Constant>(Op1)) { 252702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Op1 = ConstantExpr::getBitCast(Op1C, Op0->getType()); 252802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else { 252902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Otherwise, cast the RHS right before the icmp 253002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Op1 = Builder->CreateBitCast(Op1, Op0->getType()); 253102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 253202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 253302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(I.getPredicate(), Op0, Op1); 253402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 253502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 25360cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 253702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (isa<CastInst>(Op0)) { 253802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Handle the special case of: icmp (cast bool to X), <cst> 253902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // This comes up when you have code like 254002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // int X = A < B; 254102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // if (X) ... 254202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // For generality, we handle any zero-extension of any operand comparison 254302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // with a constant or another cast from the same type. 254402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (isa<Constant>(Op1) || isa<CastInst>(Op1)) 254502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Instruction *R = visitICmpInstWithCastAndCast(I)) 254602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return R; 254702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 2548a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands 2549a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands // Special logic for binary operators. 2550a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands BinaryOperator *BO0 = dyn_cast<BinaryOperator>(Op0); 2551a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands BinaryOperator *BO1 = dyn_cast<BinaryOperator>(Op1); 2552a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands if (BO0 || BO1) { 2553a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands CmpInst::Predicate Pred = I.getPredicate(); 2554a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands bool NoOp0WrapProblem = false, NoOp1WrapProblem = false; 2555a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands if (BO0 && isa<OverflowingBinaryOperator>(BO0)) 2556a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands NoOp0WrapProblem = ICmpInst::isEquality(Pred) || 2557a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands (CmpInst::isUnsigned(Pred) && BO0->hasNoUnsignedWrap()) || 2558a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands (CmpInst::isSigned(Pred) && BO0->hasNoSignedWrap()); 2559a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands if (BO1 && isa<OverflowingBinaryOperator>(BO1)) 2560a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands NoOp1WrapProblem = ICmpInst::isEquality(Pred) || 2561a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands (CmpInst::isUnsigned(Pred) && BO1->hasNoUnsignedWrap()) || 2562a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands (CmpInst::isSigned(Pred) && BO1->hasNoSignedWrap()); 2563a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands 2564a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands // Analyze the case when either Op0 or Op1 is an add instruction. 2565a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands // Op0 = A + B (or A and B are null); Op1 = C + D (or C and D are null). 2566a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands Value *A = 0, *B = 0, *C = 0, *D = 0; 2567a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands if (BO0 && BO0->getOpcode() == Instruction::Add) 2568a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands A = BO0->getOperand(0), B = BO0->getOperand(1); 2569a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands if (BO1 && BO1->getOpcode() == Instruction::Add) 2570a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands C = BO1->getOperand(0), D = BO1->getOperand(1); 2571a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands 2572a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands // icmp (X+Y), X -> icmp Y, 0 for equalities or if there is no overflow. 2573a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands if ((A == Op1 || B == Op1) && NoOp0WrapProblem) 2574a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands return new ICmpInst(Pred, A == Op1 ? B : A, 2575a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands Constant::getNullValue(Op1->getType())); 2576a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands 2577a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands // icmp X, (X+Y) -> icmp 0, Y for equalities or if there is no overflow. 2578a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands if ((C == Op0 || D == Op0) && NoOp1WrapProblem) 2579a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands return new ICmpInst(Pred, Constant::getNullValue(Op0->getType()), 2580a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands C == Op0 ? D : C); 2581a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands 258239a7de72c8b5013f32802ceacefaaf6697726c28Duncan Sands // icmp (X+Y), (X+Z) -> icmp Y, Z for equalities or if there is no overflow. 2583a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands if (A && C && (A == C || A == D || B == C || B == D) && 2584a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands NoOp0WrapProblem && NoOp1WrapProblem && 2585a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands // Try not to increase register pressure. 2586a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands BO0->hasOneUse() && BO1->hasOneUse()) { 2587a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands // Determine Y and Z in the form icmp (X+Y), (X+Z). 2588afe4539f8ea9e12404dce0d67b421d8decb2f0fbDuncan Sands Value *Y, *Z; 2589afe4539f8ea9e12404dce0d67b421d8decb2f0fbDuncan Sands if (A == C) { 25904f0dfbb454ea8110459e2d1ee5f92e74cb3e8a5cDuncan Sands // C + B == C + D -> B == D 2591afe4539f8ea9e12404dce0d67b421d8decb2f0fbDuncan Sands Y = B; 2592afe4539f8ea9e12404dce0d67b421d8decb2f0fbDuncan Sands Z = D; 2593afe4539f8ea9e12404dce0d67b421d8decb2f0fbDuncan Sands } else if (A == D) { 25944f0dfbb454ea8110459e2d1ee5f92e74cb3e8a5cDuncan Sands // D + B == C + D -> B == C 2595afe4539f8ea9e12404dce0d67b421d8decb2f0fbDuncan Sands Y = B; 2596afe4539f8ea9e12404dce0d67b421d8decb2f0fbDuncan Sands Z = C; 2597afe4539f8ea9e12404dce0d67b421d8decb2f0fbDuncan Sands } else if (B == C) { 25984f0dfbb454ea8110459e2d1ee5f92e74cb3e8a5cDuncan Sands // A + C == C + D -> A == D 2599afe4539f8ea9e12404dce0d67b421d8decb2f0fbDuncan Sands Y = A; 2600afe4539f8ea9e12404dce0d67b421d8decb2f0fbDuncan Sands Z = D; 26014f0dfbb454ea8110459e2d1ee5f92e74cb3e8a5cDuncan Sands } else { 26024f0dfbb454ea8110459e2d1ee5f92e74cb3e8a5cDuncan Sands assert(B == D); 26034f0dfbb454ea8110459e2d1ee5f92e74cb3e8a5cDuncan Sands // A + D == C + D -> A == C 2604afe4539f8ea9e12404dce0d67b421d8decb2f0fbDuncan Sands Y = A; 2605afe4539f8ea9e12404dce0d67b421d8decb2f0fbDuncan Sands Z = C; 2606afe4539f8ea9e12404dce0d67b421d8decb2f0fbDuncan Sands } 2607a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands return new ICmpInst(Pred, Y, Z); 2608a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands } 2609a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands 261059b11c415eb90861223477841913cf7d35b1a1a4David Majnemer // icmp slt (X + -1), Y -> icmp sle X, Y 261159b11c415eb90861223477841913cf7d35b1a1a4David Majnemer if (A && NoOp0WrapProblem && Pred == CmpInst::ICMP_SLT && 261259b11c415eb90861223477841913cf7d35b1a1a4David Majnemer match(B, m_AllOnes())) 261359b11c415eb90861223477841913cf7d35b1a1a4David Majnemer return new ICmpInst(CmpInst::ICMP_SLE, A, Op1); 261459b11c415eb90861223477841913cf7d35b1a1a4David Majnemer 261559b11c415eb90861223477841913cf7d35b1a1a4David Majnemer // icmp sge (X + -1), Y -> icmp sgt X, Y 261659b11c415eb90861223477841913cf7d35b1a1a4David Majnemer if (A && NoOp0WrapProblem && Pred == CmpInst::ICMP_SGE && 261759b11c415eb90861223477841913cf7d35b1a1a4David Majnemer match(B, m_AllOnes())) 261859b11c415eb90861223477841913cf7d35b1a1a4David Majnemer return new ICmpInst(CmpInst::ICMP_SGT, A, Op1); 261959b11c415eb90861223477841913cf7d35b1a1a4David Majnemer 262059b11c415eb90861223477841913cf7d35b1a1a4David Majnemer // icmp sle (X + 1), Y -> icmp slt X, Y 262159b11c415eb90861223477841913cf7d35b1a1a4David Majnemer if (A && NoOp0WrapProblem && Pred == CmpInst::ICMP_SLE && 262259b11c415eb90861223477841913cf7d35b1a1a4David Majnemer match(B, m_One())) 262359b11c415eb90861223477841913cf7d35b1a1a4David Majnemer return new ICmpInst(CmpInst::ICMP_SLT, A, Op1); 262459b11c415eb90861223477841913cf7d35b1a1a4David Majnemer 262559b11c415eb90861223477841913cf7d35b1a1a4David Majnemer // icmp sgt (X + 1), Y -> icmp sge X, Y 262659b11c415eb90861223477841913cf7d35b1a1a4David Majnemer if (A && NoOp0WrapProblem && Pred == CmpInst::ICMP_SGT && 262759b11c415eb90861223477841913cf7d35b1a1a4David Majnemer match(B, m_One())) 262859b11c415eb90861223477841913cf7d35b1a1a4David Majnemer return new ICmpInst(CmpInst::ICMP_SGE, A, Op1); 262959b11c415eb90861223477841913cf7d35b1a1a4David Majnemer 263059b11c415eb90861223477841913cf7d35b1a1a4David Majnemer // if C1 has greater magnitude than C2: 263159b11c415eb90861223477841913cf7d35b1a1a4David Majnemer // icmp (X + C1), (Y + C2) -> icmp (X + C3), Y 263259b11c415eb90861223477841913cf7d35b1a1a4David Majnemer // s.t. C3 = C1 - C2 263359b11c415eb90861223477841913cf7d35b1a1a4David Majnemer // 263459b11c415eb90861223477841913cf7d35b1a1a4David Majnemer // if C2 has greater magnitude than C1: 263559b11c415eb90861223477841913cf7d35b1a1a4David Majnemer // icmp (X + C1), (Y + C2) -> icmp X, (Y + C3) 263659b11c415eb90861223477841913cf7d35b1a1a4David Majnemer // s.t. C3 = C2 - C1 263759b11c415eb90861223477841913cf7d35b1a1a4David Majnemer if (A && C && NoOp0WrapProblem && NoOp1WrapProblem && 263859b11c415eb90861223477841913cf7d35b1a1a4David Majnemer (BO0->hasOneUse() || BO1->hasOneUse()) && !I.isUnsigned()) 263959b11c415eb90861223477841913cf7d35b1a1a4David Majnemer if (ConstantInt *C1 = dyn_cast<ConstantInt>(B)) 264059b11c415eb90861223477841913cf7d35b1a1a4David Majnemer if (ConstantInt *C2 = dyn_cast<ConstantInt>(D)) { 264159b11c415eb90861223477841913cf7d35b1a1a4David Majnemer const APInt &AP1 = C1->getValue(); 264259b11c415eb90861223477841913cf7d35b1a1a4David Majnemer const APInt &AP2 = C2->getValue(); 264359b11c415eb90861223477841913cf7d35b1a1a4David Majnemer if (AP1.isNegative() == AP2.isNegative()) { 264459b11c415eb90861223477841913cf7d35b1a1a4David Majnemer APInt AP1Abs = C1->getValue().abs(); 264559b11c415eb90861223477841913cf7d35b1a1a4David Majnemer APInt AP2Abs = C2->getValue().abs(); 264659b11c415eb90861223477841913cf7d35b1a1a4David Majnemer if (AP1Abs.uge(AP2Abs)) { 264759b11c415eb90861223477841913cf7d35b1a1a4David Majnemer ConstantInt *C3 = Builder->getInt(AP1 - AP2); 264859b11c415eb90861223477841913cf7d35b1a1a4David Majnemer Value *NewAdd = Builder->CreateNSWAdd(A, C3); 264959b11c415eb90861223477841913cf7d35b1a1a4David Majnemer return new ICmpInst(Pred, NewAdd, C); 265059b11c415eb90861223477841913cf7d35b1a1a4David Majnemer } else { 265159b11c415eb90861223477841913cf7d35b1a1a4David Majnemer ConstantInt *C3 = Builder->getInt(AP2 - AP1); 265259b11c415eb90861223477841913cf7d35b1a1a4David Majnemer Value *NewAdd = Builder->CreateNSWAdd(C, C3); 265359b11c415eb90861223477841913cf7d35b1a1a4David Majnemer return new ICmpInst(Pred, A, NewAdd); 265459b11c415eb90861223477841913cf7d35b1a1a4David Majnemer } 265559b11c415eb90861223477841913cf7d35b1a1a4David Majnemer } 265659b11c415eb90861223477841913cf7d35b1a1a4David Majnemer } 265759b11c415eb90861223477841913cf7d35b1a1a4David Majnemer 265859b11c415eb90861223477841913cf7d35b1a1a4David Majnemer 2659a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands // Analyze the case when either Op0 or Op1 is a sub instruction. 2660a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands // Op0 = A - B (or A and B are null); Op1 = C - D (or C and D are null). 2661a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands A = 0; B = 0; C = 0; D = 0; 2662a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands if (BO0 && BO0->getOpcode() == Instruction::Sub) 2663a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands A = BO0->getOperand(0), B = BO0->getOperand(1); 2664a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands if (BO1 && BO1->getOpcode() == Instruction::Sub) 2665a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands C = BO1->getOperand(0), D = BO1->getOperand(1); 2666a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands 266739a7de72c8b5013f32802ceacefaaf6697726c28Duncan Sands // icmp (X-Y), X -> icmp 0, Y for equalities or if there is no overflow. 266839a7de72c8b5013f32802ceacefaaf6697726c28Duncan Sands if (A == Op1 && NoOp0WrapProblem) 266939a7de72c8b5013f32802ceacefaaf6697726c28Duncan Sands return new ICmpInst(Pred, Constant::getNullValue(Op1->getType()), B); 267039a7de72c8b5013f32802ceacefaaf6697726c28Duncan Sands 267139a7de72c8b5013f32802ceacefaaf6697726c28Duncan Sands // icmp X, (X-Y) -> icmp Y, 0 for equalities or if there is no overflow. 267239a7de72c8b5013f32802ceacefaaf6697726c28Duncan Sands if (C == Op0 && NoOp1WrapProblem) 267339a7de72c8b5013f32802ceacefaaf6697726c28Duncan Sands return new ICmpInst(Pred, D, Constant::getNullValue(Op0->getType())); 267439a7de72c8b5013f32802ceacefaaf6697726c28Duncan Sands 267539a7de72c8b5013f32802ceacefaaf6697726c28Duncan Sands // icmp (Y-X), (Z-X) -> icmp Y, Z for equalities or if there is no overflow. 2676a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands if (B && D && B == D && NoOp0WrapProblem && NoOp1WrapProblem && 2677a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands // Try not to increase register pressure. 2678a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands BO0->hasOneUse() && BO1->hasOneUse()) 2679a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands return new ICmpInst(Pred, A, C); 2680a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands 268139a7de72c8b5013f32802ceacefaaf6697726c28Duncan Sands // icmp (X-Y), (X-Z) -> icmp Z, Y for equalities or if there is no overflow. 268239a7de72c8b5013f32802ceacefaaf6697726c28Duncan Sands if (A && C && A == C && NoOp0WrapProblem && NoOp1WrapProblem && 268339a7de72c8b5013f32802ceacefaaf6697726c28Duncan Sands // Try not to increase register pressure. 268439a7de72c8b5013f32802ceacefaaf6697726c28Duncan Sands BO0->hasOneUse() && BO1->hasOneUse()) 268539a7de72c8b5013f32802ceacefaaf6697726c28Duncan Sands return new ICmpInst(Pred, D, B); 268639a7de72c8b5013f32802ceacefaaf6697726c28Duncan Sands 26879feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky BinaryOperator *SRem = NULL; 2688dcf77575d25ad4841e585afa27bc5ee62b32d9fdNick Lewycky // icmp (srem X, Y), Y 26899feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky if (BO0 && BO0->getOpcode() == Instruction::SRem && 26909feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky Op1 == BO0->getOperand(1)) 26919feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky SRem = BO0; 2692dcf77575d25ad4841e585afa27bc5ee62b32d9fdNick Lewycky // icmp Y, (srem X, Y) 26939feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky else if (BO1 && BO1->getOpcode() == Instruction::SRem && 26949feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky Op0 == BO1->getOperand(1)) 26959feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky SRem = BO1; 26969feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky if (SRem) { 26979feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky // We don't check hasOneUse to avoid increasing register pressure because 26989feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky // the value we use is the same value this instruction was already using. 26999feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky switch (SRem == BO0 ? ICmpInst::getSwappedPredicate(Pred) : Pred) { 27009feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky default: break; 27019feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky case ICmpInst::ICMP_EQ: 2702d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ReplaceInstUsesWith(I, ConstantInt::getFalse(I.getType())); 27039feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky case ICmpInst::ICMP_NE: 2704d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ReplaceInstUsesWith(I, ConstantInt::getTrue(I.getType())); 27059feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky case ICmpInst::ICMP_SGT: 27069feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky case ICmpInst::ICMP_SGE: 27079feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky return new ICmpInst(ICmpInst::ICMP_SGT, SRem->getOperand(1), 27089feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky Constant::getAllOnesValue(SRem->getType())); 27099feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky case ICmpInst::ICMP_SLT: 27109feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky case ICmpInst::ICMP_SLE: 27119feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky return new ICmpInst(ICmpInst::ICMP_SLT, SRem->getOperand(1), 27129feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky Constant::getNullValue(SRem->getType())); 27139feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky } 27149feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky } 27159feda1730c225589e144fb1f86a86a8cf3f39c9eNick Lewycky 2716a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands if (BO0 && BO1 && BO0->getOpcode() == BO1->getOpcode() && 2717a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands BO0->hasOneUse() && BO1->hasOneUse() && 2718a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands BO0->getOperand(1) == BO1->getOperand(1)) { 2719a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands switch (BO0->getOpcode()) { 2720a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands default: break; 2721a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands case Instruction::Add: 2722a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands case Instruction::Sub: 2723a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands case Instruction::Xor: 2724a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands if (I.isEquality()) // a+x icmp eq/ne b+x --> a icmp b 2725a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands return new ICmpInst(I.getPredicate(), BO0->getOperand(0), 2726a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands BO1->getOperand(0)); 2727a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands // icmp u/s (a ^ signbit), (b ^ signbit) --> icmp s/u a, b 2728a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands if (ConstantInt *CI = dyn_cast<ConstantInt>(BO0->getOperand(1))) { 2729a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands if (CI->getValue().isSignBit()) { 2730a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands ICmpInst::Predicate Pred = I.isSigned() 2731a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands ? I.getUnsignedPredicate() 2732a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands : I.getSignedPredicate(); 2733a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands return new ICmpInst(Pred, BO0->getOperand(0), 2734a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands BO1->getOperand(0)); 2735a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands } 27360cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 2737c73b24db5f6226ed44ebc44ce1c25bb357206623Chris Lattner if (CI->isMaxValue(true)) { 2738a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands ICmpInst::Predicate Pred = I.isSigned() 2739a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands ? I.getUnsignedPredicate() 2740a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands : I.getSignedPredicate(); 2741a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands Pred = I.getSwappedPredicate(Pred); 2742a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands return new ICmpInst(Pred, BO0->getOperand(0), 2743a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands BO1->getOperand(0)); 274402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 2745a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands } 2746a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands break; 2747a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands case Instruction::Mul: 2748a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands if (!I.isEquality()) 274902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 275002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 2751a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands if (ConstantInt *CI = dyn_cast<ConstantInt>(BO0->getOperand(1))) { 2752a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands // a * Cst icmp eq/ne b * Cst --> a & Mask icmp b & Mask 2753a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands // Mask = -1 >> count-trailing-zeros(Cst). 2754a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands if (!CI->isZero() && !CI->isOne()) { 2755a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands const APInt &AP = CI->getValue(); 27560cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach ConstantInt *Mask = ConstantInt::get(I.getContext(), 2757a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands APInt::getLowBitsSet(AP.getBitWidth(), 2758a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands AP.getBitWidth() - 2759a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands AP.countTrailingZeros())); 2760a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands Value *And1 = Builder->CreateAnd(BO0->getOperand(0), Mask); 2761a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands Value *And2 = Builder->CreateAnd(BO1->getOperand(0), Mask); 2762a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands return new ICmpInst(I.getPredicate(), And1, And2); 276302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 276402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 2765a77243300ba1a40c80c0f8417ba74bb76e7de279Duncan Sands break; 276658bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::UDiv: 276758bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::LShr: 276858bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (I.isSigned()) 276958bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 277058bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky // fall-through 277158bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::SDiv: 277258bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::AShr: 2773b6e7cd655c6ee119dbeacc321ee92387f983edb0Eli Friedman if (!BO0->isExact() || !BO1->isExact()) 277458bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 277558bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky return new ICmpInst(I.getPredicate(), BO0->getOperand(0), 277658bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky BO1->getOperand(0)); 277758bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky case Instruction::Shl: { 277858bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky bool NUW = BO0->hasNoUnsignedWrap() && BO1->hasNoUnsignedWrap(); 277958bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky bool NSW = BO0->hasNoSignedWrap() && BO1->hasNoSignedWrap(); 278058bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (!NUW && !NSW) 278158bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 278258bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky if (!NSW && I.isSigned()) 278358bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky break; 278458bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky return new ICmpInst(I.getPredicate(), BO0->getOperand(0), 278558bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky BO1->getOperand(0)); 278658bfcdbcf6a7c1cac0187f7c6beb3afe9d8f5411Nick Lewycky } 278702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 278802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 278902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 27900cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 279102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner { Value *A, *B; 2792fb1cd69b9022cb48dc3b054656cd015474d4f229David Majnemer // Transform (A & ~B) == 0 --> (A & B) != 0 2793fb1cd69b9022cb48dc3b054656cd015474d4f229David Majnemer // and (A & ~B) != 0 --> (A & B) == 0 2794fb1cd69b9022cb48dc3b054656cd015474d4f229David Majnemer // if A is a power of 2. 2795fb1cd69b9022cb48dc3b054656cd015474d4f229David Majnemer if (match(Op0, m_And(m_Value(A), m_Not(m_Value(B)))) && 2796fb1cd69b9022cb48dc3b054656cd015474d4f229David Majnemer match(Op1, m_Zero()) && isKnownToBeAPowerOfTwo(A) && I.isEquality()) 2797fb1cd69b9022cb48dc3b054656cd015474d4f229David Majnemer return new ICmpInst(I.getInversePredicate(), 2798fb1cd69b9022cb48dc3b054656cd015474d4f229David Majnemer Builder->CreateAnd(A, B), 2799fb1cd69b9022cb48dc3b054656cd015474d4f229David Majnemer Op1); 2800fb1cd69b9022cb48dc3b054656cd015474d4f229David Majnemer 2801fdb5b01df486f8fca44927a38dc9763e9d538e4cChris Lattner // ~x < ~y --> y < x 2802fdb5b01df486f8fca44927a38dc9763e9d538e4cChris Lattner // ~x < cst --> ~cst < x 2803fdb5b01df486f8fca44927a38dc9763e9d538e4cChris Lattner if (match(Op0, m_Not(m_Value(A)))) { 2804fdb5b01df486f8fca44927a38dc9763e9d538e4cChris Lattner if (match(Op1, m_Not(m_Value(B)))) 2805fdb5b01df486f8fca44927a38dc9763e9d538e4cChris Lattner return new ICmpInst(I.getPredicate(), B, A); 280627a98482bd70dd12eecd02ad600f78a2fc6c16a2Chris Lattner if (ConstantInt *RHSC = dyn_cast<ConstantInt>(Op1)) 2807fdb5b01df486f8fca44927a38dc9763e9d538e4cChris Lattner return new ICmpInst(I.getPredicate(), ConstantExpr::getNot(RHSC), A); 2808fdb5b01df486f8fca44927a38dc9763e9d538e4cChris Lattner } 2809e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner 2810e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner // (a+b) <u a --> llvm.uadd.with.overflow. 2811e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner // (a+b) <u b --> llvm.uadd.with.overflow. 2812e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner if (I.getPredicate() == ICmpInst::ICMP_ULT && 28130cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach match(Op0, m_Add(m_Value(A), m_Value(B))) && 2814e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner (Op1 == A || Op1 == B)) 2815e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner if (Instruction *R = ProcessUAddIdiom(I, Op0, *this)) 2816e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner return R; 28170cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 2818e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner // a >u (a+b) --> llvm.uadd.with.overflow. 2819e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner // b >u (a+b) --> llvm.uadd.with.overflow. 2820e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner if (I.getPredicate() == ICmpInst::ICMP_UGT && 2821e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner match(Op1, m_Add(m_Value(A), m_Value(B))) && 2822e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner (Op0 == A || Op0 == B)) 2823e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner if (Instruction *R = ProcessUAddIdiom(I, Op1, *this)) 2824e5cbdca3bd4bc40ca31282531a9292f70648d265Chris Lattner return R; 282502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 28260cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 282702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (I.isEquality()) { 282802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *A, *B, *C, *D; 282939a7de72c8b5013f32802ceacefaaf6697726c28Duncan Sands 283002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (match(Op0, m_Xor(m_Value(A), m_Value(B)))) { 283102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (A == Op1 || B == Op1) { // (A^B) == A -> B == 0 283202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *OtherVal = A == Op1 ? B : A; 283302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(I.getPredicate(), OtherVal, 283402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant::getNullValue(A->getType())); 283502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 283602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 283702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (match(Op1, m_Xor(m_Value(C), m_Value(D)))) { 283802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // A^c1 == C^c2 --> A == C^(c1^c2) 283902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ConstantInt *C1, *C2; 284002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (match(B, m_ConstantInt(C1)) && 284102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner match(D, m_ConstantInt(C2)) && Op1->hasOneUse()) { 28423facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak Constant *NC = Builder->getInt(C1->getValue() ^ C2->getValue()); 2843a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer Value *Xor = Builder->CreateXor(C, NC); 284402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(I.getPredicate(), A, Xor); 284502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 28460cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 284702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // A^B == A^D -> B == D 284802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (A == C) return new ICmpInst(I.getPredicate(), B, D); 284902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (A == D) return new ICmpInst(I.getPredicate(), B, C); 285002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (B == C) return new ICmpInst(I.getPredicate(), A, D); 285102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (B == D) return new ICmpInst(I.getPredicate(), A, C); 285202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 285302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 28540cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 285502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (match(Op1, m_Xor(m_Value(A), m_Value(B))) && 285602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner (A == Op0 || B == Op0)) { 285702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // A == (A^B) -> B == 0 285802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *OtherVal = A == Op0 ? B : A; 285902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(I.getPredicate(), OtherVal, 286002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant::getNullValue(A->getType())); 286102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 286202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 286302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (X&Z) == (Y&Z) -> (X^Y) & Z == 0 28640cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach if (match(Op0, m_OneUse(m_And(m_Value(A), m_Value(B)))) && 28655036ce4a64caaeaff4b1f8f1c91836cc2e49a455Chris Lattner match(Op1, m_OneUse(m_And(m_Value(C), m_Value(D))))) { 286602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *X = 0, *Y = 0, *Z = 0; 28670cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 286802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (A == C) { 286902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner X = B; Y = D; Z = A; 287002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else if (A == D) { 287102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner X = B; Y = C; Z = A; 287202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else if (B == C) { 287302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner X = A; Y = D; Z = B; 287402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else if (B == D) { 287502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner X = A; Y = C; Z = B; 287602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 28770cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 287802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (X) { // Build (X^Y) & Z 2879a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer Op1 = Builder->CreateXor(X, Y); 2880a9390a4d5f5d568059a80970d22194b165d097a7Benjamin Kramer Op1 = Builder->CreateAnd(Op1, Z); 288102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner I.setOperand(0, Op1); 288202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner I.setOperand(1, Constant::getNullValue(Op1->getType())); 288302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return &I; 288402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 288502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 28860cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 288766821d902040f838a97bf04a4b910fdc11ba49a9Benjamin Kramer // Transform (zext A) == (B & (1<<X)-1) --> A == (trunc B) 28887a99b467df7cf4505612a11109ed7f05ba40abf1Benjamin Kramer // and (B & (1<<X)-1) == (zext A) --> A == (trunc B) 288966821d902040f838a97bf04a4b910fdc11ba49a9Benjamin Kramer ConstantInt *Cst1; 28907a99b467df7cf4505612a11109ed7f05ba40abf1Benjamin Kramer if ((Op0->hasOneUse() && 28917a99b467df7cf4505612a11109ed7f05ba40abf1Benjamin Kramer match(Op0, m_ZExt(m_Value(A))) && 28927a99b467df7cf4505612a11109ed7f05ba40abf1Benjamin Kramer match(Op1, m_And(m_Value(B), m_ConstantInt(Cst1)))) || 28937a99b467df7cf4505612a11109ed7f05ba40abf1Benjamin Kramer (Op1->hasOneUse() && 28947a99b467df7cf4505612a11109ed7f05ba40abf1Benjamin Kramer match(Op0, m_And(m_Value(B), m_ConstantInt(Cst1))) && 28957a99b467df7cf4505612a11109ed7f05ba40abf1Benjamin Kramer match(Op1, m_ZExt(m_Value(A))))) { 289666821d902040f838a97bf04a4b910fdc11ba49a9Benjamin Kramer APInt Pow2 = Cst1->getValue() + 1; 289766821d902040f838a97bf04a4b910fdc11ba49a9Benjamin Kramer if (Pow2.isPowerOf2() && isa<IntegerType>(A->getType()) && 289866821d902040f838a97bf04a4b910fdc11ba49a9Benjamin Kramer Pow2.logBase2() == cast<IntegerType>(A->getType())->getBitWidth()) 289966821d902040f838a97bf04a4b910fdc11ba49a9Benjamin Kramer return new ICmpInst(I.getPredicate(), A, 290066821d902040f838a97bf04a4b910fdc11ba49a9Benjamin Kramer Builder->CreateTrunc(B, A->getType())); 290166821d902040f838a97bf04a4b910fdc11ba49a9Benjamin Kramer } 290266821d902040f838a97bf04a4b910fdc11ba49a9Benjamin Kramer 2903325eeb1cd7c3247ead1513204bc9cf4b6e883653Chris Lattner // Transform "icmp eq (trunc (lshr(X, cst1)), cst" to 2904325eeb1cd7c3247ead1513204bc9cf4b6e883653Chris Lattner // "icmp (and X, mask), cst" 2905325eeb1cd7c3247ead1513204bc9cf4b6e883653Chris Lattner uint64_t ShAmt = 0; 2906325eeb1cd7c3247ead1513204bc9cf4b6e883653Chris Lattner if (Op0->hasOneUse() && 2907325eeb1cd7c3247ead1513204bc9cf4b6e883653Chris Lattner match(Op0, m_Trunc(m_OneUse(m_LShr(m_Value(A), 2908325eeb1cd7c3247ead1513204bc9cf4b6e883653Chris Lattner m_ConstantInt(ShAmt))))) && 2909325eeb1cd7c3247ead1513204bc9cf4b6e883653Chris Lattner match(Op1, m_ConstantInt(Cst1)) && 2910325eeb1cd7c3247ead1513204bc9cf4b6e883653Chris Lattner // Only do this when A has multiple uses. This is most important to do 2911325eeb1cd7c3247ead1513204bc9cf4b6e883653Chris Lattner // when it exposes other optimizations. 2912325eeb1cd7c3247ead1513204bc9cf4b6e883653Chris Lattner !A->hasOneUse()) { 2913325eeb1cd7c3247ead1513204bc9cf4b6e883653Chris Lattner unsigned ASize =cast<IntegerType>(A->getType())->getPrimitiveSizeInBits(); 29140cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 2915325eeb1cd7c3247ead1513204bc9cf4b6e883653Chris Lattner if (ShAmt < ASize) { 2916325eeb1cd7c3247ead1513204bc9cf4b6e883653Chris Lattner APInt MaskV = 2917325eeb1cd7c3247ead1513204bc9cf4b6e883653Chris Lattner APInt::getLowBitsSet(ASize, Op0->getType()->getPrimitiveSizeInBits()); 2918325eeb1cd7c3247ead1513204bc9cf4b6e883653Chris Lattner MaskV <<= ShAmt; 29190cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 2920325eeb1cd7c3247ead1513204bc9cf4b6e883653Chris Lattner APInt CmpV = Cst1->getValue().zext(ASize); 2921325eeb1cd7c3247ead1513204bc9cf4b6e883653Chris Lattner CmpV <<= ShAmt; 29220cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 2923325eeb1cd7c3247ead1513204bc9cf4b6e883653Chris Lattner Value *Mask = Builder->CreateAnd(A, Builder->getInt(MaskV)); 2924325eeb1cd7c3247ead1513204bc9cf4b6e883653Chris Lattner return new ICmpInst(I.getPredicate(), Mask, Builder->getInt(CmpV)); 2925325eeb1cd7c3247ead1513204bc9cf4b6e883653Chris Lattner } 2926325eeb1cd7c3247ead1513204bc9cf4b6e883653Chris Lattner } 292702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 29280cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 292902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner { 293002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *X; ConstantInt *Cst; 293102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // icmp X+Cst, X 293202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (match(Op0, m_Add(m_Value(X), m_ConstantInt(Cst))) && Op1 == X) 293302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return FoldICmpAddOpCst(I, X, Cst, I.getPredicate(), Op0); 293402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 293502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // icmp X, X+Cst 293602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (match(Op1, m_Add(m_Value(X), m_ConstantInt(Cst))) && Op0 == X) 293702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return FoldICmpAddOpCst(I, X, Cst, I.getSwappedPredicate(), Op1); 293802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 293902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return Changed ? &I : 0; 294002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner} 294102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 294202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 294302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 294402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 294502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 294602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 294702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// FoldFCmp_IntToFP_Cst - Fold fcmp ([us]itofp x, cst) if possible. 294802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner/// 294902446fc99abb06d3117d65c0b1f5fba4f906db2eChris LattnerInstruction *InstCombiner::FoldFCmp_IntToFP_Cst(FCmpInst &I, 295002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Instruction *LHSI, 295102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant *RHSC) { 295202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!isa<ConstantFP>(RHSC)) return 0; 295302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner const APFloat &RHS = cast<ConstantFP>(RHSC)->getValueAPF(); 29540cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 295502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Get the width of the mantissa. We don't want to hack on conversions that 295602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // might lose information from the integer, e.g. "i64 -> float" 295702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner int MantissaWidth = LHSI->getType()->getFPMantissaWidth(); 295802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (MantissaWidth == -1) return 0; // Unknown. 29590cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 296002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Check to see that the input is converted from an integer type that is small 296102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // enough that preserves all bits. TODO: check here for "known" sign bits. 296202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // This would allow us to handle (fptosi (x >>s 62) to float) if x is i64 f.e. 296302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner unsigned InputSize = LHSI->getOperand(0)->getType()->getScalarSizeInBits(); 29640cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 296502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If this is a uitofp instruction, we need an extra bit to hold the sign. 296602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner bool LHSUnsigned = isa<UIToFPInst>(LHSI); 296702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (LHSUnsigned) 296802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ++InputSize; 29690cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 297002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If the conversion would lose info, don't hack on this. 297102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if ((int)InputSize > MantissaWidth) 297202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return 0; 29730cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 297402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Otherwise, we can potentially simplify the comparison. We know that it 297502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // will always come through as an integer value and we know the constant is 297602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // not a NAN (it would have been previously simplified). 297702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner assert(!RHS.isNaN() && "NaN comparison not already folded!"); 29780cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 297902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ICmpInst::Predicate Pred; 298002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner switch (I.getPredicate()) { 298102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner default: llvm_unreachable("Unexpected predicate!"); 298202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_UEQ: 298302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_OEQ: 298402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Pred = ICmpInst::ICMP_EQ; 298502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 298602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_UGT: 298702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_OGT: 298802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Pred = LHSUnsigned ? ICmpInst::ICMP_UGT : ICmpInst::ICMP_SGT; 298902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 299002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_UGE: 299102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_OGE: 299202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Pred = LHSUnsigned ? ICmpInst::ICMP_UGE : ICmpInst::ICMP_SGE; 299302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 299402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_ULT: 299502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_OLT: 299602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Pred = LHSUnsigned ? ICmpInst::ICMP_ULT : ICmpInst::ICMP_SLT; 299702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 299802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_ULE: 299902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_OLE: 300002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Pred = LHSUnsigned ? ICmpInst::ICMP_ULE : ICmpInst::ICMP_SLE; 300102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 300202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_UNE: 300302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_ONE: 300402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Pred = ICmpInst::ICMP_NE; 300502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 300602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_ORD: 30073facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak return ReplaceInstUsesWith(I, Builder->getTrue()); 300802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_UNO: 30093facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak return ReplaceInstUsesWith(I, Builder->getFalse()); 301002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 30110cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 3012db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner IntegerType *IntTy = cast<IntegerType>(LHSI->getOperand(0)->getType()); 30130cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 301402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Now we know that the APFloat is a normal number, zero or inf. 30150cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 301602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // See if the FP constant is too large for the integer. For example, 301702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // comparing an i8 to 300.0. 301802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner unsigned IntWidth = IntTy->getScalarSizeInBits(); 30190cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 302002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!LHSUnsigned) { 302102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If the RHS value is > SignedMax, fold the comparison. This handles +INF 302202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // and large values. 30234dfc257a1ad58be07753bfb96377869cb5dcf8e7Michael Gottesman APFloat SMax(RHS.getSemantics()); 302402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner SMax.convertFromAPInt(APInt::getSignedMaxValue(IntWidth), true, 302502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner APFloat::rmNearestTiesToEven); 302602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (SMax.compare(RHS) == APFloat::cmpLessThan) { // smax < 13123.0 302702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Pred == ICmpInst::ICMP_NE || Pred == ICmpInst::ICMP_SLT || 302802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Pred == ICmpInst::ICMP_SLE) 30293facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak return ReplaceInstUsesWith(I, Builder->getTrue()); 30303facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak return ReplaceInstUsesWith(I, Builder->getFalse()); 303102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 303202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else { 303302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If the RHS value is > UnsignedMax, fold the comparison. This handles 303402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // +INF and large values. 30354dfc257a1ad58be07753bfb96377869cb5dcf8e7Michael Gottesman APFloat UMax(RHS.getSemantics()); 303602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner UMax.convertFromAPInt(APInt::getMaxValue(IntWidth), false, 303702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner APFloat::rmNearestTiesToEven); 303802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (UMax.compare(RHS) == APFloat::cmpLessThan) { // umax < 13123.0 303902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Pred == ICmpInst::ICMP_NE || Pred == ICmpInst::ICMP_ULT || 304002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Pred == ICmpInst::ICMP_ULE) 30413facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak return ReplaceInstUsesWith(I, Builder->getTrue()); 30423facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak return ReplaceInstUsesWith(I, Builder->getFalse()); 304302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 304402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 30450cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 304602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!LHSUnsigned) { 304702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // See if the RHS value is < SignedMin. 30484dfc257a1ad58be07753bfb96377869cb5dcf8e7Michael Gottesman APFloat SMin(RHS.getSemantics()); 304902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner SMin.convertFromAPInt(APInt::getSignedMinValue(IntWidth), true, 305002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner APFloat::rmNearestTiesToEven); 305102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (SMin.compare(RHS) == APFloat::cmpGreaterThan) { // smin > 12312.0 305202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Pred == ICmpInst::ICMP_NE || Pred == ICmpInst::ICMP_SGT || 305302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Pred == ICmpInst::ICMP_SGE) 30543facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak return ReplaceInstUsesWith(I, Builder->getTrue()); 30553facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak return ReplaceInstUsesWith(I, Builder->getFalse()); 305602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 3057a2e0f6b643e9cfbbd698dbc9eb0289e5e33f8dc9Devang Patel } else { 3058a2e0f6b643e9cfbbd698dbc9eb0289e5e33f8dc9Devang Patel // See if the RHS value is < UnsignedMin. 30594dfc257a1ad58be07753bfb96377869cb5dcf8e7Michael Gottesman APFloat SMin(RHS.getSemantics()); 3060a2e0f6b643e9cfbbd698dbc9eb0289e5e33f8dc9Devang Patel SMin.convertFromAPInt(APInt::getMinValue(IntWidth), true, 3061a2e0f6b643e9cfbbd698dbc9eb0289e5e33f8dc9Devang Patel APFloat::rmNearestTiesToEven); 3062a2e0f6b643e9cfbbd698dbc9eb0289e5e33f8dc9Devang Patel if (SMin.compare(RHS) == APFloat::cmpGreaterThan) { // umin > 12312.0 3063a2e0f6b643e9cfbbd698dbc9eb0289e5e33f8dc9Devang Patel if (Pred == ICmpInst::ICMP_NE || Pred == ICmpInst::ICMP_UGT || 3064a2e0f6b643e9cfbbd698dbc9eb0289e5e33f8dc9Devang Patel Pred == ICmpInst::ICMP_UGE) 30653facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak return ReplaceInstUsesWith(I, Builder->getTrue()); 30663facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak return ReplaceInstUsesWith(I, Builder->getFalse()); 3067a2e0f6b643e9cfbbd698dbc9eb0289e5e33f8dc9Devang Patel } 306802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 306902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 307002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Okay, now we know that the FP constant fits in the range [SMIN, SMAX] or 307102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // [0, UMAX], but it may still be fractional. See if it is fractional by 307202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // casting the FP value to the integer value and back, checking for equality. 307302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Don't do this for zero, because -0.0 is not fractional. 307402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Constant *RHSInt = LHSUnsigned 307502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ? ConstantExpr::getFPToUI(RHSC, IntTy) 307602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner : ConstantExpr::getFPToSI(RHSC, IntTy); 307702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!RHS.isZero()) { 307802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner bool Equal = LHSUnsigned 307902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner ? ConstantExpr::getUIToFP(RHSInt, RHSC->getType()) == RHSC 308002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner : ConstantExpr::getSIToFP(RHSInt, RHSC->getType()) == RHSC; 308102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!Equal) { 308202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If we had a comparison against a fractional value, we have to adjust 308302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // the compare predicate and sometimes the value. RHSC is rounded towards 308402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // zero at this point. 308502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner switch (Pred) { 308602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner default: llvm_unreachable("Unexpected integer comparison!"); 308702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_NE: // (float)int != 4.4 --> true 30883facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak return ReplaceInstUsesWith(I, Builder->getTrue()); 308902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_EQ: // (float)int == 4.4 --> false 30903facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak return ReplaceInstUsesWith(I, Builder->getFalse()); 309102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_ULE: 309202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (float)int <= 4.4 --> int <= 4 309302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (float)int <= -4.4 --> false 309402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (RHS.isNegative()) 30953facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak return ReplaceInstUsesWith(I, Builder->getFalse()); 309602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 309702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_SLE: 309802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (float)int <= 4.4 --> int <= 4 309902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (float)int <= -4.4 --> int < -4 310002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (RHS.isNegative()) 310102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Pred = ICmpInst::ICMP_SLT; 310202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 310302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_ULT: 310402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (float)int < -4.4 --> false 310502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (float)int < 4.4 --> int <= 4 310602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (RHS.isNegative()) 31073facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak return ReplaceInstUsesWith(I, Builder->getFalse()); 310802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Pred = ICmpInst::ICMP_ULE; 310902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 311002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_SLT: 311102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (float)int < -4.4 --> int < -4 311202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (float)int < 4.4 --> int <= 4 311302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!RHS.isNegative()) 311402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Pred = ICmpInst::ICMP_SLE; 311502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 311602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_UGT: 311702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (float)int > 4.4 --> int > 4 311802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (float)int > -4.4 --> true 311902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (RHS.isNegative()) 31203facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak return ReplaceInstUsesWith(I, Builder->getTrue()); 312102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 312202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_SGT: 312302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (float)int > 4.4 --> int > 4 312402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (float)int > -4.4 --> int >= -4 312502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (RHS.isNegative()) 312602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Pred = ICmpInst::ICMP_SGE; 312702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 312802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_UGE: 312902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (float)int >= -4.4 --> true 313002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (float)int >= 4.4 --> int > 4 3131f12c95a8af22771845fa16253ad04e90741f5602Bob Wilson if (RHS.isNegative()) 31323facc43ff69947f744f2a7b6ed94649ccb44df02Jakub Staszak return ReplaceInstUsesWith(I, Builder->getTrue()); 313302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Pred = ICmpInst::ICMP_UGT; 313402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 313502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case ICmpInst::ICMP_SGE: 313602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (float)int >= -4.4 --> int >= -4 313702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // (float)int >= 4.4 --> int > 4 313802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (!RHS.isNegative()) 313902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Pred = ICmpInst::ICMP_SGT; 314002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 314102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 314202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 314302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 314402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 314502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Lower this FP comparison into an appropriate integer version of the 314602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // comparison. 314702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return new ICmpInst(Pred, LHSI->getOperand(0), RHSInt); 314802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner} 314902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 315002446fc99abb06d3117d65c0b1f5fba4f906db2eChris LattnerInstruction *InstCombiner::visitFCmpInst(FCmpInst &I) { 315102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner bool Changed = false; 31520cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 315302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner /// Orders the operands of the compare so that they are listed from most 315402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner /// complex to least complex. This puts constants before unary operators, 315502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner /// before binary operators. 315602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (getComplexity(I.getOperand(0)) < getComplexity(I.getOperand(1))) { 315702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner I.swapOperands(); 315802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Changed = true; 315902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 316002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 316102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *Op0 = I.getOperand(0), *Op1 = I.getOperand(1); 31620cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 316302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Value *V = SimplifyFCmpInst(I.getPredicate(), Op0, Op1, TD)) 316402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return ReplaceInstUsesWith(I, V); 316502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 316602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Simplify 'fcmp pred X, X' 316702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op0 == Op1) { 316802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner switch (I.getPredicate()) { 316902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner default: llvm_unreachable("Unknown predicate!"); 317002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_UNO: // True if unordered: isnan(X) | isnan(Y) 317102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_ULT: // True if unordered or less than 317202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_UGT: // True if unordered or greater than 317302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_UNE: // True if unordered or not equal 317402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Canonicalize these to be 'fcmp uno %X, 0.0'. 317502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner I.setPredicate(FCmpInst::FCMP_UNO); 317602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner I.setOperand(1, Constant::getNullValue(Op0->getType())); 317702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return &I; 31780cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 317902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_ORD: // True if ordered (no nans) 318002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_OEQ: // True if ordered and equal 318102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_OGE: // True if ordered and greater than or equal 318202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case FCmpInst::FCMP_OLE: // True if ordered and less than or equal 318302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Canonicalize these to be 'fcmp ord %X, 0.0'. 318402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner I.setPredicate(FCmpInst::FCMP_ORD); 318502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner I.setOperand(1, Constant::getNullValue(Op0->getType())); 318602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return &I; 318702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 318802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 31890cc4a958f3f27dafd5c6039962f3e3ddb17ba39fJim Grosbach 319002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Handle fcmp with constant RHS 319102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Constant *RHSC = dyn_cast<Constant>(Op1)) { 319202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Instruction *LHSI = dyn_cast<Instruction>(Op0)) 319302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner switch (LHSI->getOpcode()) { 3194b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer case Instruction::FPExt: { 3195b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer // fcmp (fpext x), C -> fcmp x, (fptrunc C) if fptrunc is lossless 3196b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer FPExtInst *LHSExt = cast<FPExtInst>(LHSI); 3197b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer ConstantFP *RHSF = dyn_cast<ConstantFP>(RHSC); 3198b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer if (!RHSF) 3199b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer break; 3200b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer 3201b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer const fltSemantics *Sem; 3202b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer // FIXME: This shouldn't be here. 3203ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman if (LHSExt->getSrcTy()->isHalfTy()) 3204ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman Sem = &APFloat::IEEEhalf; 3205ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman else if (LHSExt->getSrcTy()->isFloatTy()) 3206b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer Sem = &APFloat::IEEEsingle; 3207b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer else if (LHSExt->getSrcTy()->isDoubleTy()) 3208b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer Sem = &APFloat::IEEEdouble; 3209b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer else if (LHSExt->getSrcTy()->isFP128Ty()) 3210b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer Sem = &APFloat::IEEEquad; 3211b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer else if (LHSExt->getSrcTy()->isX86_FP80Ty()) 3212b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer Sem = &APFloat::x87DoubleExtended; 32133467b9fd5d0c4ebc726e96c2af96610e2d6915f9Ulrich Weigand else if (LHSExt->getSrcTy()->isPPC_FP128Ty()) 32143467b9fd5d0c4ebc726e96c2af96610e2d6915f9Ulrich Weigand Sem = &APFloat::PPCDoubleDouble; 3215b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer else 3216b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer break; 3217b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer 3218b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer bool Lossy; 3219b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer APFloat F = RHSF->getValueAPF(); 3220b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer F.convert(*Sem, APFloat::rmNearestTiesToEven, &Lossy); 3221b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer 3222cbf676b3ba907f72405a02938f5cd85fb3e6a46cJim Grosbach // Avoid lossy conversions and denormals. Zero is a special case 3223cbf676b3ba907f72405a02938f5cd85fb3e6a46cJim Grosbach // that's OK to convert. 322468e05fb3687ca68d5a5be49100c7c274a3185525Jim Grosbach APFloat Fabs = F; 322568e05fb3687ca68d5a5be49100c7c274a3185525Jim Grosbach Fabs.clearSign(); 3226b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer if (!Lossy && 322768e05fb3687ca68d5a5be49100c7c274a3185525Jim Grosbach ((Fabs.compare(APFloat::getSmallestNormalized(*Sem)) != 322868e05fb3687ca68d5a5be49100c7c274a3185525Jim Grosbach APFloat::cmpLessThan) || Fabs.isZero())) 3229cbf676b3ba907f72405a02938f5cd85fb3e6a46cJim Grosbach 3230b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer return new FCmpInst(I.getPredicate(), LHSExt->getOperand(0), 3231b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer ConstantFP::get(RHSC->getContext(), F)); 3232b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer break; 3233b194bdc03b6aa932ba4f719a8aa02db8d498f364Benjamin Kramer } 323402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::PHI: 323502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Only fold fcmp into the PHI if the phi and fcmp are in the same 323602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // block. If in the same block, we're encouraging jump threading. If 323702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // not, we are just pessimizing the code by making an i1 phi. 323802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (LHSI->getParent() == I.getParent()) 32399922ccf4b483ce37524047879f9b2f9bb73e3ccbChris Lattner if (Instruction *NV = FoldOpIntoPhi(I)) 324002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return NV; 324102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 324202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::SIToFP: 324302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::UIToFP: 324402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Instruction *NV = FoldFCmp_IntToFP_Cst(I, LHSI, RHSC)) 324502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return NV; 324602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 324702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner case Instruction::Select: { 324802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // If either operand of the select is a constant, we can fold the 324902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // comparison into the select arms, which will cause one to be 325002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // constant folded and the select turned into a bitwise or. 325102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Value *Op1 = 0, *Op2 = 0; 325202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (LHSI->hasOneUse()) { 325302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Constant *C = dyn_cast<Constant>(LHSI->getOperand(1))) { 325402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Fold the known value into the constant operand. 325502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Op1 = ConstantExpr::getCompare(I.getPredicate(), C, RHSC); 325602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Insert a new FCmp of the other select operand. 325702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Op2 = Builder->CreateFCmp(I.getPredicate(), 325802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner LHSI->getOperand(2), RHSC, I.getName()); 325902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } else if (Constant *C = dyn_cast<Constant>(LHSI->getOperand(2))) { 326002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Fold the known value into the constant operand. 326102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Op2 = ConstantExpr::getCompare(I.getPredicate(), C, RHSC); 326202446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner // Insert a new FCmp of the other select operand. 326302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner Op1 = Builder->CreateFCmp(I.getPredicate(), LHSI->getOperand(1), 326402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner RHSC, I.getName()); 326502446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 326602446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 326702446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 326802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner if (Op1) 326902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return SelectInst::Create(LHSI->getOperand(0), Op1, Op2); 327002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner break; 327102446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 32720db50189dcde3408134e9011052ed8b731ec303aBenjamin Kramer case Instruction::FSub: { 32730db50189dcde3408134e9011052ed8b731ec303aBenjamin Kramer // fcmp pred (fneg x), C -> fcmp swap(pred) x, -C 32740db50189dcde3408134e9011052ed8b731ec303aBenjamin Kramer Value *Op; 32750db50189dcde3408134e9011052ed8b731ec303aBenjamin Kramer if (match(LHSI, m_FNeg(m_Value(Op)))) 32760db50189dcde3408134e9011052ed8b731ec303aBenjamin Kramer return new FCmpInst(I.getSwappedPredicate(), Op, 32770db50189dcde3408134e9011052ed8b731ec303aBenjamin Kramer ConstantExpr::getFNeg(RHSC)); 32780db50189dcde3408134e9011052ed8b731ec303aBenjamin Kramer break; 32790db50189dcde3408134e9011052ed8b731ec303aBenjamin Kramer } 328039516a632385cb8103c94fceb6cfed13897a24b4Dan Gohman case Instruction::Load: 328139516a632385cb8103c94fceb6cfed13897a24b4Dan Gohman if (GetElementPtrInst *GEP = 328239516a632385cb8103c94fceb6cfed13897a24b4Dan Gohman dyn_cast<GetElementPtrInst>(LHSI->getOperand(0))) { 328339516a632385cb8103c94fceb6cfed13897a24b4Dan Gohman if (GlobalVariable *GV = dyn_cast<GlobalVariable>(GEP->getOperand(0))) 328439516a632385cb8103c94fceb6cfed13897a24b4Dan Gohman if (GV->isConstant() && GV->hasDefinitiveInitializer() && 328539516a632385cb8103c94fceb6cfed13897a24b4Dan Gohman !cast<LoadInst>(LHSI)->isVolatile()) 328639516a632385cb8103c94fceb6cfed13897a24b4Dan Gohman if (Instruction *Res = FoldCmpLoadFromIndexedGlobal(GEP, GV, I)) 328739516a632385cb8103c94fceb6cfed13897a24b4Dan Gohman return Res; 328839516a632385cb8103c94fceb6cfed13897a24b4Dan Gohman } 328939516a632385cb8103c94fceb6cfed13897a24b4Dan Gohman break; 329000abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer case Instruction::Call: { 329100abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer CallInst *CI = cast<CallInst>(LHSI); 329200abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer LibFunc::Func Func; 329300abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer // Various optimization for fabs compared with zero. 3294a4b5717ea7ea09afeb5cda2683f6e91a802f5906Benjamin Kramer if (RHSC->isNullValue() && CI->getCalledFunction() && 329500abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer TLI->getLibFunc(CI->getCalledFunction()->getName(), Func) && 329600abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer TLI->has(Func)) { 329700abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer if (Func == LibFunc::fabs || Func == LibFunc::fabsf || 329800abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer Func == LibFunc::fabsl) { 329900abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer switch (I.getPredicate()) { 330000abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer default: break; 330100abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer // fabs(x) < 0 --> false 330200abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer case FCmpInst::FCMP_OLT: 330300abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer return ReplaceInstUsesWith(I, Builder->getFalse()); 330400abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer // fabs(x) > 0 --> x != 0 330500abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer case FCmpInst::FCMP_OGT: 330600abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer return new FCmpInst(FCmpInst::FCMP_ONE, CI->getArgOperand(0), 330700abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer RHSC); 330800abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer // fabs(x) <= 0 --> x == 0 330900abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer case FCmpInst::FCMP_OLE: 331000abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer return new FCmpInst(FCmpInst::FCMP_OEQ, CI->getArgOperand(0), 331100abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer RHSC); 331200abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer // fabs(x) >= 0 --> !isnan(x) 331300abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer case FCmpInst::FCMP_OGE: 331400abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer return new FCmpInst(FCmpInst::FCMP_ORD, CI->getArgOperand(0), 331500abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer RHSC); 331600abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer // fabs(x) == 0 --> x == 0 331700abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer // fabs(x) != 0 --> x != 0 331800abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer case FCmpInst::FCMP_OEQ: 331900abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer case FCmpInst::FCMP_UEQ: 332000abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer case FCmpInst::FCMP_ONE: 332100abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer case FCmpInst::FCMP_UNE: 332200abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer return new FCmpInst(I.getPredicate(), CI->getArgOperand(0), 332300abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer RHSC); 332400abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer } 332500abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer } 332600abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer } 332700abcd3da0f36a88fb3c73586a59d782c35e17a6Benjamin Kramer } 332802446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 332902446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner } 333002446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner 333100e00d693c3991d85ffebf305ddbfd5dfb99ead6Benjamin Kramer // fcmp pred (fneg x), (fneg y) -> fcmp swap(pred) x, y 333268b4bd0a63156a9f57210243bc5a8959e93b24faBenjamin Kramer Value *X, *Y; 333368b4bd0a63156a9f57210243bc5a8959e93b24faBenjamin Kramer if (match(Op0, m_FNeg(m_Value(X))) && match(Op1, m_FNeg(m_Value(Y)))) 333400e00d693c3991d85ffebf305ddbfd5dfb99ead6Benjamin Kramer return new FCmpInst(I.getSwappedPredicate(), X, Y); 333568b4bd0a63156a9f57210243bc5a8959e93b24faBenjamin Kramer 3336cd0274ca189040a2fd883b00a678184afc2cda3aBenjamin Kramer // fcmp (fpext x), (fpext y) -> fcmp x, y 3337cd0274ca189040a2fd883b00a678184afc2cda3aBenjamin Kramer if (FPExtInst *LHSExt = dyn_cast<FPExtInst>(Op0)) 3338cd0274ca189040a2fd883b00a678184afc2cda3aBenjamin Kramer if (FPExtInst *RHSExt = dyn_cast<FPExtInst>(Op1)) 3339cd0274ca189040a2fd883b00a678184afc2cda3aBenjamin Kramer if (LHSExt->getSrcTy() == RHSExt->getSrcTy()) 3340cd0274ca189040a2fd883b00a678184afc2cda3aBenjamin Kramer return new FCmpInst(I.getPredicate(), LHSExt->getOperand(0), 3341cd0274ca189040a2fd883b00a678184afc2cda3aBenjamin Kramer RHSExt->getOperand(0)); 3342cd0274ca189040a2fd883b00a678184afc2cda3aBenjamin Kramer 334302446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner return Changed ? &I : 0; 334402446fc99abb06d3117d65c0b1f5fba4f906db2eChris Lattner} 3345