[IR][PatternMatch] Introduce m_NegatedPower2() matcher

[lebedev.ri]

Summary

It is a good idea to do as much matching inside of match() as possible.
If some checking is done afterwards, and we don't fold because of it,
chances are we may have missed some commutative pattern.

[RKSimon]

Do we have an upcoming/existing use case for this?

unittests/IR/PatternMatch.cpp

112 ↗

(On Diff #207411)

Maybe test a INT_MIN style value? That should return true for both?

[lebedev.ri]

In D64038#1566185, @RKSimon wrote:

Do we have an upcoming/existing use case for this?

Likewise, this is needed in a followup patch.

unittests/IR/PatternMatch.cpp

112 ↗

(On Diff #207411)

Will do.

[RKSimon]

reverse ping?

[lebedev.ri]

In D64038#1584597, @RKSimon wrote:

reverse ping?

I'm not doing anything here because i don't need this before i post the patch that actually uses this,
and i'm not posting that patch until i can post all of it's prerequisite patches, because otherwise
i will have one more patch up for review, thus increasing review queue even further, and lately
that queue seems to be rather completely stale.

[lebedev.ri]

Rebased, added INT_MIN test.

[lebedev.ri]

In D64038#1584663, @lebedev.ri wrote:

Rebased, added INT_MIN test.

Any other tests wanted?

[spatel]

llvm/unittests/IR/PatternMatch.cpp

485 ↗

(On Diff #209730)

Why is CNegIntMin negating C128 rather than CIntMin?

[lebedev.ri]

Fix test with signbit (:

[RKSimon]

LGTM

[spatel]

LGTM

llvm/trunk/include/llvm/IR/PatternMatch.h

 /// For vectors, this includes constants with undefined elements.
 inline cst_pred_ty<is_power2> m_Power2() {
   return cst_pred_ty<is_power2>();
 }
 inline api_pred_ty<is_power2> m_Power2(const APInt *&V) {
   return V;
 }
 
+struct is_negated_power2 {
+  bool isValue(const APInt &C) { return (-C).isPowerOf2(); }
+};
+/// Match a integer or vector negated power-of-2.
+/// For vectors, this includes constants with undefined elements.
+inline cst_pred_ty<is_negated_power2> m_NegatedPower2() {
+  return cst_pred_ty<is_negated_power2>();
+}
+inline api_pred_ty<is_negated_power2> m_NegatedPower2(const APInt *&V) {
+  return V;
+}
+
 struct is_power2_or_zero {
   bool isValue(const APInt &C) { return !C || C.isPowerOf2(); }
 };
 /// Match an integer or vector of 0 or power-of-2 values.
 /// For vectors, this includes constants with undefined elements.
 inline cst_pred_ty<is_power2_or_zero> m_Power2OrZero() {
   return cst_pred_ty<is_power2_or_zero>();
 }

llvm/trunk/unittests/IR/PatternMatch.cpp

 //===---- llvm/unittest/IR/PatternMatch.cpp - PatternMatch unit tests ----===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/PatternMatch.h"
+#include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/IRBuilder.h"
TEST_F(PatternMatchTest, Unless) {
 
   EXPECT_TRUE(m_c_Add(m_One(), m_Zero()).match(X));
   EXPECT_TRUE(m_c_Add(m_Zero(), m_One()).match(X));
 
   EXPECT_FALSE(m_Unless(m_c_Add(m_One(), m_Zero())).match(X));
   EXPECT_FALSE(m_Unless(m_c_Add(m_Zero(), m_One())).match(X));
 }
 
+TEST_F(PatternMatchTest, Power2) {
+  Value *C128 = IRB.getInt32(128);
+  Value *CNeg128 = ConstantExpr::getNeg(cast<Constant>(C128));
+
+  EXPECT_TRUE(m_Power2().match(C128));
+  EXPECT_FALSE(m_Power2().match(CNeg128));
+
+  EXPECT_FALSE(m_NegatedPower2().match(C128));
+  EXPECT_TRUE(m_NegatedPower2().match(CNeg128));
+
+  Value *CIntMin = IRB.getInt64(APSInt::getSignedMinValue(64).getSExtValue());
+  Value *CNegIntMin = ConstantExpr::getNeg(cast<Constant>(CIntMin));
+
+  EXPECT_TRUE(m_Power2().match(CIntMin));
+  EXPECT_TRUE(m_Power2().match(CNegIntMin));
+
+  EXPECT_TRUE(m_NegatedPower2().match(CIntMin));
+  EXPECT_TRUE(m_NegatedPower2().match(CNegIntMin));
+}
+
 TEST_F(PatternMatchTest, CommutativeDeferredValue) {
   Value *X = IRB.getInt32(1);
   Value *Y = IRB.getInt32(2);
 
   {
     Value *tX = X;
     EXPECT_TRUE(match(X, m_Deferred(tX)));
     EXPECT_FALSE(match(Y, m_Deferred(tX)));