[PATCH] D101840: [InstSimplify] ctlz(x) -> 0 if x is known negative number

[Craig Topper via Phabricator via llvm-commits]

craig.topper added a comment.

isKnownNegative is just a wrapper around computeKnownBits. So if we are to do this in InstSimplify we might as well take the whole code that was already flagged in InstCombineCalls that can already do this and more.

  KnownBits Known = IC.computeKnownBits(Op0, 0, &II);                                                                                                                                                  
                                                                                                                                                                                                       
  // Create a mask for bits above (ctlz) or below (cttz) the first known one.                                                                                                                          
  unsigned PossibleZeros = IsTZ ? Known.countMaxTrailingZeros()                                                                                                                                        
                                : Known.countMaxLeadingZeros();                                                                                                                                        
  unsigned DefiniteZeros = IsTZ ? Known.countMinTrailingZeros()                                                                                                                                        
                                : Known.countMinLeadingZeros();                                                                                                                                        
                                                                                                                                                                                                       
  // If all bits above (ctlz) or below (cttz) the first known one are known                                                                                                                            
  // zero, this value is constant.                                                                                                                                                                     
  // FIXME: This should be in InstSimplify because we're replacing an                                                                                                                                  
  // instruction with a constant.                                                                                                                                                                      
  if (PossibleZeros == DefiniteZeros) {                                                                                                                                                                
    auto *C = ConstantInt::get(Op0->getType(), DefiniteZeros);                                                                                                                                         
    return IC.replaceInstUsesWith(II, C);                                                                                                                                                              
  }    


CHANGES SINCE LAST ACTION
  https://reviews.llvm.org/D101840/new/

https://reviews.llvm.org/D101840