[APSInt] Fix bug in APSInt in issue 59513

[Peter]

Summary

Also provide a tryExtValue() API like APInt did in D139683
This patch is almost identical to D140059, that one got reverted due a MIParser bug.
MIParser::parseImmediateOperand() expected APSInt.getExtValue to give back a 64bit integer regardless the sign.

getExtValue() used to provide a 64bit representation regardless of the sign.
After this patch, only 63 bits are allowed for unsigned value since the return value is int64_t.
This change of semantics caused some unit testing w/ large constants to fail.

We modify MIParser to refelect the intended behavior using try API introduced in D139683.
It's also a show case how try API can be used conveniently where user don't need to worry about
the detailed conditions.

[RKSimon]

Why didn't you just reopen D140059? We'd have a better paper trail then.

[Peter]

In D140418#4012700, @RKSimon wrote:

Why didn't you just reopen D140059? We'd have a better paper trail then.

I didn't know that's an option. Thanks for pointing out, closing this and move back to D140059 now.

llvm/include/llvm/ADT/APSInt.h

public:
   void setIsSigned(bool Val) { IsUnsigned = !Val; }
 
   /// Append this APSInt to the specified SmallString.
   void toString(SmallVectorImpl<char> &Str, unsigned Radix = 10) const {
     APInt::toString(Str, Radix, isSigned());
   }
   using APInt::toString;
 
+  /// If this int is representable using an int64_t.
+  bool isRepresentableByInt64() const {
+    // For unsigned values with 64 active bits, they technically fit into a
+    // int64_t, but the user may get negative numbers and has to manually cast
+    // them to unsigned. Let's not bet the user has the sanity to do that and
+    // not give them a vague value at the first place.
+    return isSigned() ? isSignedIntN(64) : isIntN(63);
+  }
+
   /// Get the correctly-extended \c int64_t value.
   int64_t getExtValue() const {
-    assert(getMinSignedBits() <= 64 && "Too many bits for int64_t");
+    assert(isRepresentableByInt64() && "Too many bits for int64_t");
     return isSigned() ? getSExtValue() : getZExtValue();
   }
 
+  std::optional<int64_t> tryExtValue() const {
+    return isRepresentableByInt64() ? std::optional<int64_t>(getExtValue())
+                                    : std::nullopt;
+  }
+
   APSInt trunc(uint32_t width) const {
     return APSInt(APInt::trunc(width), IsUnsigned);
   }
 
   APSInt extend(uint32_t width) const {
     if (IsUnsigned)
       return APSInt(zext(width), IsUnsigned);
     else

llvm/lib/CodeGen/MIRParser/MIParser.cpp

Dest = MachineOperand::CreateReg(
       Flags & RegState::InternalRead, Flags & RegState::Renamable);
 
   return false;
 }
 
 bool MIParser::parseImmediateOperand(MachineOperand &Dest) {
   assert(Token.is(MIToken::IntegerLiteral));
   const APSInt &Int = Token.integerValue();
-  if (Int.getMinSignedBits() > 64)
+  if (auto SImm = Int.trySExtValue(); Int.isSigned() && SImm.has_value())
+    Dest = MachineOperand::CreateImm(*SImm);
+  else if (auto UImm = Int.tryZExtValue(); !Int.isSigned() && UImm.has_value())
+    Dest = MachineOperand::CreateImm(*UImm);
+  else
     return error("integer literal is too large to be an immediate operand");
-  Dest = MachineOperand::CreateImm(Int.getExtValue());
   lex();
   return false;
 }
 
 bool MIParser::parseTargetImmMnemonic(const unsigned OpCode,
                                       const unsigned OpIdx,
                                       MachineOperand &Dest,
                                       const MIRFormatter &MF) {

llvm/unittests/ADT/APSIntTest.cpp

TEST(APSIntTest, getUnsigned) {
   EXPECT_EQ(7u, APSInt::getUnsigned(7).getZExtValue());
   EXPECT_EQ(7, APSInt::getUnsigned(7).getSExtValue());
   EXPECT_TRUE(APSInt::getUnsigned(-7).isUnsigned());
   EXPECT_EQ(64u, APSInt::getUnsigned(-7).getBitWidth());
   EXPECT_EQ(-7, APSInt::getUnsigned(-7).getSExtValue());
   EXPECT_EQ(UINT64_C(0) - 7, APSInt::getUnsigned(-7).getZExtValue());
 }
 
+TEST(APSIntTest, isRepresentableByInt64) {
+  ASSERT_TRUE(APSInt(APInt(3, 7), true).isRepresentableByInt64());
+  ASSERT_TRUE(APSInt(APInt(128, 7), true).isRepresentableByInt64());
+  ASSERT_TRUE(APSInt(APInt(128, 7), false).isRepresentableByInt64());
+  ASSERT_TRUE(APSInt(APInt(64, -1), false).isRepresentableByInt64());
+  ASSERT_FALSE(APSInt(APInt(64, (uint64_t)-1), true).isRepresentableByInt64());
+}
 TEST(APSIntTest, getExtValue) {
   EXPECT_TRUE(APSInt(APInt(3, 7), true).isUnsigned());
   EXPECT_TRUE(APSInt(APInt(3, 7), false).isSigned());
   EXPECT_TRUE(APSInt(APInt(4, 7), true).isUnsigned());
   EXPECT_TRUE(APSInt(APInt(4, 7), false).isSigned());
   EXPECT_TRUE(APSInt(APInt(4, -7), true).isUnsigned());
   EXPECT_TRUE(APSInt(APInt(4, -7), false).isSigned());
   EXPECT_EQ(7, APSInt(APInt(3, 7), true).getExtValue());
   EXPECT_EQ(-1, APSInt(APInt(3, 7), false).getExtValue());
   EXPECT_EQ(7, APSInt(APInt(4, 7), true).getExtValue());
   EXPECT_EQ(7, APSInt(APInt(4, 7), false).getExtValue());
   EXPECT_EQ(9, APSInt(APInt(4, -7), true).getExtValue());
   EXPECT_EQ(-7, APSInt(APInt(4, -7), false).getExtValue());
 }
+TEST(APSIntTest, tryExtValue) {
+  ASSERT_EQ(-7, APSInt(APInt(64, -7), false).tryExtValue().value_or(42));
+  ASSERT_EQ(42, APSInt(APInt(128, -7), false).tryExtValue().value_or(42));
+  ASSERT_EQ(-1,
+            APSInt(APInt::getAllOnes(128), false).tryExtValue().value_or(42));
+  ASSERT_EQ(42, APSInt(APInt(64, -7), true).tryExtValue().value_or(42));
+  ASSERT_EQ(1, APSInt(APInt(128, 1), true).tryExtValue().value_or(42));
+  ASSERT_EQ(42,
+            APSInt(APInt::getAllOnes(128), true).tryExtValue().value_or(42));
+}
 
 TEST(APSIntTest, compareValues) {
   auto U = [](uint64_t V) { return APSInt::getUnsigned(V); };
   auto S = [](int64_t V) { return APSInt::get(V); };
 
   // Bit-width matches and is-signed.
   EXPECT_TRUE(APSInt::compareValues(S(7), S(8)) < 0);
   EXPECT_TRUE(APSInt::compareValues(S(8), S(7)) > 0);