Skip to content

Commit 50a37c0

Browse files
kazutakahiratakazutakahirata
authored
[llvm] Migrate away from a soft-deprecated constructor of APInt (NFC) (#165164)
We have: /// Once all uses of this constructor are migrated to other constructors, /// consider marking this overload ""= delete" to prevent calls from being /// incorrectly bound to the APInt(unsigned, uint64_t, bool) constructor. LLVM_ABI APInt(unsigned numBits, unsigned numWords, const uint64_t bigVal[]); This patch migrates away from this soft-deprecated constructor.
1 parent 5142707 commit 50a37c0

File tree

2 files changed

+43
-45
lines changed

2 files changed

+43
-45
lines changed

‎llvm/lib/Support/APFloat.cpp‎

Lines changed: 2 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -5354,7 +5354,7 @@ APInt DoubleAPFloat::bitcastToAPInt() const {
53545354
Floats[0].bitcastToAPInt().getRawData()[0],
53555355
Floats[1].bitcastToAPInt().getRawData()[0],
53565356
};
5357-
return APInt(128, 2, Data);
5357+
return APInt(128, Data);
53585358
}
53595359

53605360
Expected<APFloat::opStatus> DoubleAPFloat::convertFromString(StringRef S,
@@ -5643,8 +5643,7 @@ APFloat::opStatus DoubleAPFloat::convertFromUnsignedParts(
56435643

56445644
// Create a minimally-sized APInt to represent the source value.
56455645
const unsigned SrcBitWidth = SrcMSB + 1;
5646-
APSInt SrcInt{APInt{/*numBits=*/SrcBitWidth,
5647-
/*numWords=*/SrcCount, Src},
5646+
APSInt SrcInt{APInt{/*numBits=*/SrcBitWidth, ArrayRef(Src, SrcCount)},
56485647
/*isUnsigned=*/true};
56495648

56505649
// Stage 1: Initial Approximation.

‎llvm/unittests/ADT/APFloatTest.cpp‎

Lines changed: 41 additions & 42 deletions
Original file line numberDiff line numberDiff line change
@@ -5062,8 +5062,8 @@ TEST(APFloatTest, PPCDoubleDoubleAddSpecial) {
50625062
std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected, RM) = Tp;
50635063

50645064
{
5065-
APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
5066-
APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
5065+
APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, Op1));
5066+
APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, Op2));
50675067
A1.add(A2, RM);
50685068

50695069
EXPECT_EQ(Expected, A1.getCategory())
@@ -5072,8 +5072,8 @@ TEST(APFloatTest, PPCDoubleDoubleAddSpecial) {
50725072
.str();
50735073
}
50745074
{
5075-
APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
5076-
APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
5075+
APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, Op1));
5076+
APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, Op2));
50775077
A2.add(A1, RM);
50785078

50795079
EXPECT_EQ(Expected, A2.getCategory())
@@ -5126,8 +5126,8 @@ TEST(APFloatTest, PPCDoubleDoubleAdd) {
51265126
std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp;
51275127

51285128
{
5129-
APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
5130-
APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
5129+
APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, Op1));
5130+
APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, Op2));
51315131
A1.add(A2, RM);
51325132

51335133
EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
@@ -5140,8 +5140,8 @@ TEST(APFloatTest, PPCDoubleDoubleAdd) {
51405140
.str();
51415141
}
51425142
{
5143-
APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
5144-
APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
5143+
APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, Op1));
5144+
APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, Op2));
51455145
A2.add(A1, RM);
51465146

51475147
EXPECT_EQ(Expected[0], A2.bitcastToAPInt().getRawData()[0])
@@ -5175,8 +5175,8 @@ TEST(APFloatTest, PPCDoubleDoubleSubtract) {
51755175
APFloat::roundingMode RM;
51765176
std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp;
51775177

5178-
APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
5179-
APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
5178+
APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, Op1));
5179+
APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, Op2));
51805180
A1.subtract(A2, RM);
51815181

51825182
EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
@@ -5230,8 +5230,8 @@ TEST(APFloatTest, PPCDoubleDoubleMultiplySpecial) {
52305230
std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected, RM) = Tp;
52315231

52325232
{
5233-
APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
5234-
APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
5233+
APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, Op1));
5234+
APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, Op2));
52355235
A1.multiply(A2, RM);
52365236

52375237
EXPECT_EQ(Expected, A1.getCategory())
@@ -5240,8 +5240,8 @@ TEST(APFloatTest, PPCDoubleDoubleMultiplySpecial) {
52405240
.str();
52415241
}
52425242
{
5243-
APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
5244-
APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
5243+
APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, Op1));
5244+
APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, Op2));
52455245
A2.multiply(A1, RM);
52465246

