mirrors/llvm-project
0
0
Fork 0
mirror of https://github.com/llvm/llvm-project.git synced 2025-04-19 13:16:46 +00:00
Code Issues Projects Releases Wiki Activity

[llvm] Use has_value instead of hasValue (NFC)

Browse Source
This commit is contained in:
Kazu Hirata 2022-07-12 22:25:42 -07:00
parent 67d760dd49
commit 3361a364e6
19 changed files with 198 additions and 196 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
llvm/include/llvm/MC/MCDwarf.h
View File

@ -374,8 +374,8 @@ public:
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(); }

10
llvm/unittests/ADT/OptionalTest.cpp
View File

@ -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};
@ -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);
@ -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);

16
llvm/unittests/ADT/StatisticTest.cpp
View File

@ -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.
@ -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);
@ -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.
@ -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);

4
llvm/unittests/Analysis/IRSimilarityIdentifierTest.cpp
View File

@ -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);

20
llvm/unittests/BinaryFormat/DwarfTest.cpp
View File

@ -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);
}

52
llvm/unittests/CodeGen/GlobalISel/ConstantFoldingTest.cpp
View File

@ -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());
}

14
llvm/unittests/DebugInfo/DWARF/DWARFDebugFrameTest.cpp
View File

@ -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, "");
}

102
llvm/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp
View File

