[APInt] Move operator~ out of line to make it better able to reused memory allocation from temporary objects

[craig.topper]

Summary

This makes operator~ take the APInt by value so if it came from a temporary APInt the move constructor will get invoked and it will be able to reuse the memory allocation from the temporary.

This is similar to what was already done for 2s complement negation.

[RKSimon]

Are there any uses of this? APIntTest.cpp doesn't seem to have any.

[craig.topper]

It is used in other places for example

lib/CodeGen/SelectionDAG/DAGCombiner.cpp
2017: if (DAG.MaskedValueIsZero(N1, ~APInt::getSignBit(BitWidth))) {
8127: SignMask = ~APInt::getSignBit(SourceVT.getSizeInBits());
10226: SignMask = ~APInt::getSignBit(N0.getScalarValueSizeInBits());
10230: SignMask = ~APInt::getSignBit(IntVT.getSizeInBits());
11609: APInt Mask = ~APInt::getBitsSet(IVal.getValueSizeInBits(),

I'll see if I can construct a test case for the move behavior.

[davide]

This looks fine. It would be nice if you could keep the doxygen comment.

llvm/trunk/include/llvm/ADT/APInt.h

const APInt operator--(int) {
     return API;
   }
 
   /// \brief Prefix decrement operator.
   ///
   /// \returns *this decremented by one.
   APInt &operator--();
 
-  /// \brief Unary bitwise complement operator.
-  ///
-  /// Performs a bitwise complement operation on this APInt.
-  ///
-  /// \returns an APInt that is the bitwise complement of *this
-  APInt operator~() const {
-    APInt Result(*this);
-    Result.flipAllBits();
-    return Result;
-  }
-
   /// \brief Logical negation operator.
   ///
   /// Performs logical negation operation on this APInt.
   ///
   /// \returns true if *this is zero, false otherwise.
   bool operator!() const {
     if (isSingleWord())
       return !VAL;
struct APInt::mu {
   bool a;     ///< add indicator
   unsigned s; ///< shift amount
 };
 
 inline bool operator==(uint64_t V1, const APInt &V2) { return V2 == V1; }
 
 inline bool operator!=(uint64_t V1, const APInt &V2) { return V2 != V1; }
 
+/// \brief Unary bitwise complement operator.
+///
+/// \returns an APInt that is the bitwise complement of \p v.
+inline APInt operator~(APInt v) {
+  v.flipAllBits();
+  return v;
+}
+
 inline APInt operator&(APInt a, uint64_t RHS) {
   a &= RHS;
   return a;
 }
 
 inline APInt operator&(uint64_t LHS, APInt b) {
   b &= LHS;
   return b;

llvm/trunk/unittests/ADT/APIntTest.cpp

const uint64_t *RawDataR = nullptr;
     EXPECT_EQ(SubRK.getRawData(), RawDataL);
 
     APInt SubKR = 2 - getRValue("1FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF", RawDataR);
     EXPECT_EQ(SubKR, Three);
     EXPECT_EQ(SubKR.getRawData(), RawDataR);
   }
 }
 
+TEST(APIntTest, rvalue_invert) {
+  // Lamdba to return an APInt by value, but also provide the raw value of the
+  // allocated data.
+  auto getRValue = [](const char *HexString, uint64_t const *&RawData) {
+    APInt V(129, HexString, 16);
+    RawData = V.getRawData();
+    return V;
+  };
+
+  APInt One(129, 1);
+  APInt NegativeTwo(129, -2ULL, true);
+
+  const uint64_t *RawData = nullptr;
+
+  {
+    // ~1 = -2
+    APInt NegL = ~One;
+    EXPECT_EQ(NegL, NegativeTwo);
+
+    APInt NegR = ~getRValue("1", RawData);
+    EXPECT_EQ(NegR, NegativeTwo);
+    EXPECT_EQ(NegR.getRawData(), RawData);
+  }
+}
 
 // Tests different div/rem varaints using scheme (a * b + c) / a
 void testDiv(APInt a, APInt b, APInt c) {
   ASSERT_TRUE(a.uge(b)); // Must: a >= b
   ASSERT_TRUE(a.ugt(c)); // Must: a > c
 
   auto p = a * b + c;