52475247
EXPECT_EQ(Expected, A2.getCategory())
@@ -5303,8 +5303,8 @@ TEST(APFloatTest, PPCDoubleDoubleMultiply) {
53035303
std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp;
53045304

53055305
{
5306-
APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
5307-
APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
5306+
APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, Op1));
5307+
APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, Op2));
53085308
A1.multiply(A2, RM);
53095309

53105310
EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
@@ -5317,8 +5317,8 @@ TEST(APFloatTest, PPCDoubleDoubleMultiply) {
53175317
.str();
53185318
}
53195319
{
5320-
APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
5321-
APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
5320+
APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, Op1));
5321+
APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, Op2));
53225322
A2.multiply(A1, RM);
53235323

53245324
EXPECT_EQ(Expected[0], A2.bitcastToAPInt().getRawData()[0])
@@ -5350,8 +5350,8 @@ TEST(APFloatTest, PPCDoubleDoubleDivide) {
53505350
APFloat::roundingMode RM;
53515351
std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1], RM) = Tp;
53525352

5353-
APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
5354-
APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
5353+
APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, Op1));
5354+
APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, Op2));
53555355
A1.divide(A2, RM);
53565356

53575357
EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
@@ -5383,8 +5383,8 @@ TEST(APFloatTest, PPCDoubleDoubleRemainder) {
53835383
uint64_t Op1[2], Op2[2], Expected[2];
53845384
std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1]) = Tp;
53855385

5386-
APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
5387-
APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
5386+
APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, Op1));
5387+
APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, Op2));
53885388
A1.remainder(A2);
53895389

53905390
EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
@@ -5418,8 +5418,8 @@ TEST(APFloatTest, PPCDoubleDoubleMod) {
54185418
uint64_t Op1[2], Op2[2], Expected[2];
54195419
std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected[0], Expected[1]) = Tp;
54205420

5421-
APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
5422-
APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
5421+
APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, Op1));
5422+
APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, Op2));
54235423
A1.mod(A2);
54245424

54255425
EXPECT_EQ(Expected[0], A1.bitcastToAPInt().getRawData()[0])
@@ -6282,8 +6282,8 @@ TEST(APFloatTest, PPCDoubleDoubleCompare) {
62826282
APFloat::cmpResult Expected;
62836283
std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected) = Tp;
62846284

6285-
APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
6286-
APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
6285+
APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, Op1));
6286+
APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, Op2));
62876287
EXPECT_EQ(Expected, A1.compare(A2))
62886288
<< formatv("compare(({0:x} + {1:x}), ({2:x} + {3:x}))", Op1[0], Op1[1],
62896289
Op2[0], Op2[1])
@@ -6410,8 +6410,8 @@ TEST(APFloatTest, PPCDoubleDoubleBitwiseIsEqual) {
64106410
bool Expected;
64116411
std::tie(Op1[0], Op1[1], Op2[0], Op2[1], Expected) = Tp;
64126412

6413-
APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, 2, Op1));
6414-
APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, 2, Op2));
6413+
APFloat A1(APFloat::PPCDoubleDouble(), APInt(128, Op1));
6414+
APFloat A2(APFloat::PPCDoubleDouble(), APInt(128, Op2));
64156415
EXPECT_EQ(Expected, A1.bitwiseIsEqual(A2))
64166416
<< formatv("({0:x} + {1:x}) = ({2:x} + {3:x})", Op1[0], Op1[1], Op2[0],
64176417
Op2[1])
@@ -6423,16 +6423,15 @@ TEST(APFloatTest, PPCDoubleDoubleHashValue) {
64236423
uint64_t Data1[] = {0x3ff0000000000001ull, 0x0000000000000001ull};
64246424
uint64_t Data2[] = {0x3ff0000000000001ull, 0};
64256425
// The hash values are *hopefully* different.
6426-
EXPECT_NE(
6427-
hash_value(APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Data1))),
6428-
hash_value(APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Data2))));
6426+
EXPECT_NE(hash_value(APFloat(APFloat::PPCDoubleDouble(), APInt(128, Data1))),
6427+
hash_value(APFloat(APFloat::PPCDoubleDouble(), APInt(128, Data2))));
64296428
}
64306429