@ -252,7 +252,7 @@ void TestAllForms() {
FormValue = DieDG.find(Attr_DW_FORM_block);
EXPECT_TRUE((bool)FormValue);
BlockDataOpt = FormValue->getAsBlock();
EXPECT_TRUE(BlockDataOpt.hasValue());
EXPECT_TRUE(BlockDataOpt.has_value());
ExtractedBlockData = BlockDataOpt.getValue();
EXPECT_EQ(ExtractedBlockData.size(), BlockSize);
EXPECT_TRUE(memcmp(ExtractedBlockData.data(), BlockData, BlockSize) == 0);
@ -260,7 +260,7 @@ void TestAllForms() {
FormValue = DieDG.find(Attr_DW_FORM_block1);
EXPECT_TRUE((bool)FormValue);
BlockDataOpt = FormValue->getAsBlock();
EXPECT_TRUE(BlockDataOpt.hasValue());
EXPECT_TRUE(BlockDataOpt.has_value());
ExtractedBlockData = BlockDataOpt.getValue();
EXPECT_EQ(ExtractedBlockData.size(), BlockSize);
EXPECT_TRUE(memcmp(ExtractedBlockData.data(), BlockData, BlockSize) == 0);
@ -268,7 +268,7 @@ void TestAllForms() {
FormValue = DieDG.find(Attr_DW_FORM_block2);
EXPECT_TRUE((bool)FormValue);
BlockDataOpt = FormValue->getAsBlock();
EXPECT_TRUE(BlockDataOpt.hasValue());
EXPECT_TRUE(BlockDataOpt.has_value());
ExtractedBlockData = BlockDataOpt.getValue();
EXPECT_EQ(ExtractedBlockData.size(), BlockSize);
EXPECT_TRUE(memcmp(ExtractedBlockData.data(), BlockData, BlockSize) == 0);
@ -276,7 +276,7 @@ void TestAllForms() {
FormValue = DieDG.find(Attr_DW_FORM_block4);
EXPECT_TRUE((bool)FormValue);
BlockDataOpt = FormValue->getAsBlock();
EXPECT_TRUE(BlockDataOpt.hasValue());
EXPECT_TRUE(BlockDataOpt.has_value());
ExtractedBlockData = BlockDataOpt.getValue();
EXPECT_EQ(ExtractedBlockData.size(), BlockSize);
EXPECT_TRUE(memcmp(ExtractedBlockData.data(), BlockData, BlockSize) == 0);
@ -286,7 +286,7 @@ void TestAllForms() {
FormValue = DieDG.find(Attr_DW_FORM_data16);
EXPECT_TRUE((bool)FormValue);
BlockDataOpt = FormValue->getAsBlock();
EXPECT_TRUE(BlockDataOpt.hasValue());
EXPECT_TRUE(BlockDataOpt.has_value());
ExtractedBlockData = BlockDataOpt.getValue();
EXPECT_EQ(ExtractedBlockData.size(), 16u);
EXPECT_TRUE(memcmp(ExtractedBlockData.data(), Data16, 16) == 0);
@ -1638,13 +1638,13 @@ TEST(DWARFDebugInfo, TestDwarfToFunctions) {
// First test that we don't get valid values back when using an optional with
// no value.
Optional<DWARFFormValue> FormValOpt1 = DWARFFormValue();
EXPECT_FALSE(toString(FormValOpt1).hasValue());
EXPECT_FALSE(toUnsigned(FormValOpt1).hasValue());
EXPECT_FALSE(toReference(FormValOpt1).hasValue());
EXPECT_FALSE(toSigned(FormValOpt1).hasValue());
EXPECT_FALSE(toAddress(FormValOpt1).hasValue());
EXPECT_FALSE(toSectionOffset(FormValOpt1).hasValue());
EXPECT_FALSE(toBlock(FormValOpt1).hasValue());
EXPECT_FALSE(toString(FormValOpt1).has_value());
EXPECT_FALSE(toUnsigned(FormValOpt1).has_value());
EXPECT_FALSE(toReference(FormValOpt1).has_value());
EXPECT_FALSE(toSigned(FormValOpt1).has_value());
EXPECT_FALSE(toAddress(FormValOpt1).has_value());
EXPECT_FALSE(toSectionOffset(FormValOpt1).has_value());
EXPECT_FALSE(toBlock(FormValOpt1).has_value());
EXPECT_EQ(nullptr, toString(FormValOpt1, nullptr));
EXPECT_EQ(InvalidU64, toUnsigned(FormValOpt1, InvalidU64));
EXPECT_EQ(InvalidU64, toReference(FormValOpt1, InvalidU64));
@ -1657,13 +1657,13 @@ TEST(DWARFDebugInfo, TestDwarfToFunctions) {
Optional<DWARFFormValue> FormValOpt2 =
DWARFFormValue::createFromUValue(DW_FORM_addr, Address);
EXPECT_FALSE(toString(FormValOpt2).hasValue());
EXPECT_FALSE(toUnsigned(FormValOpt2).hasValue());
EXPECT_FALSE(toReference(FormValOpt2).hasValue());
EXPECT_FALSE(toSigned(FormValOpt2).hasValue());
EXPECT_TRUE(toAddress(FormValOpt2).hasValue());
EXPECT_FALSE(toSectionOffset(FormValOpt2).hasValue());
EXPECT_FALSE(toBlock(FormValOpt2).hasValue());
EXPECT_FALSE(toString(FormValOpt2).has_value());
EXPECT_FALSE(toUnsigned(FormValOpt2).has_value());
EXPECT_FALSE(toReference(FormValOpt2).has_value());
EXPECT_FALSE(toSigned(FormValOpt2).has_value());
EXPECT_TRUE(toAddress(FormValOpt2).has_value());
EXPECT_FALSE(toSectionOffset(FormValOpt2).has_value());
EXPECT_FALSE(toBlock(FormValOpt2).has_value());
EXPECT_EQ(nullptr, toString(FormValOpt2, nullptr));
EXPECT_EQ(InvalidU64, toUnsigned(FormValOpt2, InvalidU64));
EXPECT_EQ(InvalidU64, toReference(FormValOpt2, InvalidU64));
@ -1676,13 +1676,13 @@ TEST(DWARFDebugInfo, TestDwarfToFunctions) {
Optional<DWARFFormValue> FormValOpt3 =
DWARFFormValue::createFromUValue(DW_FORM_udata, UData8);
EXPECT_FALSE(toString(FormValOpt3).hasValue());
EXPECT_TRUE(toUnsigned(FormValOpt3).hasValue());
EXPECT_FALSE(toReference(FormValOpt3).hasValue());
EXPECT_TRUE(toSigned(FormValOpt3).hasValue());
EXPECT_FALSE(toAddress(FormValOpt3).hasValue());
EXPECT_FALSE(toSectionOffset(FormValOpt3).hasValue());
EXPECT_FALSE(toBlock(FormValOpt3).hasValue());
EXPECT_FALSE(toString(FormValOpt3).has_value());
EXPECT_TRUE(toUnsigned(FormValOpt3).has_value());
EXPECT_FALSE(toReference(FormValOpt3).has_value());
EXPECT_TRUE(toSigned(FormValOpt3).has_value());
EXPECT_FALSE(toAddress(FormValOpt3).has_value());
EXPECT_FALSE(toSectionOffset(FormValOpt3).has_value());
EXPECT_FALSE(toBlock(FormValOpt3).has_value());
EXPECT_EQ(nullptr, toString(FormValOpt3, nullptr));
EXPECT_EQ(UData8, toUnsigned(FormValOpt3, InvalidU64));
EXPECT_EQ(InvalidU64, toReference(FormValOpt3, InvalidU64));
@ -1695,13 +1695,13 @@ TEST(DWARFDebugInfo, TestDwarfToFunctions) {
Optional<DWARFFormValue> FormValOpt4 =
DWARFFormValue::createFromUValue(DW_FORM_ref_addr, RefData);
EXPECT_FALSE(toString(FormValOpt4).hasValue());
EXPECT_FALSE(toUnsigned(FormValOpt4).hasValue());
EXPECT_TRUE(toReference(FormValOpt4).hasValue());
EXPECT_FALSE(toSigned(FormValOpt4).hasValue());
EXPECT_FALSE(toAddress(FormValOpt4).hasValue());
EXPECT_FALSE(toSectionOffset(FormValOpt4).hasValue());
EXPECT_FALSE(toBlock(FormValOpt4).hasValue());
EXPECT_FALSE(toString(FormValOpt4).has_value());
EXPECT_FALSE(toUnsigned(FormValOpt4).has_value());
EXPECT_TRUE(toReference(FormValOpt4).has_value());
EXPECT_FALSE(toSigned(FormValOpt4).has_value());
EXPECT_FALSE(toAddress(FormValOpt4).has_value());
EXPECT_FALSE(toSectionOffset(FormValOpt4).has_value());
EXPECT_FALSE(toBlock(FormValOpt4).has_value());
EXPECT_EQ(nullptr, toString(FormValOpt4, nullptr));
EXPECT_EQ(InvalidU64, toUnsigned(FormValOpt4, InvalidU64));
EXPECT_EQ(RefData, toReference(FormValOpt4, InvalidU64));
@ -1714,13 +1714,13 @@ TEST(DWARFDebugInfo, TestDwarfToFunctions) {
Optional<DWARFFormValue> FormValOpt5 =
DWARFFormValue::createFromSValue(DW_FORM_udata, SData8);
EXPECT_FALSE(toString(FormValOpt5).hasValue());
EXPECT_TRUE(toUnsigned(FormValOpt5).hasValue());
EXPECT_FALSE(toReference(FormValOpt5).hasValue());
EXPECT_TRUE(toSigned(FormValOpt5).hasValue());
EXPECT_FALSE(toAddress(FormValOpt5).hasValue());
EXPECT_FALSE(toSectionOffset(FormValOpt5).hasValue());
EXPECT_FALSE(toBlock(FormValOpt5).hasValue());
EXPECT_FALSE(toString(FormValOpt5).has_value());
EXPECT_TRUE(toUnsigned(FormValOpt5).has_value());
EXPECT_FALSE(toReference(FormValOpt5).has_value());
EXPECT_TRUE(toSigned(FormValOpt5).has_value());
EXPECT_FALSE(toAddress(FormValOpt5).has_value());
EXPECT_FALSE(toSectionOffset(FormValOpt5).has_value());
EXPECT_FALSE(toBlock(FormValOpt5).has_value());
EXPECT_EQ(nullptr, toString(FormValOpt5, nullptr));
EXPECT_EQ((uint64_t)SData8, toUnsigned(FormValOpt5, InvalidU64));
EXPECT_EQ(InvalidU64, toReference(FormValOpt5, InvalidU64));
@ -1734,14 +1734,14 @@ TEST(DWARFDebugInfo, TestDwarfToFunctions) {
Optional<DWARFFormValue> FormValOpt6 =
DWARFFormValue::createFromBlockValue(DW_FORM_block1, Array);
EXPECT_FALSE(toString(FormValOpt6).hasValue());
EXPECT_FALSE(toUnsigned(FormValOpt6).hasValue());
EXPECT_FALSE(toReference(FormValOpt6).hasValue());
EXPECT_FALSE(toSigned(FormValOpt6).hasValue());
EXPECT_FALSE(toAddress(FormValOpt6).hasValue());
EXPECT_FALSE(toSectionOffset(FormValOpt6).hasValue());
EXPECT_FALSE(toString(FormValOpt6).has_value());
EXPECT_FALSE(toUnsigned(FormValOpt6).has_value());
EXPECT_FALSE(toReference(FormValOpt6).has_value());
EXPECT_FALSE(toSigned(FormValOpt6).has_value());
EXPECT_FALSE(toAddress(FormValOpt6).has_value());
EXPECT_FALSE(toSectionOffset(FormValOpt6).has_value());
auto BlockOpt = toBlock(FormValOpt6);
EXPECT_TRUE(BlockOpt.hasValue());
EXPECT_TRUE(BlockOpt.has_value());
EXPECT_EQ(*BlockOpt, Array);
EXPECT_EQ(nullptr, toString(FormValOpt6, nullptr));
EXPECT_EQ(InvalidU64, toUnsigned(FormValOpt6, InvalidU64));
@ -1799,24 +1799,24 @@ TEST(DWARFDebugInfo, TestFindAttrs) {
auto FuncDie = FuncSpecDie.getSibling();
// Make sure that passing in an empty attribute list behave correctly.
EXPECT_FALSE(FuncDie.find(ArrayRef<dwarf::Attribute>()).hasValue());
EXPECT_FALSE(FuncDie.find(ArrayRef<dwarf::Attribute>()).has_value());
// Make sure that passing in a list of attribute that are not contained
// in the DIE returns nothing.
EXPECT_FALSE(FuncDie.find({DW_AT_low_pc, DW_AT_entry_pc}).hasValue());
EXPECT_FALSE(FuncDie.find({DW_AT_low_pc, DW_AT_entry_pc}).has_value());
const dwarf::Attribute Attrs[] = {DW_AT_linkage_name,
DW_AT_MIPS_linkage_name};
// Make sure we can't extract the linkage name attributes when using
// DWARFDie::find() since it won't check the DW_AT_specification DIE.
EXPECT_FALSE(FuncDie.find(Attrs).hasValue());
EXPECT_FALSE(FuncDie.find(Attrs).has_value());
// Make sure we can extract the name from the specification die when using
// DWARFDie::findRecursively() since it should recurse through the
// DW_AT_specification DIE.
auto NameOpt = FuncDie.findRecursively(Attrs);
EXPECT_TRUE(NameOpt.hasValue());
EXPECT_TRUE(NameOpt.has_value());
EXPECT_EQ(DieMangled, toString(NameOpt, ""));
}

2
llvm/unittests/DebugInfo/DWARF/DWARFFormValueTest.cpp
View File

@ -89,7 +89,7 @@ TEST(DWARFFormValue, SignedConstantForms) {
auto UMax = createULEBFormValue(LLONG_MAX);
auto TooBig = createULEBFormValue(uint64_t(LLONG_MAX) + 1);
EXPECT_EQ(UMax.getAsSignedConstant().getValue(), LLONG_MAX);
EXPECT_EQ(TooBig.getAsSignedConstant().hasValue(), false);
EXPECT_EQ(TooBig.getAsSignedConstant().has_value(), false);
// Sanity check some other forms.
auto Data1 = createDataXFormValue<uint8_t>(DW_FORM_data1, 120);

28
llvm/unittests/DebugInfo/GSYM/GSYMTest.cpp
View File

@ -1349,8 +1349,8 @@ TEST(GSYMTest, TestDWARFFunctionWithAddresses) {
auto ExpFI = GR->getFunctionInfo(0x1000);
ASSERT_THAT_EXPECTED(ExpFI, Succeeded());
ASSERT_EQ(ExpFI->Range, AddressRange(0x1000, 0x2000));
EXPECT_FALSE(ExpFI->OptLineTable.hasValue());
EXPECT_FALSE(ExpFI->Inline.hasValue());
EXPECT_FALSE(ExpFI->OptLineTable.has_value());
EXPECT_FALSE(ExpFI->Inline.has_value());
}
TEST(GSYMTest, TestDWARFFunctionWithAddressAndOffset) {
@ -1426,8 +1426,8 @@ TEST(GSYMTest, TestDWARFFunctionWithAddressAndOffset) {
auto ExpFI = GR->getFunctionInfo(0x1000);
ASSERT_THAT_EXPECTED(ExpFI, Succeeded());
ASSERT_EQ(ExpFI->Range, AddressRange(0x1000, 0x2000));
EXPECT_FALSE(ExpFI->OptLineTable.hasValue());
EXPECT_FALSE(ExpFI->Inline.hasValue());
EXPECT_FALSE(ExpFI->OptLineTable.has_value());
EXPECT_FALSE(ExpFI->Inline.has_value());
}
TEST(GSYMTest, TestDWARFStructMethodNoMangled) {
@ -1533,8 +1533,8 @@ TEST(GSYMTest, TestDWARFStructMethodNoMangled) {
auto ExpFI = GR->getFunctionInfo(0x1000);
ASSERT_THAT_EXPECTED(ExpFI, Succeeded());
ASSERT_EQ(ExpFI->Range, AddressRange(0x1000, 0x2000));
EXPECT_FALSE(ExpFI->OptLineTable.hasValue());
EXPECT_FALSE(ExpFI->Inline.hasValue());
EXPECT_FALSE(ExpFI->OptLineTable.has_value());
EXPECT_FALSE(ExpFI->Inline.has_value());
StringRef MethodName = GR->getString(ExpFI->Name);
EXPECT_EQ(MethodName, "Foo::dump");
}
@ -1638,8 +1638,8 @@ TEST(GSYMTest, TestDWARFTextRanges) {
auto ExpFI = GR->getFunctionInfo(0x1000);
ASSERT_THAT_EXPECTED(ExpFI, Succeeded());
ASSERT_EQ(ExpFI->Range, AddressRange(0x1000, 0x2000));
EXPECT_FALSE(ExpFI->OptLineTable.hasValue());
EXPECT_FALSE(ExpFI->Inline.hasValue());
EXPECT_FALSE(ExpFI->OptLineTable.has_value());
EXPECT_FALSE(ExpFI->Inline.has_value());
StringRef MethodName = GR->getString(ExpFI->Name);
EXPECT_EQ(MethodName, "main");
}
@ -1667,8 +1667,8 @@ TEST(GSYMTest, TestEmptySymbolEndAddressOfTextRanges) {
auto ExpFI = GR->getFunctionInfo(0x1500);
ASSERT_THAT_EXPECTED(ExpFI, Succeeded());
ASSERT_EQ(ExpFI->Range, AddressRange(0x1500, 0x2000));
EXPECT_FALSE(ExpFI->OptLineTable.hasValue());
EXPECT_FALSE(ExpFI->Inline.hasValue());
EXPECT_FALSE(ExpFI->OptLineTable.has_value());
EXPECT_FALSE(ExpFI->Inline.has_value());
StringRef MethodName = GR->getString(ExpFI->Name);
EXPECT_EQ(MethodName, "symbol");
}
@ -1836,8 +1836,8 @@ TEST(GSYMTest, TestDWARFInlineInfo) {
auto ExpFI = GR->getFunctionInfo(0x1000);
ASSERT_THAT_EXPECTED(ExpFI, Succeeded());
ASSERT_EQ(ExpFI->Range, AddressRange(0x1000, 0x2000));
EXPECT_TRUE(ExpFI->OptLineTable.hasValue());
EXPECT_TRUE(ExpFI->Inline.hasValue());
EXPECT_TRUE(ExpFI->OptLineTable.has_value());
EXPECT_TRUE(ExpFI->Inline.has_value());
StringRef MethodName = GR->getString(ExpFI->Name);
EXPECT_EQ(MethodName, "main");
@ -2122,14 +2122,14 @@ TEST(GSYMTest, TestDWARFNoLines) {
ASSERT_THAT_EXPECTED(ExpFI, Succeeded());
ASSERT_EQ(ExpFI->Range, AddressRange(0x3000, 0x4000));
// Make sure we have no line table.
EXPECT_FALSE(ExpFI->OptLineTable.hasValue());
EXPECT_FALSE(ExpFI->OptLineTable.has_value());
MethodName = GR->getString(ExpFI->Name);
EXPECT_EQ(MethodName, "no_lines_no_decl");
ExpFI = GR->getFunctionInfo(0x4000);
ASSERT_THAT_EXPECTED(ExpFI, Succeeded());
ASSERT_EQ(ExpFI->Range, AddressRange(0x4000, 0x5000));
EXPECT_TRUE(ExpFI->OptLineTable.hasValue());
EXPECT_TRUE(ExpFI->OptLineTable.has_value());
MethodName = GR->getString(ExpFI->Name);
EXPECT_EQ(MethodName, "no_lines_with_decl");
// Make sure we have one line table entry that uses the DW_AT_decl_file/line

24
llvm/unittests/IR/MetadataTest.cpp
View File

@ -2933,22 +2933,24 @@ TEST_F(DIExpressionTest, createFragmentExpression) {
#define EXPECT_VALID_FRAGMENT(Offset, Size, ...) \
do { \
uint64_t Elements[] = {__VA_ARGS__}; \
DIExpression* Expression = DIExpression::get(Context, Elements); \
EXPECT_TRUE(DIExpression::createFragmentExpression( \
Expression, Offset, Size).hasValue()); \
DIExpression *Expression = DIExpression::get(Context, Elements); \
EXPECT_TRUE( \
DIExpression::createFragmentExpression(Expression, Offset, Size) \
.has_value()); \
} while (false)
#define EXPECT_INVALID_FRAGMENT(Offset, Size, ...) \
do { \
uint64_t Elements[] = {__VA_ARGS__}; \
DIExpression* Expression = DIExpression::get(Context, Elements); \
EXPECT_FALSE(DIExpression::createFragmentExpression( \
Expression, Offset, Size).hasValue()); \
DIExpression *Expression = DIExpression::get(Context, Elements); \
EXPECT_FALSE( \
DIExpression::createFragmentExpression(Expression, Offset, Size) \
.has_value()); \
} while (false)
// createFragmentExpression adds correct ops.
Optional<DIExpression*> R = DIExpression::createFragmentExpression(
DIExpression::get(Context, {}), 0, 32);
EXPECT_EQ(R.hasValue(), true);
EXPECT_EQ(R.has_value(), true);
EXPECT_EQ(3u, (*R)->getNumElements());
EXPECT_EQ(dwarf::DW_OP_LLVM_fragment, (*R)->getElement(0));
EXPECT_EQ(0u, (*R)->getElement(1));
@ -3455,20 +3457,20 @@ TEST_F(FunctionAttachmentTest, Verifier) {
TEST_F(FunctionAttachmentTest, RealEntryCount) {
Function *F = getFunction("foo");
EXPECT_FALSE(F->getEntryCount().hasValue());
EXPECT_FALSE(F->getEntryCount().has_value());
F->setEntryCount(12304, Function::PCT_Real);
auto Count = F->getEntryCount();
EXPECT_TRUE(Count.hasValue());
EXPECT_TRUE(Count.has_value());
EXPECT_EQ(12304u, Count->getCount());
EXPECT_EQ(Function::PCT_Real, Count->getType());
}
TEST_F(FunctionAttachmentTest, SyntheticEntryCount) {
Function *F = getFunction("bar");
EXPECT_FALSE(F->getEntryCount().hasValue());
EXPECT_FALSE(F->getEntryCount().has_value());
F->setEntryCount(123, Function::PCT_Synthetic);
auto Count = F->getEntryCount(true /*allow synthetic*/);
EXPECT_TRUE(Count.hasValue());
EXPECT_TRUE(Count.has_value());
EXPECT_EQ(123u, Count->getCount());
EXPECT_EQ(Function::PCT_Synthetic, Count->getType());
}

20
llvm/unittests/IR/VPIntrinsicTest.cpp
View File

@ -128,25 +128,25 @@ protected:
TEST_F(VPIntrinsicTest, VPIntrinsicsDefScopes) {
Optional<Intrinsic::ID> ScopeVPID;
#define BEGIN_REGISTER_VP_INTRINSIC(VPID, ...) \
ASSERT_FALSE(ScopeVPID.hasValue()); \
ASSERT_FALSE(ScopeVPID.has_value()); \
ScopeVPID = Intrinsic::VPID;
#define END_REGISTER_VP_INTRINSIC(VPID) \
ASSERT_TRUE(ScopeVPID.hasValue()); \
ASSERT_TRUE(ScopeVPID.has_value()); \
ASSERT_EQ(ScopeVPID.getValue(), Intrinsic::VPID); \
ScopeVPID = None;
Optional<ISD::NodeType> ScopeOPC;
#define BEGIN_REGISTER_VP_SDNODE(SDOPC, ...) \
ASSERT_FALSE(ScopeOPC.hasValue()); \
ASSERT_FALSE(ScopeOPC.has_value()); \
ScopeOPC = ISD::SDOPC;
#define END_REGISTER_VP_SDNODE(SDOPC) \
ASSERT_TRUE(ScopeOPC.hasValue()); \
ASSERT_TRUE(ScopeOPC.has_value()); \
ASSERT_EQ(ScopeOPC.getValue(), ISD::SDOPC); \
ScopeOPC = None;
#include "llvm/IR/VPIntrinsics.def"
ASSERT_FALSE(ScopeVPID.hasValue());
ASSERT_FALSE(ScopeOPC.hasValue());
ASSERT_FALSE(ScopeVPID.has_value());
ASSERT_FALSE(ScopeOPC.has_value());
}
/// Check that every VP intrinsic in the test module is recognized as a VP
@ -406,13 +406,13 @@ TEST_F(VPIntrinsicTest, VPReductions) {
if (!VPReductionIntrinsic::isVPReduction(ID)) {
EXPECT_EQ(VPRedI, nullptr);
EXPECT_EQ(VPReductionIntrinsic::getStartParamPos(ID).hasValue(), false);
EXPECT_EQ(VPReductionIntrinsic::getVectorParamPos(ID).hasValue(), false);
EXPECT_EQ(VPReductionIntrinsic::getStartParamPos(ID).has_value(), false);
EXPECT_EQ(VPReductionIntrinsic::getVectorParamPos(ID).has_value(), false);
continue;
}
EXPECT_EQ(VPReductionIntrinsic::getStartParamPos(ID).hasValue(), true);
EXPECT_EQ(VPReductionIntrinsic::getVectorParamPos(ID).hasValue(), true);
EXPECT_EQ(VPReductionIntrinsic::getStartParamPos(ID).has_value(), true);
EXPECT_EQ(VPReductionIntrinsic::getVectorParamPos(ID).has_value(), true);
ASSERT_NE(VPRedI, nullptr);
EXPECT_EQ(VPReductionIntrinsic::getStartParamPos(ID),
VPRedI->getStartParamPos());

14
llvm/unittests/InterfaceStub/ELFYAMLTest.cpp
View File

@ -47,8 +47,8 @@ TEST(ElfYamlTextAPI, YAMLReadableTBE) {
ASSERT_THAT_ERROR(StubOrErr.takeError(), Succeeded());
std::unique_ptr<IFSStub> Stub = std::move(StubOrErr.get());
EXPECT_NE(Stub.get(), nullptr);
EXPECT_FALSE(Stub->SoName.hasValue());
EXPECT_TRUE(Stub->Target.Arch.hasValue());
EXPECT_FALSE(Stub->SoName.has_value());
EXPECT_TRUE(Stub->Target.Arch.has_value());
EXPECT_EQ(Stub->Target.Arch.getValue(), (uint16_t)llvm::ELF::EM_X86_64);
EXPECT_EQ(Stub->NeededLibs.size(), 3u);
EXPECT_STREQ(Stub->NeededLibs[0].c_str(), "libc.so");
@ -94,24 +94,24 @@ TEST(ElfYamlTextAPI, YAMLReadsTBESymbols) {
EXPECT_EQ(SymBaz.Type, IFSSymbolType::TLS);
EXPECT_FALSE(SymBaz.Undefined);
EXPECT_FALSE(SymBaz.Weak);
EXPECT_FALSE(SymBaz.Warning.hasValue());
EXPECT_FALSE(SymBaz.Warning.has_value());
IFSSymbol const &SymFoo = *Iterator++;
EXPECT_STREQ(SymFoo.Name.c_str(), "foo");
EXPECT_FALSE(SymFoo.Size.hasValue());
EXPECT_FALSE(SymFoo.Size.has_value());
EXPECT_EQ(SymFoo.Type, IFSSymbolType::Func);
EXPECT_FALSE(SymFoo.Undefined);
EXPECT_FALSE(SymFoo.Weak);
EXPECT_TRUE(SymFoo.Warning.hasValue());
EXPECT_TRUE(SymFoo.Warning.has_value());
EXPECT_STREQ(SymFoo.Warning->c_str(), "Deprecated!");
IFSSymbol const &SymNor = *Iterator++;
EXPECT_STREQ(SymNor.Name.c_str(), "nor");
EXPECT_FALSE(SymNor.Size.hasValue());
EXPECT_FALSE(SymNor.Size.has_value());
EXPECT_EQ(SymNor.Type, IFSSymbolType::NoType);
EXPECT_TRUE(SymNor.Undefined);
EXPECT_FALSE(SymNor.Weak);
EXPECT_FALSE(SymNor.Warning.hasValue());
EXPECT_FALSE(SymNor.Warning.has_value());
IFSSymbol const &SymNot = *Iterator++;
EXPECT_STREQ(SymNot.Name.c_str(), "not");

8
llvm/unittests/ObjectYAML/DWARFYAMLTest.cpp
View File

@ -91,7 +91,7 @@ debug_pubtypes:
DWARFYAML::Data Data;
ASSERT_THAT_ERROR(parseDWARFYAML(Yaml, Data), Succeeded());
ASSERT_TRUE(Data.PubNames.hasValue());
ASSERT_TRUE(Data.PubNames.has_value());
DWARFYAML::PubSection PubNames = Data.PubNames.getValue();
ASSERT_EQ(PubNames.Entries.size(), 2u);
@ -100,7 +100,7 @@ debug_pubtypes:
EXPECT_EQ((uint32_t)PubNames.Entries[1].DieOffset, 0x4321u);
EXPECT_EQ(PubNames.Entries[1].Name, "def");
ASSERT_TRUE(Data.PubTypes.hasValue());
ASSERT_TRUE(Data.PubTypes.has_value());
DWARFYAML::PubSection PubTypes = Data.PubTypes.getValue();
ASSERT_EQ(PubTypes.Entries.size(), 2u);
@ -157,7 +157,7 @@ debug_gnu_pubtypes:
DWARFYAML::Data Data;
ASSERT_THAT_ERROR(parseDWARFYAML(Yaml, Data), Succeeded());
ASSERT_TRUE(Data.GNUPubNames.hasValue());
ASSERT_TRUE(Data.GNUPubNames.has_value());
DWARFYAML::PubSection GNUPubNames = Data.GNUPubNames.getValue();
ASSERT_EQ(GNUPubNames.Entries.size(), 2u);
@ -168,7 +168,7 @@ debug_gnu_pubtypes:
EXPECT_EQ((uint8_t)GNUPubNames.Entries[1].Descriptor, 0x34);
EXPECT_EQ(GNUPubNames.Entries[1].Name, "def");
ASSERT_TRUE(Data.GNUPubTypes.hasValue());
ASSERT_TRUE(Data.GNUPubTypes.has_value());
DWARFYAML::PubSection GNUPubTypes = Data.GNUPubTypes.getValue();
ASSERT_EQ(GNUPubTypes.Entries.size(), 2u);

6
llvm/unittests/Support/AlignmentTest.cpp
View File

@ -63,11 +63,11 @@ TEST(AlignmentTest, ValidCTors) {
TEST(AlignmentTest, CheckMaybeAlignHasValue) {
EXPECT_TRUE(MaybeAlign(1));
EXPECT_TRUE(MaybeAlign(1).hasValue());
EXPECT_TRUE(MaybeAlign(1).has_value());
EXPECT_FALSE(MaybeAlign(0));
EXPECT_FALSE(MaybeAlign(0).hasValue());
EXPECT_FALSE(MaybeAlign(0).has_value());
EXPECT_FALSE(MaybeAlign());
EXPECT_FALSE(MaybeAlign().hasValue());
EXPECT_FALSE(MaybeAlign().has_value());
}
TEST(AlignmentTest, Division) {

4
llvm/unittests/Support/Casting.cpp
View File

@ -248,11 +248,11 @@ TEST(CastingTest, dyn_cast_value_types) {
TEST(CastingTest, dyn_cast_if_present) {
Optional<T1> empty{};
Optional<T2> F1 = dyn_cast_if_present<T2>(empty);
EXPECT_FALSE(F1.hasValue());
EXPECT_FALSE(F1.has_value());
T1 t1;
Optional<T2> F2 = dyn_cast_if_present<T2>(t1);
EXPECT_TRUE(F2.hasValue());
EXPECT_TRUE(F2.has_value());
T1 *t1Null = nullptr;

60
llvm/unittests/Support/KnownBitsTest.cpp
View File

@ -358,38 +358,38 @@ TEST(KnownBitsTest, ICmpExhaustive) {
Optional<bool> KnownSLT = KnownBits::slt(Known1, Known2);
Optional<bool> KnownSLE = KnownBits::sle(Known1, Known2);
EXPECT_EQ(AllEQ || NoneEQ, KnownEQ.hasValue());
EXPECT_EQ(AllNE || NoneNE, KnownNE.hasValue());
EXPECT_EQ(AllUGT || NoneUGT, KnownUGT.hasValue());
EXPECT_EQ(AllUGE || NoneUGE, KnownUGE.hasValue());
EXPECT_EQ(AllULT || NoneULT, KnownULT.hasValue());
EXPECT_EQ(AllULE || NoneULE, KnownULE.hasValue());
EXPECT_EQ(AllSGT || NoneSGT, KnownSGT.hasValue());
EXPECT_EQ(AllSGE || NoneSGE, KnownSGE.hasValue());
EXPECT_EQ(AllSLT || NoneSLT, KnownSLT.hasValue());
EXPECT_EQ(AllSLE || NoneSLE, KnownSLE.hasValue());
EXPECT_EQ(AllEQ || NoneEQ, KnownEQ.has_value());
EXPECT_EQ(AllNE || NoneNE, KnownNE.has_value());
EXPECT_EQ(AllUGT || NoneUGT, KnownUGT.has_value());
EXPECT_EQ(AllUGE || NoneUGE, KnownUGE.has_value());
EXPECT_EQ(AllULT || NoneULT, KnownULT.has_value());
EXPECT_EQ(AllULE || NoneULE, KnownULE.has_value());
EXPECT_EQ(AllSGT || NoneSGT, KnownSGT.has_value());
EXPECT_EQ(AllSGE || NoneSGE, KnownSGE.has_value());
EXPECT_EQ(AllSLT || NoneSLT, KnownSLT.has_value());
EXPECT_EQ(AllSLE || NoneSLE, KnownSLE.has_value());
EXPECT_EQ(AllEQ, KnownEQ.hasValue() && KnownEQ.getValue());
EXPECT_EQ(AllNE, KnownNE.hasValue() && KnownNE.getValue());
EXPECT_EQ(AllUGT, KnownUGT.hasValue() && KnownUGT.getValue());
EXPECT_EQ(AllUGE, KnownUGE.hasValue() && KnownUGE.getValue());
EXPECT_EQ(AllULT, KnownULT.hasValue() && KnownULT.getValue());
EXPECT_EQ(AllULE, KnownULE.hasValue() && KnownULE.getValue());
EXPECT_EQ(AllSGT, KnownSGT.hasValue() && KnownSGT.getValue());
EXPECT_EQ(AllSGE, KnownSGE.hasValue() && KnownSGE.getValue());
EXPECT_EQ(AllSLT, KnownSLT.hasValue() && KnownSLT.getValue());
EXPECT_EQ(AllSLE, KnownSLE.hasValue() && KnownSLE.getValue());
EXPECT_EQ(AllEQ, KnownEQ.has_value() && KnownEQ.getValue());
EXPECT_EQ(AllNE, KnownNE.has_value() && KnownNE.getValue());
EXPECT_EQ(AllUGT, KnownUGT.has_value() && KnownUGT.getValue());
EXPECT_EQ(AllUGE, KnownUGE.has_value() && KnownUGE.getValue());
EXPECT_EQ(AllULT, KnownULT.has_value() && KnownULT.getValue());
EXPECT_EQ(AllULE, KnownULE.has_value() && KnownULE.getValue());
EXPECT_EQ(AllSGT, KnownSGT.has_value() && KnownSGT.getValue());
EXPECT_EQ(AllSGE, KnownSGE.has_value() && KnownSGE.getValue());
EXPECT_EQ(AllSLT, KnownSLT.has_value() && KnownSLT.getValue());
EXPECT_EQ(AllSLE, KnownSLE.has_value() && KnownSLE.getValue());
EXPECT_EQ(NoneEQ, KnownEQ.hasValue() && !KnownEQ.getValue());
EXPECT_EQ(NoneNE, KnownNE.hasValue() && !KnownNE.getValue());
EXPECT_EQ(NoneUGT, KnownUGT.hasValue() && !KnownUGT.getValue());
EXPECT_EQ(NoneUGE, KnownUGE.hasValue() && !KnownUGE.getValue());
EXPECT_EQ(NoneULT, KnownULT.hasValue() && !KnownULT.getValue());
EXPECT_EQ(NoneULE, KnownULE.hasValue() && !KnownULE.getValue());
EXPECT_EQ(NoneSGT, KnownSGT.hasValue() && !KnownSGT.getValue());
EXPECT_EQ(NoneSGE, KnownSGE.hasValue() && !KnownSGE.getValue());
EXPECT_EQ(NoneSLT, KnownSLT.hasValue() && !KnownSLT.getValue());
EXPECT_EQ(NoneSLE, KnownSLE.hasValue() && !KnownSLE.getValue());
EXPECT_EQ(NoneEQ, KnownEQ.has_value() && !KnownEQ.getValue());
EXPECT_EQ(NoneNE, KnownNE.has_value() && !KnownNE.getValue());
EXPECT_EQ(NoneUGT, KnownUGT.has_value() && !KnownUGT.getValue());
EXPECT_EQ(NoneUGE, KnownUGE.has_value() && !KnownUGE.getValue());
EXPECT_EQ(NoneULT, KnownULT.has_value() && !KnownULT.getValue());
EXPECT_EQ(NoneULE, KnownULE.has_value() && !KnownULE.getValue());
EXPECT_EQ(NoneSGT, KnownSGT.has_value() && !KnownSGT.getValue());
EXPECT_EQ(NoneSGE, KnownSGE.has_value() && !KnownSGE.getValue());
EXPECT_EQ(NoneSLT, KnownSLT.has_value() && !KnownSLT.getValue());
EXPECT_EQ(NoneSLE, KnownSLE.has_value() && !KnownSLE.getValue());
});
});
}

4
llvm/unittests/Support/YAMLParserTest.cpp
View File

@ -344,12 +344,12 @@ TEST(YAMLParser, FlowSequenceTokensOutsideFlowSequence) {
static void expectCanParseBool(StringRef S, bool Expected) {
llvm::Optional<bool> Parsed = yaml::parseBool(S);
EXPECT_TRUE(Parsed.hasValue());
EXPECT_TRUE(Parsed.has_value());
EXPECT_EQ(*Parsed, Expected);
}
static void expectCannotParseBool(StringRef S) {
EXPECT_FALSE(yaml::parseBool(S).hasValue());
EXPECT_FALSE(yaml::parseBool(S).has_value());
}
TEST(YAMLParser, ParsesBools) {

2
llvm/unittests/TableGen/ParserEntryPointTest.cpp
View File

@ -35,6 +35,6 @@ TEST(Parser, SanityTest) {
Record *Foo = Records.getDef("Foo");
Optional<StringRef> Field = Foo->getValueAsOptionalString("strField");
EXPECT_TRUE(Field.hasValue());
EXPECT_TRUE(Field.has_value());
EXPECT_EQ(Field.getValue(), "value");
}