Skip to content

Commit

Permalink
[llvm] Use has_value instead of hasValue (NFC)
Browse files Browse the repository at this point in the history
  • Loading branch information
@kazutakahirata
kazutakahirata committed Jul 13, 2022
1 parent 67d760d commit 3361a36
Show file tree
Hide file tree
Showing 19 changed files with 200 additions and 198 deletions.
4 changes: 2 additions & 2 deletions llvm/include/llvm/MC/MCDwarf.h
View file
Expand Up @@ -374,8 +374,8 @@ class MCDwarfLineTable {
Header.RootFile.DirIndex = 0;
Header.RootFile.Checksum = Checksum;
Header.RootFile.Source = Source;
Header.trackMD5Usage(Checksum.hasValue());
Header.HasSource = Source.hasValue();
Header.trackMD5Usage(Checksum.has_value());
Header.HasSource = Source.has_value();
}

void resetFileTable() { Header.resetFileTable(); }
Expand Down
10 changes: 5 additions & 5 deletions llvm/unittests/ADT/OptionalTest.cpp
View file
Expand Up @@ -29,7 +29,7 @@ void OptionalWorksInConstexpr() {
constexpr Optional<int> x2{};
static_assert(!x1.has_value() && !x2.has_value(),
"Default construction and hasValue() are contexpr");
static_assert(!x1.hasValue() && !x2.hasValue(),
static_assert(!x1.has_value() && !x2.has_value(),
"Default construction and hasValue() are contexpr");
constexpr auto y1 = Optional<int>(3);
constexpr Optional<int> y2{3};
Expand Down Expand Up @@ -252,14 +252,14 @@ TEST(OptionalTest, Emplace) {

A.emplace(1, 2);
EXPECT_TRUE(A.has_value());
EXPECT_TRUE(A.hasValue());
EXPECT_TRUE(A.has_value());
EXPECT_EQ(1, A->x);
EXPECT_EQ(2, A->y);
EXPECT_EQ(0u, MultiArgConstructor::Destructions);

A.emplace(5, false);
EXPECT_TRUE(A.has_value());
EXPECT_TRUE(A.hasValue());
EXPECT_TRUE(A.has_value());
EXPECT_EQ(5, A->x);
EXPECT_EQ(-5, A->y);
EXPECT_EQ(1u, MultiArgConstructor::Destructions);
Expand All @@ -270,12 +270,12 @@ TEST(OptionalTest, InPlaceConstructionMultiArgConstructorTest) {
{
Optional<MultiArgConstructor> A{in_place, 1, 2};
EXPECT_TRUE(A.has_value());
EXPECT_TRUE(A.hasValue());
EXPECT_TRUE(A.has_value());
EXPECT_EQ(1, A->x);
EXPECT_EQ(2, A->y);
Optional<MultiArgConstructor> B{in_place, 5, false};
EXPECT_TRUE(B.has_value());
EXPECT_TRUE(B.hasValue());
EXPECT_TRUE(B.has_value());
EXPECT_EQ(5, B->x);
EXPECT_EQ(-5, B->y);
EXPECT_EQ(0u, MultiArgConstructor::Destructions);
Expand Down
16 changes: 8 additions & 8 deletions llvm/unittests/ADT/StatisticTest.cpp
View file
Expand Up @@ -92,8 +92,8 @@ TEST(StatisticTest, API) {
OptionalStatistic S2;
extractCounters(Range1, S1, S2);

EXPECT_EQ(S1.hasValue(), true);
EXPECT_EQ(S2.hasValue(), false);
EXPECT_EQ(S1.has_value(), true);
EXPECT_EQ(S2.has_value(), false);
}

// Counter2 will be registered when it's first touched.
Expand All @@ -108,8 +108,8 @@ TEST(StatisticTest, API) {
OptionalStatistic S2;
extractCounters(Range, S1, S2);

EXPECT_EQ(S1.hasValue(), true);
EXPECT_EQ(S2.hasValue(), true);
EXPECT_EQ(S1.has_value(), true);
EXPECT_EQ(S2.has_value(), true);

EXPECT_EQ(S1->first, "Counter");
EXPECT_EQ(S1->second, 2u);
Expand All @@ -135,8 +135,8 @@ TEST(StatisticTest, API) {
OptionalStatistic S1;
OptionalStatistic S2;
extractCounters(Range, S1, S2);
EXPECT_EQ(S1.hasValue(), false);
EXPECT_EQ(S2.hasValue(), false);
EXPECT_EQ(S1.has_value(), false);
EXPECT_EQ(S2.has_value(), false);
}

// Now check that they successfully re-register and count.
Expand All @@ -153,8 +153,8 @@ TEST(StatisticTest, API) {
OptionalStatistic S2;
extractCounters(Range, S1, S2);

EXPECT_EQ(S1.hasValue(), true);
EXPECT_EQ(S2.hasValue(), true);
EXPECT_EQ(S1.has_value(), true);
EXPECT_EQ(S2.has_value(), true);

EXPECT_EQ(S1->first, "Counter");
EXPECT_EQ(S1->second, 1u);
Expand Down
4 changes: 2 additions & 2 deletions llvm/unittests/Analysis/IRSimilarityIdentifierTest.cpp
View file
Expand Up @@ -2188,9 +2188,9 @@ TEST(IRSimilarityCandidate, CanonicalNumbering) {
for (std::pair<unsigned, DenseSet<unsigned>> &P : Mapping2) {
unsigned Source = P.first;

ASSERT_TRUE(Cand2.getCanonicalNum(Source).hasValue());
ASSERT_TRUE(Cand2.getCanonicalNum(Source).has_value());
unsigned Canon = *Cand2.getCanonicalNum(Source);
ASSERT_TRUE(Cand1.fromCanonicalNum(Canon).hasValue());
ASSERT_TRUE(Cand1.fromCanonicalNum(Canon).has_value());
unsigned Dest = *Cand1.fromCanonicalNum(Canon);

DenseSet<unsigned>::iterator It = P.second.find(Dest);
Expand Down
20 changes: 10 additions & 10 deletions llvm/unittests/BinaryFormat/DwarfTest.cpp
View file
Expand Up @@ -147,48 +147,48 @@ TEST(DwarfTest, FixedFormSizes) {
FormParams Params_2_4_32 = {2, 4, DWARF32};
RefSize = getFixedFormByteSize(DW_FORM_ref_addr, Params_2_4_32);
AddrSize = getFixedFormByteSize(DW_FORM_ref_addr, Params_2_4_32);
EXPECT_TRUE(RefSize.hasValue());
EXPECT_TRUE(AddrSize.hasValue());
EXPECT_TRUE(RefSize.has_value());
EXPECT_TRUE(AddrSize.has_value());
EXPECT_EQ(*RefSize, *AddrSize);

// Test 32 bit DWARF version 2 with 8 byte addresses.
FormParams Params_2_8_32 = {2, 8, DWARF32};
RefSize = getFixedFormByteSize(DW_FORM_ref_addr, Params_2_8_32);
AddrSize = getFixedFormByteSize(DW_FORM_ref_addr, Params_2_8_32);
EXPECT_TRUE(RefSize.hasValue());
EXPECT_TRUE(AddrSize.hasValue());
EXPECT_TRUE(RefSize.has_value());
EXPECT_TRUE(AddrSize.has_value());
EXPECT_EQ(*RefSize, *AddrSize);

// DW_FORM_ref_addr is 4 bytes in DWARF 32 in DWARF version 3 and beyond.
FormParams Params_3_4_32 = {3, 4, DWARF32};
RefSize = getFixedFormByteSize(DW_FORM_ref_addr, Params_3_4_32);
EXPECT_TRUE(RefSize.hasValue());
EXPECT_TRUE(RefSize.has_value());
EXPECT_EQ(*RefSize, 4);

FormParams Params_4_4_32 = {4, 4, DWARF32};
RefSize = getFixedFormByteSize(DW_FORM_ref_addr, Params_4_4_32);
EXPECT_TRUE(RefSize.hasValue());
EXPECT_TRUE(RefSize.has_value());
EXPECT_EQ(*RefSize, 4);

FormParams Params_5_4_32 = {5, 4, DWARF32};
RefSize = getFixedFormByteSize(DW_FORM_ref_addr, Params_5_4_32);
EXPECT_TRUE(RefSize.hasValue());
EXPECT_TRUE(RefSize.has_value());
EXPECT_EQ(*RefSize, 4);

// DW_FORM_ref_addr is 8 bytes in DWARF 64 in DWARF version 3 and beyond.
FormParams Params_3_8_64 = {3, 8, DWARF64};
RefSize = getFixedFormByteSize(DW_FORM_ref_addr, Params_3_8_64);
EXPECT_TRUE(RefSize.hasValue());
EXPECT_TRUE(RefSize.has_value());
EXPECT_EQ(*RefSize, 8);

FormParams Params_4_8_64 = {4, 8, DWARF64};
RefSize = getFixedFormByteSize(DW_FORM_ref_addr, Params_4_8_64);
EXPECT_TRUE(RefSize.hasValue());
EXPECT_TRUE(RefSize.has_value());
EXPECT_EQ(*RefSize, 8);

FormParams Params_5_8_64 = {5, 8, DWARF64};
RefSize = getFixedFormByteSize(DW_FORM_ref_addr, Params_5_8_64);
EXPECT_TRUE(RefSize.hasValue());
EXPECT_TRUE(RefSize.has_value());
EXPECT_EQ(*RefSize, 8);
}

Expand Down
52 changes: 26 additions & 26 deletions llvm/unittests/CodeGen/GlobalISel/ConstantFoldingTest.cpp
View file
Expand Up @@ -83,156 +83,156 @@ TEST_F(AArch64GISelMITest, FoldBinOp) {
Optional<APInt> FoldGAddInt =
ConstantFoldBinOp(TargetOpcode::G_ADD, MIBCst1.getReg(0),
MIBCst2.getReg(0), *MRI);
EXPECT_TRUE(FoldGAddInt.hasValue());
EXPECT_TRUE(FoldGAddInt.has_value());
EXPECT_EQ(25ULL, FoldGAddInt.getValue().getLimitedValue());
Optional<APInt> FoldGAddMix =
ConstantFoldBinOp(TargetOpcode::G_ADD, MIBCst1.getReg(0),
MIBFCst2.getReg(0), *MRI);
EXPECT_TRUE(FoldGAddMix.hasValue());
EXPECT_TRUE(FoldGAddMix.has_value());
EXPECT_EQ(1073741840ULL, FoldGAddMix.getValue().getLimitedValue());

// Test G_AND folding Integer + Mixed Int-Float cases
Optional<APInt> FoldGAndInt =
ConstantFoldBinOp(TargetOpcode::G_AND, MIBCst1.getReg(0),
MIBCst2.getReg(0), *MRI);
EXPECT_TRUE(FoldGAndInt.hasValue());
EXPECT_TRUE(FoldGAndInt.has_value());
EXPECT_EQ(0ULL, FoldGAndInt.getValue().getLimitedValue());
Optional<APInt> FoldGAndMix =
ConstantFoldBinOp(TargetOpcode::G_AND, MIBCst2.getReg(0),
MIBFCst1.getReg(0), *MRI);
EXPECT_TRUE(FoldGAndMix.hasValue());
EXPECT_TRUE(FoldGAndMix.has_value());
EXPECT_EQ(1ULL, FoldGAndMix.getValue().getLimitedValue());

// Test G_ASHR folding Integer + Mixed cases
Optional<APInt> FoldGAShrInt =
ConstantFoldBinOp(TargetOpcode::G_ASHR, MIBCst1.getReg(0),
MIBCst2.getReg(0), *MRI);
EXPECT_TRUE(FoldGAShrInt.hasValue());
EXPECT_TRUE(FoldGAShrInt.has_value());
EXPECT_EQ(0ULL, FoldGAShrInt.getValue().getLimitedValue());
Optional<APInt> FoldGAShrMix =
ConstantFoldBinOp(TargetOpcode::G_ASHR, MIBFCst2.getReg(0),
MIBCst2.getReg(0), *MRI);
EXPECT_TRUE(FoldGAShrMix.hasValue());
EXPECT_TRUE(FoldGAShrMix.has_value());
EXPECT_EQ(2097152ULL, FoldGAShrMix.getValue().getLimitedValue());

// Test G_LSHR folding Integer + Mixed Int-Float cases
Optional<APInt> FoldGLShrInt =
ConstantFoldBinOp(TargetOpcode::G_LSHR, MIBCst1.getReg(0),
MIBCst2.getReg(0), *MRI);
EXPECT_TRUE(FoldGLShrInt.hasValue());
EXPECT_TRUE(FoldGLShrInt.has_value());
EXPECT_EQ(0ULL, FoldGLShrInt.getValue().getLimitedValue());
Optional<APInt> FoldGLShrMix =
ConstantFoldBinOp(TargetOpcode::G_LSHR, MIBFCst1.getReg(0),
MIBCst2.getReg(0), *MRI);
EXPECT_TRUE(FoldGLShrMix.hasValue());
EXPECT_TRUE(FoldGLShrMix.has_value());
EXPECT_EQ(2080768ULL, FoldGLShrMix.getValue().getLimitedValue());

// Test G_MUL folding Integer + Mixed Int-Float cases
Optional<APInt> FoldGMulInt =
ConstantFoldBinOp(TargetOpcode::G_MUL, MIBCst1.getReg(0),
MIBCst2.getReg(0), *MRI);
EXPECT_TRUE(FoldGMulInt.hasValue());
EXPECT_TRUE(FoldGMulInt.has_value());
EXPECT_EQ(144ULL, FoldGMulInt.getValue().getLimitedValue());
Optional<APInt> FoldGMulMix =
ConstantFoldBinOp(TargetOpcode::G_MUL, MIBCst1.getReg(0),
MIBFCst2.getReg(0), *MRI);
EXPECT_TRUE(FoldGMulMix.hasValue());
EXPECT_TRUE(FoldGMulMix.has_value());
EXPECT_EQ(0ULL, FoldGMulMix.getValue().getLimitedValue());

// Test G_OR folding Integer + Mixed Int-Float cases
Optional<APInt> FoldGOrInt =
ConstantFoldBinOp(TargetOpcode::G_OR, MIBCst1.getReg(0),
MIBCst2.getReg(0), *MRI);
EXPECT_TRUE(FoldGOrInt.hasValue());
EXPECT_TRUE(FoldGOrInt.has_value());
EXPECT_EQ(25ULL, FoldGOrInt.getValue().getLimitedValue());
Optional<APInt> FoldGOrMix =
ConstantFoldBinOp(TargetOpcode::G_OR, MIBCst1.getReg(0),
MIBFCst2.getReg(0), *MRI);
EXPECT_TRUE(FoldGOrMix.hasValue());
EXPECT_TRUE(FoldGOrMix.has_value());
EXPECT_EQ(1073741840ULL, FoldGOrMix.getValue().getLimitedValue());

// Test G_SHL folding Integer + Mixed Int-Float cases
Optional<APInt> FoldGShlInt =
ConstantFoldBinOp(TargetOpcode::G_SHL, MIBCst1.getReg(0),
MIBCst2.getReg(0), *MRI);
EXPECT_TRUE(FoldGShlInt.hasValue());
EXPECT_TRUE(FoldGShlInt.has_value());
EXPECT_EQ(8192ULL, FoldGShlInt.getValue().getLimitedValue());
Optional<APInt> FoldGShlMix =
ConstantFoldBinOp(TargetOpcode::G_SHL, MIBCst1.getReg(0),
MIBFCst2.getReg(0), *MRI);
EXPECT_TRUE(FoldGShlMix.hasValue());
EXPECT_TRUE(FoldGShlMix.has_value());
EXPECT_EQ(0ULL, FoldGShlMix.getValue().getLimitedValue());

// Test G_SUB folding Integer + Mixed Int-Float cases
Optional<APInt> FoldGSubInt =
ConstantFoldBinOp(TargetOpcode::G_SUB, MIBCst1.getReg(0),
MIBCst2.getReg(0), *MRI);
EXPECT_TRUE(FoldGSubInt.hasValue());
EXPECT_TRUE(FoldGSubInt.has_value());
EXPECT_EQ(7ULL, FoldGSubInt.getValue().getLimitedValue());
Optional<APInt> FoldGSubMix =
ConstantFoldBinOp(TargetOpcode::G_SUB, MIBCst1.getReg(0),
MIBFCst2.getReg(0), *MRI);
EXPECT_TRUE(FoldGSubMix.hasValue());
EXPECT_TRUE(FoldGSubMix.has_value());
EXPECT_EQ(3221225488ULL, FoldGSubMix.getValue().getLimitedValue());

// Test G_XOR folding Integer + Mixed Int-Float cases
Optional<APInt> FoldGXorInt =
ConstantFoldBinOp(TargetOpcode::G_XOR, MIBCst1.getReg(0),
MIBCst2.getReg(0), *MRI);
EXPECT_TRUE(FoldGXorInt.hasValue());
EXPECT_TRUE(FoldGXorInt.has_value());
EXPECT_EQ(25ULL, FoldGXorInt.getValue().getLimitedValue());
Optional<APInt> FoldGXorMix =
ConstantFoldBinOp(TargetOpcode::G_XOR, MIBCst1.getReg(0),
MIBFCst2.getReg(0), *MRI);
EXPECT_TRUE(FoldGXorMix.hasValue());
EXPECT_TRUE(FoldGXorMix.has_value());
EXPECT_EQ(1073741840ULL, FoldGXorMix.getValue().getLimitedValue());

// Test G_UDIV folding Integer + Mixed Int-Float cases
Optional<APInt> FoldGUdivInt =
ConstantFoldBinOp(TargetOpcode::G_UDIV, MIBCst1.getReg(0),
MIBCst2.getReg(0), *MRI);
EXPECT_TRUE(FoldGUdivInt.hasValue());
EXPECT_TRUE(FoldGUdivInt.has_value());
EXPECT_EQ(1ULL, FoldGUdivInt.getValue().getLimitedValue());
Optional<APInt> FoldGUdivMix =
ConstantFoldBinOp(TargetOpcode::G_UDIV, MIBCst1.getReg(0),
MIBFCst2.getReg(0), *MRI);
EXPECT_TRUE(FoldGUdivMix.hasValue());
EXPECT_TRUE(FoldGUdivMix.has_value());
EXPECT_EQ(0ULL, FoldGUdivMix.getValue().getLimitedValue());

// Test G_SDIV folding Integer + Mixed Int-Float cases
Optional<APInt> FoldGSdivInt =
ConstantFoldBinOp(TargetOpcode::G_SDIV, MIBCst1.getReg(0),
MIBCst2.getReg(0), *MRI);
EXPECT_TRUE(FoldGSdivInt.hasValue());
EXPECT_TRUE(FoldGSdivInt.has_value());
EXPECT_EQ(1ULL, FoldGSdivInt.getValue().getLimitedValue());
Optional<APInt> FoldGSdivMix =
ConstantFoldBinOp(TargetOpcode::G_SDIV, MIBCst1.getReg(0),
MIBFCst2.getReg(0), *MRI);
EXPECT_TRUE(FoldGSdivMix.hasValue());
EXPECT_TRUE(FoldGSdivMix.has_value());
EXPECT_EQ(0ULL, FoldGSdivMix.getValue().getLimitedValue());

// Test G_UREM folding Integer + Mixed Int-Float cases
Optional<APInt> FoldGUremInt =
ConstantFoldBinOp(TargetOpcode::G_UDIV, MIBCst1.getReg(0),
MIBCst2.getReg(0), *MRI);
EXPECT_TRUE(FoldGUremInt.hasValue());
EXPECT_TRUE(FoldGUremInt.has_value());
EXPECT_EQ(1ULL, FoldGUremInt.getValue().getLimitedValue());
Optional<APInt> FoldGUremMix =
ConstantFoldBinOp(TargetOpcode::G_UDIV, MIBCst1.getReg(0),
MIBFCst2.getReg(0), *MRI);
EXPECT_TRUE(FoldGUremMix.hasValue());
EXPECT_TRUE(FoldGUremMix.has_value());
EXPECT_EQ(0ULL, FoldGUremMix.getValue().getLimitedValue());

// Test G_SREM folding Integer + Mixed Int-Float cases
Optional<APInt> FoldGSremInt =
ConstantFoldBinOp(TargetOpcode::G_SREM, MIBCst1.getReg(0),
MIBCst2.getReg(0), *MRI);
EXPECT_TRUE(FoldGSremInt.hasValue());
EXPECT_TRUE(FoldGSremInt.has_value());
EXPECT_EQ(7ULL, FoldGSremInt.getValue().getLimitedValue());
Optional<APInt> FoldGSremMix =
ConstantFoldBinOp(TargetOpcode::G_SREM, MIBCst1.getReg(0),
MIBFCst2.getReg(0), *MRI);
EXPECT_TRUE(FoldGSremMix.hasValue());
EXPECT_TRUE(FoldGSremMix.has_value());
EXPECT_EQ(16ULL, FoldGSremMix.getValue().getLimitedValue());
}

Expand Down
14 changes: 7 additions & 7 deletions llvm/unittests/DebugInfo/DWARF/DWARFDebugFrameTest.cpp
View file
Expand Up @@ -424,31 +424,31 @@ TEST(DWARFDebugFrame, RegisterLocations) {
// Verify RegisterLocations::getRegisterLocation() works as expected.
Optional<dwarf::UnwindLocation> OptionalLoc;
OptionalLoc = Locs.getRegisterLocation(0);
EXPECT_FALSE(OptionalLoc.hasValue());
EXPECT_FALSE(OptionalLoc.has_value());

OptionalLoc = Locs.getRegisterLocation(12);
EXPECT_TRUE(OptionalLoc.hasValue());
EXPECT_TRUE(OptionalLoc.has_value());
EXPECT_EQ(*OptionalLoc, Reg12Loc);

OptionalLoc = Locs.getRegisterLocation(13);
EXPECT_TRUE(OptionalLoc.hasValue());
EXPECT_TRUE(OptionalLoc.has_value());
EXPECT_EQ(*OptionalLoc, Reg13Loc);

OptionalLoc = Locs.getRegisterLocation(14);
EXPECT_TRUE(OptionalLoc.hasValue());
EXPECT_TRUE(OptionalLoc.has_value());
EXPECT_EQ(*OptionalLoc, Reg14Loc);

// Verify registers are correctly removed when multiple exist in the list.
Locs.removeRegisterLocation(13);
EXPECT_FALSE(Locs.getRegisterLocation(13).hasValue());
EXPECT_FALSE(Locs.getRegisterLocation(13).has_value());
EXPECT_TRUE(Locs.hasLocations());
expectDumpResult(Locs, "reg12=[CFA+4], reg14=same");
Locs.removeRegisterLocation(14);
EXPECT_FALSE(Locs.getRegisterLocation(14).hasValue());
EXPECT_FALSE(Locs.getRegisterLocation(14).has_value());
EXPECT_TRUE(Locs.hasLocations());
expectDumpResult(Locs, "reg12=[CFA+4]");
Locs.removeRegisterLocation(12);
EXPECT_FALSE(Locs.getRegisterLocation(12).hasValue());
EXPECT_FALSE(Locs.getRegisterLocation(12).has_value());
EXPECT_FALSE(Locs.hasLocations());
expectDumpResult(Locs, "");
}
Expand Down

0 comments on commit 3361a36

Please sign in to comment.