64316430
TEST(APFloatTest, PPCDoubleDoubleChangeSign) {
64326431
uint64_t Data[] = {
64336432
0x400f000000000000ull, 0xbcb0000000000000ull,
64346433
};
6435-
APFloat Float(APFloat::PPCDoubleDouble(), APInt(128, 2, Data));
6434+
APFloat Float(APFloat::PPCDoubleDouble(), APInt(128, Data));
64366435
{
64376436
APFloat Actual =
64386437
APFloat::copySign(Float, APFloat(APFloat::IEEEdouble(), "1"));
@@ -6452,27 +6451,27 @@ TEST(APFloatTest, PPCDoubleDoubleFactories) {
64526451
uint64_t Data[] = {
64536452
0, 0,
64546453
};
6455-
EXPECT_EQ(APInt(128, 2, Data),
6454+
EXPECT_EQ(APInt(128, Data),
64566455
APFloat::getZero(APFloat::PPCDoubleDouble()).bitcastToAPInt());
64576456
}
64586457
{
64596458
uint64_t Data[] = {
64606459
0x7fefffffffffffffull, 0x7c8ffffffffffffeull,
64616460
};
6462-
EXPECT_EQ(APInt(128, 2, Data),
6461+
EXPECT_EQ(APInt(128, Data),
64636462
APFloat::getLargest(APFloat::PPCDoubleDouble()).bitcastToAPInt());
64646463
}
64656464
{
64666465
uint64_t Data[] = {
64676466
0x0000000000000001ull, 0,
64686467
};
64696468
EXPECT_EQ(
6470-
APInt(128, 2, Data),
6469+
APInt(128, Data),
64716470
APFloat::getSmallest(APFloat::PPCDoubleDouble()).bitcastToAPInt());
64726471
}
64736472
{
64746473
uint64_t Data[] = {0x0360000000000000ull, 0};
6475-
EXPECT_EQ(APInt(128, 2, Data),
6474+
EXPECT_EQ(APInt(128, Data),
64766475
APFloat::getSmallestNormalized(APFloat::PPCDoubleDouble())
64776476
.bitcastToAPInt());
64786477
}
@@ -6481,30 +6480,30 @@ TEST(APFloatTest, PPCDoubleDoubleFactories) {
64816480
0x8000000000000000ull, 0x0000000000000000ull,
64826481
};
64836482
EXPECT_EQ(
6484-
APInt(128, 2, Data),
6483+
APInt(128, Data),
64856484
APFloat::getZero(APFloat::PPCDoubleDouble(), true).bitcastToAPInt());
64866485
}
64876486
{
64886487
uint64_t Data[] = {
64896488
0xffefffffffffffffull, 0xfc8ffffffffffffeull,
64906489
};
64916490
EXPECT_EQ(
6492-
APInt(128, 2, Data),
6491+
APInt(128, Data),
64936492
APFloat::getLargest(APFloat::PPCDoubleDouble(), true).bitcastToAPInt());
64946493
}
64956494
{
64966495
uint64_t Data[] = {
64976496
0x8000000000000001ull, 0x0000000000000000ull,
64986497
};
6499-
EXPECT_EQ(APInt(128, 2, Data),
6498+
EXPECT_EQ(APInt(128, Data),
65006499
APFloat::getSmallest(APFloat::PPCDoubleDouble(), true)
65016500
.bitcastToAPInt());
65026501
}
65036502
{
65046503
uint64_t Data[] = {
65056504
0x8360000000000000ull, 0x0000000000000000ull,
65066505
};
6507-
EXPECT_EQ(APInt(128, 2, Data),
6506+
EXPECT_EQ(APInt(128, Data),
65086507
APFloat::getSmallestNormalized(APFloat::PPCDoubleDouble(), true)
65096508
.bitcastToAPInt());
65106509
}
@@ -6523,7 +6522,7 @@ TEST(APFloatTest, PPCDoubleDoubleIsDenormal) {
65236522
0x4010000000000000ull, 0x4008000000000000ull,
65246523
};
65256524
EXPECT_TRUE(
6526-
APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Data)).isDenormal());
6525+
APFloat(APFloat::PPCDoubleDouble(), APInt(128, Data)).isDenormal());
65276526
}
65286527
}
65296528

@@ -6533,7 +6532,7 @@ TEST(APFloatTest, PPCDoubleDoubleScalbn) {
65336532
0x4008000000000000ull, 0x3cb8000000000000ull,
65346533
};
65356534
APFloat Result =
6536-
scalbn(APFloat(APFloat::PPCDoubleDouble(), APInt(128, 2, Input)), 1,
6535+
scalbn(APFloat(APFloat::PPCDoubleDouble(), APInt(128, Input)), 1,
65376536
APFloat::rmNearestTiesToEven);
65386537
// 6.0 + 6.0 << 53
65396538
EXPECT_EQ(0x4018000000000000ull, Result.bitcastToAPInt().getRawData()[0]);

0 commit comments

Comments
 (0)