diff options
| author | Kazu Hirata <kazu@google.com> | 2022-06-25 11:56:50 -0700 |
|---|---|---|
| committer | Kazu Hirata <kazu@google.com> | 2022-06-25 11:56:50 -0700 |
| commit | 3b7c3a654c9175f41ac871a937cbcae73dfb3c5d (patch) | |
| tree | 21094939ea6c8b726c481d7b28eaf4ea27c64008 | |
| parent | aa8feeefd3ac6c78ee8f67bf033976fc7d68bc6d (diff) | |
| download | llvm-3b7c3a654c9175f41ac871a937cbcae73dfb3c5d.zip llvm-3b7c3a654c9175f41ac871a937cbcae73dfb3c5d.tar.gz llvm-3b7c3a654c9175f41ac871a937cbcae73dfb3c5d.tar.bz2 | |
Revert "Don't use Optional::hasValue (NFC)"
This reverts commit aa8feeefd3ac6c78ee8f67bf033976fc7d68bc6d.
372 files changed, 2180 insertions, 2098 deletions
diff --git a/clang-tools-extra/clang-doc/HTMLGenerator.cpp b/clang-tools-extra/clang-doc/HTMLGenerator.cpp index 12c07ac..3e5a533 100644 --- a/clang-tools-extra/clang-doc/HTMLGenerator.cpp +++ b/clang-tools-extra/clang-doc/HTMLGenerator.cpp @@ -653,10 +653,10 @@ genHTML(const EnumInfo &I, const ClangDocContext &CDCtx) { if (I.DefLoc) { if (!CDCtx.RepositoryUrl) - Out.emplace_back(writeFileDefinition(*I.DefLoc)); + Out.emplace_back(writeFileDefinition(I.DefLoc.getValue())); else - Out.emplace_back( - writeFileDefinition(*I.DefLoc, StringRef{*CDCtx.RepositoryUrl})); + Out.emplace_back(writeFileDefinition( + I.DefLoc.getValue(), StringRef{CDCtx.RepositoryUrl.getValue()})); } std::string Description; @@ -702,10 +702,10 @@ genHTML(const FunctionInfo &I, const ClangDocContext &CDCtx, if (I.DefLoc) { if (!CDCtx.RepositoryUrl) - Out.emplace_back(writeFileDefinition(*I.DefLoc)); + Out.emplace_back(writeFileDefinition(I.DefLoc.getValue())); else - Out.emplace_back( - writeFileDefinition(*I.DefLoc, StringRef{*CDCtx.RepositoryUrl})); + Out.emplace_back(writeFileDefinition( + I.DefLoc.getValue(), StringRef{CDCtx.RepositoryUrl.getValue()})); } std::string Description; @@ -768,10 +768,10 @@ genHTML(const RecordInfo &I, Index &InfoIndex, const ClangDocContext &CDCtx, if (I.DefLoc) { if (!CDCtx.RepositoryUrl) - Out.emplace_back(writeFileDefinition(*I.DefLoc)); + Out.emplace_back(writeFileDefinition(I.DefLoc.getValue())); else - Out.emplace_back( - writeFileDefinition(*I.DefLoc, StringRef{*CDCtx.RepositoryUrl})); + Out.emplace_back(writeFileDefinition( + I.DefLoc.getValue(), StringRef{CDCtx.RepositoryUrl.getValue()})); } std::string Description; diff --git a/clang-tools-extra/clang-tidy/bugprone/NotNullTerminatedResultCheck.cpp b/clang-tools-extra/clang-tidy/bugprone/NotNullTerminatedResultCheck.cpp index 418b749..1efd88d 100644 --- a/clang-tools-extra/clang-tidy/bugprone/NotNullTerminatedResultCheck.cpp +++ b/clang-tools-extra/clang-tidy/bugprone/NotNullTerminatedResultCheck.cpp @@ -817,8 +817,8 @@ void NotNullTerminatedResultCheck::check( ++It; } - if (AreSafeFunctionsWanted) - UseSafeFunctions = *AreSafeFunctionsWanted; + if (AreSafeFunctionsWanted.hasValue()) + UseSafeFunctions = AreSafeFunctionsWanted.getValue(); } StringRef Name = FunctionExpr->getDirectCallee()->getName(); diff --git a/clang-tools-extra/clangd/ClangdLSPServer.cpp b/clang-tools-extra/clangd/ClangdLSPServer.cpp index 4a26b5a..3bade14 100644 --- a/clang-tools-extra/clangd/ClangdLSPServer.cpp +++ b/clang-tools-extra/clangd/ClangdLSPServer.cpp @@ -663,9 +663,9 @@ void ClangdLSPServer::onDocumentDidOpen( void ClangdLSPServer::onDocumentDidChange( const DidChangeTextDocumentParams &Params) { auto WantDiags = WantDiagnostics::Auto; - if (Params.wantDiagnostics) - WantDiags = - *Params.wantDiagnostics ? WantDiagnostics::Yes : WantDiagnostics::No; + if (Params.wantDiagnostics.hasValue()) + WantDiags = Params.wantDiagnostics.getValue() ? WantDiagnostics::Yes + : WantDiagnostics::No; PathRef File = Params.textDocument.uri.file(); auto Code = Server->getDraft(File); diff --git a/clang-tools-extra/clangd/ClangdServer.cpp b/clang-tools-extra/clangd/ClangdServer.cpp index 1fe63c1f..fa6c70b 100644 --- a/clang-tools-extra/clangd/ClangdServer.cpp +++ b/clang-tools-extra/clangd/ClangdServer.cpp @@ -411,9 +411,10 @@ void ClangdServer::codeComplete(PathRef File, Position Pos, clang::clangd::trace::Span Tracer("Completion results callback"); CB(std::move(Result)); } - if (SpecFuzzyFind && SpecFuzzyFind->NewReq) { + if (SpecFuzzyFind && SpecFuzzyFind->NewReq.hasValue()) { std::lock_guard<std::mutex> Lock(CachedCompletionFuzzyFindRequestMutex); - CachedCompletionFuzzyFindRequestByFile[File] = *SpecFuzzyFind->NewReq; + CachedCompletionFuzzyFindRequestByFile[File] = + SpecFuzzyFind->NewReq.getValue(); } // SpecFuzzyFind is only destroyed after speculative fuzzy find finishes. // We don't want `codeComplete` to wait for the async call if it doesn't use diff --git a/clang-tools-extra/clangd/CodeComplete.cpp b/clang-tools-extra/clangd/CodeComplete.cpp index d17a14b..fbd7488 100644 --- a/clang-tools-extra/clangd/CodeComplete.cpp +++ b/clang-tools-extra/clangd/CodeComplete.cpp @@ -391,9 +391,11 @@ struct CodeCompletionBuilder { ToInclude.takeError()); } // Prefer includes that do not need edits (i.e. already exist). - std::stable_partition( - Completion.Includes.begin(), Completion.Includes.end(), - [](const CodeCompletion::IncludeCandidate &I) { return !I.Insertion; }); + std::stable_partition(Completion.Includes.begin(), + Completion.Includes.end(), + [](const CodeCompletion::IncludeCandidate &I) { + return !I.Insertion.hasValue(); + }); } void add(const CompletionCandidate &C, CodeCompletionString *SemaCCS) { diff --git a/clang-tools-extra/clangd/ConfigCompile.cpp b/clang-tools-extra/clangd/ConfigCompile.cpp index 8f207ab..2de8816 100644 --- a/clang-tools-extra/clangd/ConfigCompile.cpp +++ b/clang-tools-extra/clangd/ConfigCompile.cpp @@ -358,8 +358,8 @@ struct FragmentCompiler { } #endif // Make sure exactly one of the Sources is set. - unsigned SourceCount = External.File.has_value() + - External.Server.has_value() + *External.IsNone; + unsigned SourceCount = External.File.hasValue() + + External.Server.hasValue() + *External.IsNone; if (SourceCount != 1) { diag(Error, "Exactly one of File, Server or None must be set.", BlockRange); diff --git a/clang-tools-extra/clangd/FeatureModule.cpp b/clang-tools-extra/clangd/FeatureModule.cpp index 872cea1..85977aa 100644 --- a/clang-tools-extra/clangd/FeatureModule.cpp +++ b/clang-tools-extra/clangd/FeatureModule.cpp @@ -13,12 +13,12 @@ namespace clang { namespace clangd { void FeatureModule::initialize(const Facilities &F) { - assert(!Fac && "Initialized twice"); + assert(!Fac.hasValue() && "Initialized twice"); Fac.emplace(F); } FeatureModule::Facilities &FeatureModule::facilities() { - assert(Fac && "Not initialized yet"); + assert(Fac.hasValue() && "Not initialized yet"); return *Fac; } diff --git a/clang-tools-extra/clangd/index/YAMLSerialization.cpp b/clang-tools-extra/clangd/index/YAMLSerialization.cpp index 1ac7433..79c9e1d 100644 --- a/clang-tools-extra/clangd/index/YAMLSerialization.cpp +++ b/clang-tools-extra/clangd/index/YAMLSerialization.cpp @@ -354,23 +354,23 @@ template <> struct MappingTraits<CompileCommandYAML> { template <> struct MappingTraits<VariantEntry> { static void mapping(IO &IO, VariantEntry &Variant) { - if (IO.mapTag("!Symbol", Variant.Symbol.has_value())) { + if (IO.mapTag("!Symbol", Variant.Symbol.hasValue())) { if (!IO.outputting()) Variant.Symbol.emplace(); MappingTraits<Symbol>::mapping(IO, *Variant.Symbol); - } else if (IO.mapTag("!Refs", Variant.Refs.has_value())) { + } else if (IO.mapTag("!Refs", Variant.Refs.hasValue())) { if (!IO.outputting()) Variant.Refs.emplace(); MappingTraits<RefBundle>::mapping(IO, *Variant.Refs); - } else if (IO.mapTag("!Relations", Variant.Relation.has_value())) { + } else if (IO.mapTag("!Relations", Variant.Relation.hasValue())) { if (!IO.outputting()) Variant.Relation.emplace(); MappingTraits<Relation>::mapping(IO, *Variant.Relation); - } else if (IO.mapTag("!Source", Variant.Source.has_value())) { + } else if (IO.mapTag("!Source", Variant.Source.hasValue())) { if (!IO.outputting()) Variant.Source.emplace(); MappingTraits<IncludeGraphNode>::mapping(IO, *Variant.Source); - } else if (IO.mapTag("!Cmd", Variant.Cmd.has_value())) { + } else if (IO.mapTag("!Cmd", Variant.Cmd.hasValue())) { if (!IO.outputting()) Variant.Cmd.emplace(); MappingTraits<CompileCommandYAML>::mapping( diff --git a/clang-tools-extra/clangd/unittests/ConfigYAMLTests.cpp b/clang-tools-extra/clangd/unittests/ConfigYAMLTests.cpp index 6af1e3b..ddf6f4f 100644 --- a/clang-tools-extra/clangd/unittests/ConfigYAMLTests.cpp +++ b/clang-tools-extra/clangd/unittests/ConfigYAMLTests.cpp @@ -82,12 +82,12 @@ Diagnostics: EXPECT_THAT(Results[1].CompileFlags.Add, ElementsAre(val("b\naz\n"))); ASSERT_TRUE(Results[2].Index.Background); - EXPECT_EQ("Skip", *Results[2].Index.Background.value()); + EXPECT_EQ("Skip", *Results[2].Index.Background.getValue()); EXPECT_THAT(Results[3].Diagnostics.ClangTidy.CheckOptions, ElementsAre(PairVal("IgnoreMacros", "true"), PairVal("example-check.ExampleOption", "0"))); EXPECT_TRUE(Results[3].Diagnostics.UnusedIncludes); - EXPECT_EQ("Strict", *Results[3].Diagnostics.UnusedIncludes.value()); + EXPECT_EQ("Strict", *Results[3].Diagnostics.UnusedIncludes.getValue()); } TEST(ParseYAML, Locations) { @@ -163,10 +163,10 @@ Index: ASSERT_THAT(Diags.Diagnostics, IsEmpty()); ASSERT_EQ(Results.size(), 1u); ASSERT_TRUE(Results[0].Index.External); - EXPECT_FALSE(Results[0].Index.External.value()->File.has_value()); - EXPECT_FALSE(Results[0].Index.External.value()->MountPoint.has_value()); - EXPECT_FALSE(Results[0].Index.External.value()->Server.has_value()); - EXPECT_THAT(*Results[0].Index.External.value()->IsNone, testing::Eq(true)); + EXPECT_FALSE(Results[0].Index.External.getValue()->File.hasValue()); + EXPECT_FALSE(Results[0].Index.External.getValue()->MountPoint.hasValue()); + EXPECT_FALSE(Results[0].Index.External.getValue()->Server.hasValue()); + EXPECT_THAT(*Results[0].Index.External.getValue()->IsNone, testing::Eq(true)); } TEST(ParseYAML, ExternalBlock) { @@ -182,10 +182,10 @@ Index: Fragment::parseYAML(YAML.code(), "config.yaml", Diags.callback()); ASSERT_EQ(Results.size(), 1u); ASSERT_TRUE(Results[0].Index.External); - EXPECT_THAT(*Results[0].Index.External.value()->File, val("foo")); - EXPECT_THAT(*Results[0].Index.External.value()->MountPoint, val("baz")); + EXPECT_THAT(*Results[0].Index.External.getValue()->File, val("foo")); + EXPECT_THAT(*Results[0].Index.External.getValue()->MountPoint, val("baz")); ASSERT_THAT(Diags.Diagnostics, IsEmpty()); - EXPECT_THAT(*Results[0].Index.External.value()->Server, val("bar")); + EXPECT_THAT(*Results[0].Index.External.getValue()->Server, val("bar")); } TEST(ParseYAML, AllScopes) { diff --git a/clang-tools-extra/clangd/unittests/FSTests.cpp b/clang-tools-extra/clangd/unittests/FSTests.cpp index 81129fe..575111e 100644 --- a/clang-tools-extra/clangd/unittests/FSTests.cpp +++ b/clang-tools-extra/clangd/unittests/FSTests.cpp @@ -28,10 +28,10 @@ TEST(FSTests, PreambleStatusCache) { EXPECT_TRUE(ProduceFS->status("y")); EXPECT_TRUE(ProduceFS->status("main")); - EXPECT_TRUE(StatCache.lookup(testPath("x")).has_value()); - EXPECT_TRUE(StatCache.lookup(testPath("y")).has_value()); + EXPECT_TRUE(StatCache.lookup(testPath("x")).hasValue()); + EXPECT_TRUE(StatCache.lookup(testPath("y")).hasValue()); // Main file is not cached. - EXPECT_FALSE(StatCache.lookup(testPath("main")).has_value()); + EXPECT_FALSE(StatCache.lookup(testPath("main")).hasValue()); llvm::vfs::Status S("fake", llvm::sys::fs::UniqueID(123, 456), std::chrono::system_clock::now(), 0, 0, 1024, diff --git a/clang-tools-extra/clangd/unittests/GlobalCompilationDatabaseTests.cpp b/clang-tools-extra/clangd/unittests/GlobalCompilationDatabaseTests.cpp index 3959c3e..fbf07aa 100644 --- a/clang-tools-extra/clangd/unittests/GlobalCompilationDatabaseTests.cpp +++ b/clang-tools-extra/clangd/unittests/GlobalCompilationDatabaseTests.cpp @@ -331,14 +331,14 @@ TEST(GlobalCompilationDatabaseTest, CompileFlagsDirectory) { FS.Files[testPath("x/compile_flags.txt")] = "-DFOO"; DirectoryBasedGlobalCompilationDatabase CDB(FS); auto Commands = CDB.getCompileCommand(testPath("x/y.cpp")); - ASSERT_TRUE(Commands.has_value()); - EXPECT_THAT(Commands->CommandLine, Contains("-DFOO")); + ASSERT_TRUE(Commands.hasValue()); + EXPECT_THAT(Commands.getValue().CommandLine, Contains("-DFOO")); // Make sure we pick the right working directory. - EXPECT_EQ(testPath("x"), Commands->Directory); + EXPECT_EQ(testPath("x"), Commands.getValue().Directory); } MATCHER_P(hasArg, Flag, "") { - if (!arg) { + if (!arg.hasValue()) { *result_listener << "command is null"; return false; } diff --git a/clang-tools-extra/clangd/unittests/HeaderSourceSwitchTests.cpp b/clang-tools-extra/clangd/unittests/HeaderSourceSwitchTests.cpp index 5b9467f..b2d7a7e 100644 --- a/clang-tools-extra/clangd/unittests/HeaderSourceSwitchTests.cpp +++ b/clang-tools-extra/clangd/unittests/HeaderSourceSwitchTests.cpp @@ -33,12 +33,12 @@ TEST(HeaderSourceSwitchTest, FileHeuristic) { FS.Files[Invalid]; Optional<Path> PathResult = getCorrespondingHeaderOrSource(FooCpp, FS.view(llvm::None)); - EXPECT_TRUE(PathResult.has_value()); - ASSERT_EQ(*PathResult, FooH); + EXPECT_TRUE(PathResult.hasValue()); + ASSERT_EQ(PathResult.getValue(), FooH); PathResult = getCorrespondingHeaderOrSource(FooH, FS.view(llvm::None)); - EXPECT_TRUE(PathResult.has_value()); - ASSERT_EQ(*PathResult, FooCpp); + EXPECT_TRUE(PathResult.hasValue()); + ASSERT_EQ(PathResult.getValue(), FooCpp); // Test with header file in capital letters and different extension, source // file with different extension @@ -48,8 +48,8 @@ TEST(HeaderSourceSwitchTest, FileHeuristic) { FS.Files[FooC]; FS.Files[FooHH]; PathResult = getCorrespondingHeaderOrSource(FooC, FS.view(llvm::None)); - EXPECT_TRUE(PathResult.has_value()); - ASSERT_EQ(*PathResult, FooHH); + EXPECT_TRUE(PathResult.hasValue()); + ASSERT_EQ(PathResult.getValue(), FooHH); // Test with both capital letters auto Foo2C = testPath("foo2.C"); @@ -57,8 +57,8 @@ TEST(HeaderSourceSwitchTest, FileHeuristic) { FS.Files[Foo2C]; FS.Files[Foo2HH]; PathResult = getCorrespondingHeaderOrSource(Foo2C, FS.view(llvm::None)); - EXPECT_TRUE(PathResult.has_value()); - ASSERT_EQ(*PathResult, Foo2HH); + EXPECT_TRUE(PathResult.hasValue()); + ASSERT_EQ(PathResult.getValue(), Foo2HH); // Test with source file as capital letter and .hxx header file auto Foo3C = testPath("foo3.C"); @@ -67,13 +67,13 @@ TEST(HeaderSourceSwitchTest, FileHeuristic) { FS.Files[Foo3C]; FS.Files[Foo3HXX]; PathResult = getCorrespondingHeaderOrSource(Foo3C, FS.view(llvm::None)); - EXPECT_TRUE(PathResult.has_value()); - ASSERT_EQ(*PathResult, Foo3HXX); + EXPECT_TRUE(PathResult.hasValue()); + ASSERT_EQ(PathResult.getValue(), Foo3HXX); // Test if asking for a corresponding file that doesn't exist returns an empty // string. PathResult = getCorrespondingHeaderOrSource(Invalid, FS.view(llvm::None)); - EXPECT_FALSE(PathResult.has_value()); + EXPECT_FALSE(PathResult.hasValue()); } MATCHER_P(declNamed, Name, "") { diff --git a/clang-tools-extra/clangd/unittests/LSPBinderTests.cpp b/clang-tools-extra/clangd/unittests/LSPBinderTests.cpp index 97a4316..8b9363b 100644 --- a/clang-tools-extra/clangd/unittests/LSPBinderTests.cpp +++ b/clang-tools-extra/clangd/unittests/LSPBinderTests.cpp @@ -93,18 +93,19 @@ TEST(LSPBinderTest, IncomingCalls) { auto &RawPlusOne = RawHandlers.MethodHandlers["plusOne"]; RawPlusOne(1, capture(Reply)); - ASSERT_TRUE(Reply.has_value()); - EXPECT_THAT_EXPECTED(*Reply, llvm::HasValue(2)); + ASSERT_TRUE(Reply.hasValue()); + EXPECT_THAT_EXPECTED(Reply.getValue(), llvm::HasValue(2)); RawPlusOne("foo", capture(Reply)); - ASSERT_TRUE(Reply.has_value()); + ASSERT_TRUE(Reply.hasValue()); EXPECT_THAT_EXPECTED( - *Reply, llvm::FailedWithMessage(HasSubstr( - "failed to decode plusOne request: expected integer"))); + Reply.getValue(), + llvm::FailedWithMessage( + HasSubstr("failed to decode plusOne request: expected integer"))); auto &RawFail = RawHandlers.MethodHandlers["fail"]; RawFail(2, capture(Reply)); - ASSERT_TRUE(Reply.has_value()); - EXPECT_THAT_EXPECTED(*Reply, llvm::FailedWithMessage("X=2")); + ASSERT_TRUE(Reply.hasValue()); + EXPECT_THAT_EXPECTED(Reply.getValue(), llvm::FailedWithMessage("X=2")); auto &RawNotify = RawHandlers.NotificationHandlers["notify"]; RawNotify(42); @@ -116,8 +117,8 @@ TEST(LSPBinderTest, IncomingCalls) { auto &RawCmdPlusOne = RawHandlers.CommandHandlers["cmdPlusOne"]; RawCmdPlusOne(1, capture(Reply)); - ASSERT_TRUE(Reply.has_value()); - EXPECT_THAT_EXPECTED(*Reply, llvm::HasValue(2)); + ASSERT_TRUE(Reply.hasValue()); + EXPECT_THAT_EXPECTED(Reply.getValue(), llvm::HasValue(2)); // None of this generated any outgoing traffic. EXPECT_THAT(RawOutgoing.Received, IsEmpty()); @@ -138,23 +139,23 @@ TEST(LSPBinderTest, OutgoingCalls) { llvm::Optional<llvm::Expected<Foo>> Reply; Echo(Foo{2}, capture(Reply)); EXPECT_THAT(RawOutgoing.take("echo"), ElementsAre(llvm::json::Value(2))); - ASSERT_TRUE(Reply.has_value()); - EXPECT_THAT_EXPECTED(*Reply, llvm::HasValue(Foo{2})); + ASSERT_TRUE(Reply.hasValue()); + EXPECT_THAT_EXPECTED(Reply.getValue(), llvm::HasValue(Foo{2})); // JSON response is integer, can't be parsed as string. llvm::Optional<llvm::Expected<std::string>> WrongTypeReply; WrongSignature(Foo{2}, capture(WrongTypeReply)); EXPECT_THAT(RawOutgoing.take("wrongSignature"), ElementsAre(llvm::json::Value(2))); - ASSERT_TRUE(Reply.has_value()); - EXPECT_THAT_EXPECTED(*WrongTypeReply, + ASSERT_TRUE(Reply.hasValue()); + EXPECT_THAT_EXPECTED(WrongTypeReply.getValue(), llvm::FailedWithMessage( HasSubstr("failed to decode wrongSignature reply"))); Fail(Foo{2}, capture(Reply)); EXPECT_THAT(RawOutgoing.take("fail"), ElementsAre(llvm::json::Value(2))); - ASSERT_TRUE(Reply.has_value()); - EXPECT_THAT_EXPECTED(*Reply, llvm::FailedWithMessage("Params=2")); + ASSERT_TRUE(Reply.hasValue()); + EXPECT_THAT_EXPECTED(Reply.getValue(), llvm::FailedWithMessage("Params=2")); } } // namespace diff --git a/clang-tools-extra/clangd/unittests/TidyProviderTests.cpp b/clang-tools-extra/clangd/unittests/TidyProviderTests.cpp index ece7f52..df3dcac 100644 --- a/clang-tools-extra/clangd/unittests/TidyProviderTests.cpp +++ b/clang-tools-extra/clangd/unittests/TidyProviderTests.cpp @@ -37,18 +37,18 @@ TEST(TidyProvider, NestedDirectories) { TidyProvider Provider = provideClangTidyFiles(FS); auto BaseOptions = getTidyOptionsForFile(Provider, testPath("File.cpp")); - ASSERT_TRUE(BaseOptions.Checks.has_value()); + ASSERT_TRUE(BaseOptions.Checks.hasValue()); EXPECT_EQ(*BaseOptions.Checks, "llvm-*"); EXPECT_EQ(BaseOptions.CheckOptions.lookup("TestKey").Value, "1"); auto Sub1Options = getTidyOptionsForFile(Provider, testPath("sub1/File.cpp")); - ASSERT_TRUE(Sub1Options.Checks.has_value()); + ASSERT_TRUE(Sub1Options.Checks.hasValue()); EXPECT_EQ(*Sub1Options.Checks, "misc-*"); EXPECT_EQ(Sub1Options.CheckOptions.lookup("TestKey").Value, "2"); auto Sub2Options = getTidyOptionsForFile(Provider, testPath("sub1/sub2/File.cpp")); - ASSERT_TRUE(Sub2Options.Checks.has_value()); + ASSERT_TRUE(Sub2Options.Checks.hasValue()); EXPECT_EQ(*Sub2Options.Checks, "misc-*,bugprone-*"); EXPECT_EQ(Sub2Options.CheckOptions.lookup("TestKey").Value, "3"); } diff --git a/clang-tools-extra/pseudo/lib/GLR.cpp b/clang-tools-extra/pseudo/lib/GLR.cpp index d93f682..1cee8f8 100644 --- a/clang-tools-extra/pseudo/lib/GLR.cpp +++ b/clang-tools-extra/pseudo/lib/GLR.cpp @@ -375,11 +375,11 @@ private: for (auto &A : Params.Table.getActions(Head->State, Lookahead)) { if (A.kind() != LRTable::Action::Reduce) continue; - if (RID) + if (RID.hasValue()) return false; RID = A.getReduceRule(); } - if (!RID) + if (!RID.hasValue()) return true; // no reductions available, but we've processed the head! const auto &Rule = Params.G.lookupRule(*RID); const GSS::Node *Base = Head; diff --git a/clang-tools-extra/unittests/clang-doc/ClangDocTest.cpp b/clang-tools-extra/unittests/clang-doc/ClangDocTest.cpp index ea1ef73..970ffce 100644 --- a/clang-tools-extra/unittests/clang-doc/ClangDocTest.cpp +++ b/clang-tools-extra/unittests/clang-doc/ClangDocTest.cpp @@ -95,8 +95,8 @@ void CheckBaseInfo(Info *Expected, Info *Actual) { void CheckSymbolInfo(SymbolInfo *Expected, SymbolInfo *Actual) { CheckBaseInfo(Expected, Actual); - EXPECT_EQ(Expected->DefLoc.has_value(), Actual->DefLoc.has_value()); - if (Expected->DefLoc && Actual->DefLoc) { + EXPECT_EQ(Expected->DefLoc.hasValue(), Actual->DefLoc.hasValue()); + if (Expected->DefLoc.hasValue() && Actual->DefLoc.hasValue()) { EXPECT_EQ(Expected->DefLoc->LineNumber, Actual->DefLoc->LineNumber); EXPECT_EQ(Expected->DefLoc->Filename, Actual->DefLoc->Filename); } diff --git a/clang-tools-extra/unittests/clang-tidy/ClangTidyOptionsTest.cpp b/clang-tools-extra/unittests/clang-tidy/ClangTidyOptionsTest.cpp index 5dcec03..3558b5f 100644 --- a/clang-tools-extra/unittests/clang-tidy/ClangTidyOptionsTest.cpp +++ b/clang-tools-extra/unittests/clang-tidy/ClangTidyOptionsTest.cpp @@ -129,14 +129,14 @@ TEST(ParseConfiguration, MergeConfigurations) { EXPECT_EQ("check1,check2,check3,check4", *Options.Checks); EXPECT_EQ("filter2", *Options.HeaderFilterRegex); EXPECT_EQ("user2", *Options.User); - ASSERT_TRUE(Options.ExtraArgs.has_value()); + ASSERT_TRUE(Options.ExtraArgs.hasValue()); EXPECT_EQ("arg1,arg2,arg3,arg4", llvm::join(Options.ExtraArgs->begin(), Options.ExtraArgs->end(), ",")); - ASSERT_TRUE(Options.ExtraArgsBefore.has_value()); + ASSERT_TRUE(Options.ExtraArgsBefore.hasValue()); EXPECT_EQ("arg-before1,arg-before2,arg-before3,arg-before4", llvm::join(Options.ExtraArgsBefore->begin(), Options.ExtraArgsBefore->end(), ",")); - ASSERT_TRUE(Options.UseColor.has_value()); + ASSERT_TRUE(Options.UseColor.hasValue()); EXPECT_TRUE(*Options.UseColor); } @@ -325,9 +325,9 @@ TEST(CheckOptionsValidation, ValidIntOptions) { CHECK_VAL(TestCheck.getIntLocal("IntExpected"), 1); CHECK_VAL(TestCheck.getIntGlobal("GlobalIntExpected"), 1); - EXPECT_FALSE(TestCheck.getIntLocal("IntInvalid1").has_value()); - EXPECT_FALSE(TestCheck.getIntLocal("IntInvalid2").has_value()); - EXPECT_FALSE(TestCheck.getIntGlobal("GlobalIntInvalid").has_value()); + EXPECT_FALSE(TestCheck.getIntLocal("IntInvalid1").hasValue()); + EXPECT_FALSE(TestCheck.getIntLocal("IntInvalid2").hasValue()); + EXPECT_FALSE(TestCheck.getIntGlobal("GlobalIntInvalid").hasValue()); ASSERT_EQ(TestCheck.getIntLocal("DefaultedIntInvalid", 1), 1); CHECK_VAL(TestCheck.getIntLocal<bool>("BoolITrueValue"), true); @@ -395,14 +395,14 @@ TEST(ValidConfiguration, ValidEnumOptions) { /*IgnoreCase*/ true), Colours::Violet); - EXPECT_FALSE(TestCheck.getIntLocal<Colours>("ValidWrongCase").has_value()); - EXPECT_FALSE(TestCheck.getIntLocal<Colours>("NearMiss").has_value()); - EXPECT_FALSE(TestCheck.getIntGlobal<Colours>("GlobalInvalid").has_value()); + EXPECT_FALSE(TestCheck.getIntLocal<Colours>("ValidWrongCase").hasValue()); + EXPECT_FALSE(TestCheck.getIntLocal<Colours>("NearMiss").hasValue()); + EXPECT_FALSE(TestCheck.getIntGlobal<Colours>("GlobalInvalid").hasValue()); EXPECT_FALSE( - TestCheck.getIntGlobal<Colours>("GlobalValidWrongCase").has_value()); - EXPECT_FALSE(TestCheck.getIntGlobal<Colours>("GlobalNearMiss").has_value()); + TestCheck.getIntGlobal<Colours>("GlobalValidWrongCase").hasValue()); + EXPECT_FALSE(TestCheck.getIntGlobal<Colours>("GlobalNearMiss").hasValue()); - EXPECT_FALSE(TestCheck.getIntLocal<Colours>("Invalid").has_value()); + EXPECT_FALSE(TestCheck.getIntLocal<Colours>("Invalid").hasValue()); EXPECT_THAT( DiagConsumer.take(), UnorderedElementsAre( diff --git a/clang-tools-extra/unittests/clang-tidy/NamespaceAliaserTest.cpp b/clang-tools-extra/unittests/clang-tidy/NamespaceAliaserTest.cpp index c7ebd5e..e4cd74e 100644 --- a/clang-tools-extra/unittests/clang-tidy/NamespaceAliaserTest.cpp +++ b/clang-tools-extra/unittests/clang-tidy/NamespaceAliaserTest.cpp @@ -34,8 +34,8 @@ public: assert(Call != nullptr && "Did not find node \"foo\""); auto Hint = Aliaser->createAlias(*Result.Context, *Call, "::foo::bar", {"b", "some_alias"}); - if (Hint) - diag(Call->getBeginLoc(), "Fix for testing") << *Hint; + if (Hint.hasValue()) + diag(Call->getBeginLoc(), "Fix for testing") << Hint.getValue(); diag(Call->getBeginLoc(), "insert call") << FixItHint::CreateInsertion( Call->getBeginLoc(), diff --git a/clang-tools-extra/unittests/clang-tidy/OptionsProviderTest.cpp b/clang-tools-extra/unittests/clang-tidy/OptionsProviderTest.cpp index 5aa3730..b99d078 100644 --- a/clang-tools-extra/unittests/clang-tidy/OptionsProviderTest.cpp +++ b/clang-tools-extra/unittests/clang-tidy/OptionsProviderTest.cpp @@ -53,9 +53,9 @@ TEST(ClangTidyOptionsProvider, InMemoryFileSystems) { ClangTidyOptions File3Options = FileOpt.getOptions("ProjectRoot/SubDir1/SubDir2/SubDir3/File.cpp"); - ASSERT_TRUE(File1Options.Checks.has_value()); + ASSERT_TRUE(File1Options.Checks.hasValue()); EXPECT_EQ(*File1Options.Checks, "-*,clang-diagnostic-*,readability-*"); - ASSERT_TRUE(File2Options.Checks.has_value()); + ASSERT_TRUE(File2Options.Checks.hasValue()); EXPECT_EQ(*File2Options.Checks, "bugprone-*,misc-*,clang-diagnostic-*"); // 2 and 3 should use the same config so these should also be the same. diff --git a/clang-tools-extra/unittests/clang-tidy/UsingInserterTest.cpp b/clang-tools-extra/unittests/clang-tidy/UsingInserterTest.cpp index 43350cb..71c7159 100644 --- a/clang-tools-extra/unittests/clang-tidy/UsingInserterTest.cpp +++ b/clang-tools-extra/unittests/clang-tidy/UsingInserterTest.cpp @@ -37,8 +37,8 @@ public: auto Hint = Inserter->createUsingDeclaration(*Result.Context, *Call, "::foo::func"); - if (Hint) - diag(Call->getBeginLoc(), "Fix for testing") << *Hint; + if (Hint.hasValue()) + diag(Call->getBeginLoc(), "Fix for testing") << Hint.getValue(); diag(Call->getBeginLoc(), "insert call") << clang::FixItHint::CreateReplacement( diff --git a/clang/include/clang/APINotes/Types.h b/clang/include/clang/APINotes/Types.h index d98b3d9..ed5250f 100644 --- a/clang/include/clang/APINotes/Types.h +++ b/clang/include/clang/APINotes/Types.h @@ -76,8 +76,8 @@ public: } void setSwiftPrivate(llvm::Optional<bool> Private) { - SwiftPrivateSpecified = Private.has_value(); - SwiftPrivate = Private.value_or(0); + SwiftPrivateSpecified = Private.hasValue(); + SwiftPrivate = Private.hasValue() ? *Private : 0; } friend bool operator==(const CommonEntityInfo &, const CommonEntityInfo &); diff --git a/clang/include/clang/AST/PropertiesBase.td b/clang/include/clang/AST/PropertiesBase.td index 0f7acf6..559f29e 100644 --- a/clang/include/clang/AST/PropertiesBase.td +++ b/clang/include/clang/AST/PropertiesBase.td @@ -520,15 +520,15 @@ let Class = PropertyTypeCase<APValue, "LValue"> in { if (hasBase) { if (isTypeInfo) { base = APValue::LValueBase::getTypeInfo( - TypeInfoLValue(typeInfo->getTypePtr()), *type); + TypeInfoLValue(typeInfo.getValue().getTypePtr()), type.getValue()); elemTy = base.getTypeInfoType(); } else if (isExpr) { - base = APValue::LValueBase(cast<Expr>(*stmt), - *callIndex, *version); + base = APValue::LValueBase(cast<Expr>(stmt.getValue()), + callIndex.getValue(), version.getValue()); elemTy = base.get<const Expr *>()->getType(); } else { - base = APValue::LValueBase(cast<ValueDecl>(*decl), - *callIndex, *version); + base = APValue::LValueBase(cast<ValueDecl>(decl.getValue()), + callIndex.getValue(), version.getValue()); elemTy = base.get<const ValueDecl *>()->getType(); } } diff --git a/clang/include/clang/Analysis/PathDiagnostic.h b/clang/include/clang/Analysis/PathDiagnostic.h index 9877f1e..47cb549 100644 --- a/clang/include/clang/Analysis/PathDiagnostic.h +++ b/clang/include/clang/Analysis/PathDiagnostic.h @@ -544,8 +544,8 @@ public: /// flag may have been previously set, at which point it will not /// be reset unless one specifies to do so. void setPrunable(bool isPrunable, bool override = false) { - if (IsPrunable && !override) - return; + if (IsPrunable.hasValue() && !override) + return; IsPrunable = isPrunable; } diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h index 8b8b1b2..ba4d0bb 100644 --- a/clang/include/clang/Sema/Sema.h +++ b/clang/include/clang/Sema/Sema.h @@ -1766,9 +1766,9 @@ public: template <typename T> friend const SemaDiagnosticBuilder & operator<<(const SemaDiagnosticBuilder &Diag, const T &Value) { - if (Diag.ImmediateDiag) + if (Diag.ImmediateDiag.hasValue()) *Diag.ImmediateDiag << Value; - else if (Diag.PartialDiagId) + else if (Diag.PartialDiagId.hasValue()) Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second << Value; return Diag; @@ -1780,26 +1780,26 @@ public: template <typename T, typename = typename std::enable_if< !std::is_lvalue_reference<T>::value>::type> const SemaDiagnosticBuilder &operator<<(T &&V) const { - if (ImmediateDiag) + if (ImmediateDiag.hasValue()) *ImmediateDiag << std::move(V); - else if (PartialDiagId) + else if (PartialDiagId.hasValue()) S.DeviceDeferredDiags[Fn][*PartialDiagId].second << std::move(V); return *this; } friend const SemaDiagnosticBuilder & operator<<(const SemaDiagnosticBuilder &Diag, const PartialDiagnostic &PD) { - if (Diag.ImmediateDiag) + if (Diag.ImmediateDiag.hasValue()) PD.Emit(*Diag.ImmediateDiag); - else if (Diag.PartialDiagId) + else if (Diag.PartialDiagId.hasValue()) Diag.S.DeviceDeferredDiags[Diag.Fn][*Diag.PartialDiagId].second = PD; return Diag; } void AddFixItHint(const FixItHint &Hint) const { - if (ImmediateDiag) + if (ImmediateDiag.hasValue()) ImmediateDiag->AddFixItHint(Hint); - else if (PartialDiagId) + else if (PartialDiagId.hasValue()) S.DeviceDeferredDiags[Fn][*PartialDiagId].second.AddFixItHint(Hint); } diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h index 59fe535e..a01b326 100644 --- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h +++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h @@ -414,8 +414,7 @@ public: bool isArgumentConstructedDirectly(unsigned Index) const { // This assumes that the object was not yet removed from the state. return ExprEngine::getObjectUnderConstruction( - getState(), {getOriginExpr(), Index}, getLocationContext()) - .has_value(); + getState(), {getOriginExpr(), Index}, getLocationContext()).hasValue(); } /// Some calls have parameter numbering mismatched from argument numbering. @@ -1017,8 +1016,9 @@ public: } SVal getObjectUnderConstruction() const { - return *ExprEngine::getObjectUnderConstruction(getState(), getOriginExpr(), - getLocationContext()); + return ExprEngine::getObjectUnderConstruction(getState(), getOriginExpr(), + getLocationContext()) + .getValue(); } /// Number of non-placement arguments to the call. It is equal to 2 for diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ConstraintManager.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ConstraintManager.h index 92a37c6..11c60b6 100644 --- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ConstraintManager.h +++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/ConstraintManager.h @@ -53,17 +53,25 @@ public: } /// Return true if the constraint is perfectly constrained to 'true'. - bool isConstrainedTrue() const { return Val && *Val; } + bool isConstrainedTrue() const { + return Val.hasValue() && Val.getValue(); + } /// Return true if the constraint is perfectly constrained to 'false'. - bool isConstrainedFalse() const { return Val && !*Val; } + bool isConstrainedFalse() const { + return Val.hasValue() && !Val.getValue(); + } /// Return true if the constrained is perfectly constrained. - bool isConstrained() const { return Val.has_value(); } + bool isConstrained() const { + return Val.hasValue(); + } /// Return true if the constrained is underconstrained and we do not know /// if the constraint is true of value. - bool isUnderconstrained() const { return !Val.has_value(); } + bool isUnderconstrained() const { + return !Val.hasValue(); + } }; class ConstraintManager { diff --git a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SMTConstraintManager.h b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SMTConstraintManager.h index 6c8ed07..250ba4f 100644 --- a/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SMTConstraintManager.h +++ b/clang/include/clang/StaticAnalyzer/Core/PathSensitive/SMTConstraintManager.h @@ -341,10 +341,10 @@ protected: addStateConstraints(NewState); Optional<bool> res = Solver->check(); - if (!res) + if (!res.hasValue()) Cached[hash] = ConditionTruthVal(); else - Cached[hash] = ConditionTruthVal(*res); + Cached[hash] = ConditionTruthVal(res.getValue()); return Cached[hash]; } diff --git a/clang/include/clang/Support/RISCVVIntrinsicUtils.h b/clang/include/clang/Support/RISCVVIntrinsicUtils.h index 8d34caf..0e9fe97 100644 --- a/clang/include/clang/Support/RISCVVIntrinsicUtils.h +++ b/clang/include/clang/Support/RISCVVIntrinsicUtils.h @@ -209,8 +209,8 @@ public: } bool isValid() const { return Valid; } - bool isScalar() const { return Scale && *Scale == 0; } - bool isVector() const { return Scale && *Scale != 0; } + bool isScalar() const { return Scale.hasValue() && Scale.getValue() == 0; } + bool isVector() const { return Scale.hasValue() && Scale.getValue() != 0; } bool isVector(unsigned Width) const { return isVector() && ElementBitwidth == Width; } diff --git a/clang/include/clang/Tooling/DependencyScanning/DependencyScanningFilesystem.h b/clang/include/clang/Tooling/DependencyScanning/DependencyScanningFilesystem.h index b3882c2..e0d16df 100644 --- a/clang/include/clang/Tooling/DependencyScanning/DependencyScanningFilesystem.h +++ b/clang/include/clang/Tooling/DependencyScanning/DependencyScanningFilesystem.h @@ -94,9 +94,9 @@ public: assert(!isDirectory() && "not a file"); assert(Contents && "contents not initialized"); if (auto *Directives = Contents->DepDirectives.load()) { - if (Directives->has_value()) + if (Directives->hasValue()) return ArrayRef<dependency_directives_scan::Directive>( - Directives->value()); + Directives->getValue()); } return None; } diff --git a/clang/lib/AST/AttrImpl.cpp b/clang/lib/AST/AttrImpl.cpp index deb28be..7b8acfc 100644 --- a/clang/lib/AST/AttrImpl.cpp +++ b/clang/lib/AST/AttrImpl.cpp @@ -168,24 +168,24 @@ OMPDeclareTargetDeclAttr::getActiveAttr(const ValueDecl *VD) { llvm::Optional<OMPDeclareTargetDeclAttr::MapTypeTy> OMPDeclareTargetDeclAttr::isDeclareTargetDeclaration(const ValueDecl *VD) { llvm::Optional<OMPDeclareTargetDeclAttr *> ActiveAttr = getActiveAttr(VD); - if (ActiveAttr) - return ActiveAttr.value()->getMapType(); + if (ActiveAttr.hasValue()) + return ActiveAttr.getValue()->getMapType(); return llvm::None; } llvm::Optional<OMPDeclareTargetDeclAttr::DevTypeTy> OMPDeclareTargetDeclAttr::getDeviceType(const ValueDecl *VD) { llvm::Optional<OMPDeclareTargetDeclAttr *> ActiveAttr = getActiveAttr(VD); - if (ActiveAttr) - return ActiveAttr.value()->getDevType(); + if (ActiveAttr.hasValue()) + return ActiveAttr.getValue()->getDevType(); return llvm::None; } llvm::Optional<SourceLocation> OMPDeclareTargetDeclAttr::getLocation(const ValueDecl *VD) { llvm::Optional<OMPDeclareTargetDeclAttr *> ActiveAttr = getActiveAttr(VD); - if (ActiveAttr) - return ActiveAttr.value()->getRange().getBegin(); + if (ActiveAttr.hasValue()) + return ActiveAttr.getValue()->getRange().getBegin(); return llvm::None; } diff --git a/clang/lib/ASTMatchers/Dynamic/Parser.cpp b/clang/lib/ASTMatchers/Dynamic/Parser.cpp index 6470df2..ec14f7a 100644 --- a/clang/lib/ASTMatchers/Dynamic/Parser.cpp +++ b/clang/lib/ASTMatchers/Dynamic/Parser.cpp @@ -397,9 +397,9 @@ bool Parser::parseIdentifierPrefixImpl(VariantValue *Value) { assert(NamedValue.isMatcher()); llvm::Optional<DynTypedMatcher> Result = NamedValue.getMatcher().getSingleMatcher(); - if (Result) { + if (Result.hasValue()) { llvm::Optional<DynTypedMatcher> Bound = Result->tryBind(BindID); - if (Bound) { + if (Bound.hasValue()) { *Value = VariantMatcher::SingleMatcher(*Bound); return true; } diff --git a/clang/lib/ASTMatchers/Dynamic/Registry.cpp b/clang/lib/ASTMatchers/Dynamic/Registry.cpp index 42193e6..72629d0 100644 --- a/clang/lib/ASTMatchers/Dynamic/Registry.cpp +++ b/clang/lib/ASTMatchers/Dynamic/Registry.cpp @@ -797,9 +797,9 @@ VariantMatcher Registry::constructBoundMatcher(MatcherCtor Ctor, if (Out.isNull()) return Out; llvm::Optional<DynTypedMatcher> Result = Out.getSingleMatcher(); - if (Result) { + if (Result.hasValue()) { llvm::Optional<DynTypedMatcher> Bound = Result->tryBind(BindID); - if (Bound) { + if (Bound.hasValue()) { return VariantMatcher::SingleMatcher(*Bound); } } diff --git a/clang/lib/Analysis/BodyFarm.cpp b/clang/lib/Analysis/BodyFarm.cpp index f182506..3587cf4 100644 --- a/clang/lib/Analysis/BodyFarm.cpp +++ b/clang/lib/Analysis/BodyFarm.cpp @@ -697,8 +697,8 @@ static Stmt *create_OSAtomicCompareAndSwap(ASTContext &C, const FunctionDecl *D) Stmt *BodyFarm::getBody(const FunctionDecl *D) { Optional<Stmt *> &Val = Bodies[D]; - if (Val) - return *Val; + if (Val.hasValue()) + return Val.getValue(); Val = nullptr; @@ -872,8 +872,8 @@ Stmt *BodyFarm::getBody(const ObjCMethodDecl *D) { return nullptr; Optional<Stmt *> &Val = Bodies[D]; - if (Val) - return *Val; + if (Val.hasValue()) + return Val.getValue(); Val = nullptr; // For now, we only synthesize getters. diff --git a/clang/lib/Analysis/FlowSensitive/ControlFlowContext.cpp b/clang/lib/Analysis/FlowSensitive/ControlFlowContext.cpp index 3a362d49..c0b8119 100644 --- a/clang/lib/Analysis/FlowSensitive/ControlFlowContext.cpp +++ b/clang/lib/Analysis/FlowSensitive/ControlFlowContext.cpp @@ -31,10 +31,13 @@ buildStmtToBasicBlockMap(const CFG &Cfg) { if (Block == nullptr) continue; - for (const CFGElement &Element : *Block) - if (auto Stmt = Element.getAs<CFGStmt>()) - StmtToBlock[Stmt->getStmt()] = Block; + for (const CFGElement &Element : *Block) { + auto Stmt = Element.getAs<CFGStmt>(); + if (!Stmt.hasValue()) + continue; + StmtToBlock[Stmt.getValue().getStmt()] = Block; + } if (const Stmt *TerminatorStmt = Block->getTerminatorStmt()) StmtToBlock[TerminatorStmt] = Block; } diff --git a/clang/lib/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.cpp b/clang/lib/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.cpp index 0de4bca..68e897e 100644 --- a/clang/lib/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.cpp +++ b/clang/lib/Analysis/FlowSensitive/TypeErasedDataflowAnalysis.cpp @@ -50,8 +50,8 @@ public: auto BlockIT = CFCtx.getStmtToBlock().find(&ignoreCFGOmittedNodes(S)); assert(BlockIT != CFCtx.getStmtToBlock().end()); const auto &State = BlockToState[BlockIT->getSecond()->getBlockID()]; - assert(State); - return &State->Env; + assert(State.hasValue()); + return &State.getValue().Env; } private: @@ -209,10 +209,10 @@ static TypeErasedDataflowAnalysisState computeBlockInputState( // loop back edge to `Block`. const llvm::Optional<TypeErasedDataflowAnalysisState> &MaybePredState = BlockStates[Pred->getBlockID()]; - if (!MaybePredState) + if (!MaybePredState.hasValue()) continue; - TypeErasedDataflowAnalysisState PredState = *MaybePredState; + TypeErasedDataflowAnalysisState PredState = MaybePredState.getValue(); if (ApplyBuiltinTransfer) { if (const Stmt *PredTerminatorStmt = Pred->getTerminatorStmt()) { const StmtToEnvMapImpl StmtToEnv(CFCtx, BlockStates); @@ -222,14 +222,14 @@ static TypeErasedDataflowAnalysisState computeBlockInputState( } } - if (MaybeState) { + if (MaybeState.hasValue()) { Analysis.joinTypeErased(MaybeState->Lattice, PredState.Lattice); MaybeState->Env.join(PredState.Env, Analysis); } else { MaybeState = std::move(PredState); } } - if (!MaybeState) { + if (!MaybeState.hasValue()) { // FIXME: Consider passing `Block` to `Analysis.typeErasedInitialElement()` // to enable building analyses like computation of dominators that // initialize the state of each basic block differently. @@ -367,8 +367,8 @@ runTypeErasedDataflowAnalysis(const ControlFlowContext &CFCtx, TypeErasedDataflowAnalysisState NewBlockState = transferBlock(CFCtx, BlockStates, *Block, InitEnv, Analysis); - if (OldBlockState && - Analysis.isEqualTypeErased(OldBlockState->Lattice, + if (OldBlockState.hasValue() && + Analysis.isEqualTypeErased(OldBlockState.getValue().Lattice, NewBlockState.Lattice) && OldBlockState->Env.equivalentTo(NewBlockState.Env, Analysis)) { // The state of `Block` didn't change after transfer so there's no need to diff --git a/clang/lib/Analysis/PathDiagnostic.cpp b/clang/lib/Analysis/PathDiagnostic.cpp index b5be645..90c4624 100644 --- a/clang/lib/Analysis/PathDiagnostic.cpp +++ b/clang/lib/Analysis/PathDiagnostic.cpp @@ -319,8 +319,8 @@ static Optional<bool> comparePath(const PathPieces &X, const PathPieces &Y) { for ( ; X_I != X_end && Y_I != Y_end; ++X_I, ++Y_I) { Optional<bool> b = comparePiece(**X_I, **Y_I); - if (b) - return *b; + if (b.hasValue()) + return b.getValue(); } return None; @@ -396,8 +396,8 @@ static bool compare(const PathDiagnostic &X, const PathDiagnostic &Y) { return (*XI) < (*YI); } Optional<bool> b = comparePath(X.path, Y.path); - assert(b); - return *b; + assert(b.hasValue()); + return b.getValue(); } void PathDiagnosticConsumer::FlushDiagnostics( diff --git a/clang/lib/Analysis/UninitializedValues.cpp b/clang/lib/Analysis/UninitializedValues.cpp index f1be392..811146e 100644 --- a/clang/lib/Analysis/UninitializedValues.cpp +++ b/clang/lib/Analysis/UninitializedValues.cpp @@ -148,8 +148,8 @@ public: Value getValue(const CFGBlock *block, const CFGBlock *dstBlock, const VarDecl *vd) { const Optional<unsigned> &idx = declToIndex.getValueIndex(vd); - assert(idx); - return getValueVector(block)[*idx]; + assert(idx.hasValue()); + return getValueVector(block)[idx.getValue()]; } }; @@ -209,8 +209,8 @@ void CFGBlockValues::resetScratch() { ValueVector::reference CFGBlockValues::operator[](const VarDecl *vd) { const Optional<unsigned> &idx = declToIndex.getValueIndex(vd); - assert(idx); - return scratch[*idx]; + assert(idx.hasValue()); + return scratch[idx.getValue()]; } //------------------------------------------------------------------------====// diff --git a/clang/lib/Basic/Targets/RISCV.cpp b/clang/lib/Basic/Targets/RISCV.cpp index 722a605..098bf21 100644 --- a/clang/lib/Basic/Targets/RISCV.cpp +++ b/clang/lib/Basic/Targets/RISCV.cpp @@ -251,8 +251,8 @@ bool RISCVTargetInfo::hasFeature(StringRef Feature) const { .Case("riscv64", Is64Bit) .Case("64bit", Is64Bit) .Default(None); - if (Result) - return *Result; + if (Result.hasValue()) + return Result.getValue(); if (ISAInfo->isSupportedExtensionFeature(Feature)) return ISAInfo->hasExtension(Feature); diff --git a/clang/lib/CodeGen/CGClass.cpp b/clang/lib/CodeGen/CGClass.cpp index ec9e325..153f299 100644 --- a/clang/lib/CodeGen/CGClass.cpp +++ b/clang/lib/CodeGen/CGClass.cpp @@ -1782,15 +1782,15 @@ namespace { if (!StartIndex) StartIndex = FieldIndex; } else if (StartIndex) { - EHStack.pushCleanup<SanitizeDtorFieldRange>(NormalAndEHCleanup, DD, - *StartIndex, FieldIndex); + EHStack.pushCleanup<SanitizeDtorFieldRange>( + NormalAndEHCleanup, DD, StartIndex.getValue(), FieldIndex); StartIndex = None; } } void End() { if (StartIndex) EHStack.pushCleanup<SanitizeDtorFieldRange>(NormalAndEHCleanup, DD, - *StartIndex, -1); + StartIndex.getValue(), -1); } }; } // end anonymous namespace diff --git a/clang/lib/CodeGen/CodeGenModule.cpp b/clang/lib/CodeGen/CodeGenModule.cpp index 34d8b3a..17b8e6b 100644 --- a/clang/lib/CodeGen/CodeGenModule.cpp +++ b/clang/lib/CodeGen/CodeGenModule.cpp @@ -2826,12 +2826,12 @@ bool CodeGenModule::isProfileInstrExcluded(llvm::Function *Fn, CodeGenOptions::ProfileInstrKind Kind = getCodeGenOpts().getProfileInstr(); // First, check the function name. Optional<bool> V = ProfileList.isFunctionExcluded(Fn->getName(), Kind); - if (V) + if (V.hasValue()) return *V; // Next, check the source location. if (Loc.isValid()) { Optional<bool> V = ProfileList.isLocationExcluded(Loc, Kind); - if (V) + if (V.hasValue()) return *V; } // If location is unknown, this may be a compiler-generated function. Assume diff --git a/clang/lib/Driver/Driver.cpp b/clang/lib/Driver/Driver.cpp index 721c8f8..d831422 100644 --- a/clang/lib/Driver/Driver.cpp +++ b/clang/lib/Driver/Driver.cpp @@ -3325,8 +3325,8 @@ class OffloadingActionBuilder final { A = C.getDriver().ConstructPhaseAction(C, Args, CurPhase, A, AssociatedOffloadKind); - if (CompileDeviceOnly && CurPhase == FinalPhase && BundleOutput && - *BundleOutput) { + if (CompileDeviceOnly && CurPhase == FinalPhase && + BundleOutput.hasValue() && BundleOutput.getValue()) { for (unsigned I = 0, E = GpuArchList.size(); I != E; ++I) { OffloadAction::DeviceDependences DDep; DDep.add(*CudaDeviceActions[I], *ToolChains.front(), GpuArchList[I], diff --git a/clang/lib/Driver/ToolChains/AVR.cpp b/clang/lib/Driver/ToolChains/AVR.cpp index 0b68a32..2547d13 100644 --- a/clang/lib/Driver/ToolChains/AVR.cpp +++ b/clang/lib/Driver/ToolChains/AVR.cpp @@ -475,9 +475,9 @@ void AVR::Linker::ConstructJob(Compilation &C, const JobAction &JA, D.Diag(diag::warn_drv_avr_stdlib_not_linked); } - if (SectionAddressData) { - std::string DataSectionArg = - std::string("-Tdata=0x") + llvm::utohexstr(*SectionAddressData); + if (SectionAddressData.hasValue()) { + std::string DataSectionArg = std::string("-Tdata=0x") + + llvm::utohexstr(SectionAddressData.getValue()); CmdArgs.push_back(Args.MakeArgString(DataSectionArg)); } else { // We do not have an entry for this CPU in the address mapping table yet. diff --git a/clang/lib/Driver/ToolChains/Clang.cpp b/clang/lib/Driver/ToolChains/Clang.cpp index 286d414..5142b72 100644 --- a/clang/lib/Driver/ToolChains/Clang.cpp +++ b/clang/lib/Driver/ToolChains/Clang.cpp @@ -2340,8 +2340,8 @@ void Clang::AddHexagonTargetArgs(const ArgList &Args, if (auto G = toolchains::HexagonToolChain::getSmallDataThreshold(Args)) { CmdArgs.push_back("-mllvm"); - CmdArgs.push_back( - Args.MakeArgString("-hexagon-small-data-threshold=" + Twine(*G))); + CmdArgs.push_back(Args.MakeArgString("-hexagon-small-data-threshold=" + + Twine(G.getValue()))); } if (!Args.hasArg(options::OPT_fno_short_enums)) diff --git a/clang/lib/Driver/ToolChains/Gnu.cpp b/clang/lib/Driver/ToolChains/Gnu.cpp index d813def..dc99010 100644 --- a/clang/lib/Driver/ToolChains/Gnu.cpp +++ b/clang/lib/Driver/ToolChains/Gnu.cpp @@ -2086,8 +2086,8 @@ void Generic_GCC::GCCInstallationDetector::print(raw_ostream &OS) const { } bool Generic_GCC::GCCInstallationDetector::getBiarchSibling(Multilib &M) const { - if (BiarchSibling) { - M = *BiarchSibling; + if (BiarchSibling.hasValue()) { + M = BiarchSibling.getValue(); return true; } return false; diff --git a/clang/lib/Driver/ToolChains/Hexagon.cpp b/clang/lib/Driver/ToolChains/Hexagon.cpp index e129e30..9142dba 100644 --- a/clang/lib/Driver/ToolChains/Hexagon.cpp +++ b/clang/lib/Driver/ToolChains/Hexagon.cpp @@ -340,8 +340,8 @@ constructHexagonLinkArgs(Compilation &C, const JobAction &JA, CmdArgs.push_back("-pie"); if (auto G = toolchains::HexagonToolChain::getSmallDataThreshold(Args)) { - CmdArgs.push_back(Args.MakeArgString("-G" + Twine(*G))); - UseG0 = *G == 0; + CmdArgs.push_back(Args.MakeArgString("-G" + Twine(G.getValue()))); + UseG0 = G.getValue() == 0; } CmdArgs.push_back("-o"); diff --git a/clang/lib/Edit/RewriteObjCFoundationAPI.cpp b/clang/lib/Edit/RewriteObjCFoundationAPI.cpp index 1ca041f..589bf8d 100644 --- a/clang/lib/Edit/RewriteObjCFoundationAPI.cpp +++ b/clang/lib/Edit/RewriteObjCFoundationAPI.cpp @@ -725,11 +725,11 @@ static bool getLiteralInfo(SourceRange literalRange, break; } - if (!UpperU && !UpperL) + if (!UpperU.hasValue() && !UpperL.hasValue()) UpperU = UpperL = true; - else if (UpperU && !UpperL) + else if (UpperU.hasValue() && !UpperL.hasValue()) UpperL = UpperU; - else if (UpperL && !UpperU) + else if (UpperL.hasValue() && !UpperU.hasValue()) UpperU = UpperL; Info.U = *UpperU ? "U" : "u"; diff --git a/clang/lib/ExtractAPI/Serialization/SymbolGraphSerializer.cpp b/clang/lib/ExtractAPI/Serialization/SymbolGraphSerializer.cpp index b1450b2..c4797ce 100644 --- a/clang/lib/ExtractAPI/Serialization/SymbolGraphSerializer.cpp +++ b/clang/lib/ExtractAPI/Serialization/SymbolGraphSerializer.cpp @@ -31,14 +31,14 @@ namespace { /// at position \p Key. void serializeObject(Object &Paren, StringRef Key, Optional<Object> Obj) { if (Obj) - Paren[Key] = std::move(*Obj); + Paren[Key] = std::move(Obj.getValue()); } /// Helper function to inject a JSON array \p Array into object \p Paren at /// position \p Key. void serializeArray(Object &Paren, StringRef Key, Optional<Array> Array) { if (Array) - Paren[Key] = std::move(*Array); + Paren[Key] = std::move(Array.getValue()); } /// Serialize a \c VersionTuple \p V with the Symbol Graph semantic version diff --git a/clang/lib/Frontend/CompilerInstance.cpp b/clang/lib/Frontend/CompilerInstance.cpp index 95e5b04..b982ca7 100644 --- a/clang/lib/Frontend/CompilerInstance.cpp +++ b/clang/lib/Frontend/CompilerInstance.cpp @@ -115,9 +115,9 @@ bool CompilerInstance::createTarget() { auto TO = std::make_shared<TargetOptions>(); TO->Triple = llvm::Triple::normalize(getFrontendOpts().AuxTriple); if (getFrontendOpts().AuxTargetCPU) - TO->CPU = *getFrontendOpts().AuxTargetCPU; + TO->CPU = getFrontendOpts().AuxTargetCPU.getValue(); if (getFrontendOpts().AuxTargetFeatures) - TO->FeaturesAsWritten = *getFrontendOpts().AuxTargetFeatures; + TO->FeaturesAsWritten = getFrontendOpts().AuxTargetFeatures.getValue(); TO->HostTriple = getTarget().getTriple().str(); setAuxTarget(TargetInfo::CreateTargetInfo(getDiagnostics(), TO)); } diff --git a/clang/lib/Frontend/CompilerInvocation.cpp b/clang/lib/Frontend/CompilerInvocation.cpp index 4b53d6d..c0eed3a 100644 --- a/clang/lib/Frontend/CompilerInvocation.cpp +++ b/clang/lib/Frontend/CompilerInvocation.cpp @@ -1951,8 +1951,8 @@ bool CompilerInvocation::ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, << "-fdiagnostics-hotness-threshold="; } else { Opts.DiagnosticsHotnessThreshold = *ResultOrErr; - if ((!Opts.DiagnosticsHotnessThreshold || - *Opts.DiagnosticsHotnessThreshold > 0) && + if ((!Opts.DiagnosticsHotnessThreshold.hasValue() || + Opts.DiagnosticsHotnessThreshold.getValue() > 0) && !UsingProfile) Diags.Report(diag::warn_drv_diagnostics_hotness_requires_pgo) << "-fdiagnostics-hotness-threshold="; @@ -1968,8 +1968,8 @@ bool CompilerInvocation::ParseCodeGenArgs(CodeGenOptions &Opts, ArgList &Args, << "-fdiagnostics-misexpect-tolerance="; } else { Opts.DiagnosticsMisExpectTolerance = *ResultOrErr; - if ((!Opts.DiagnosticsMisExpectTolerance || - *Opts.DiagnosticsMisExpectTolerance > 0) && + if ((!Opts.DiagnosticsMisExpectTolerance.hasValue() || + Opts.DiagnosticsMisExpectTolerance.getValue() > 0) && !UsingProfile) Diags.Report(diag::warn_drv_diagnostics_misexpect_requires_pgo) << "-fdiagnostics-misexpect-tolerance="; @@ -2578,10 +2578,10 @@ static void GenerateFrontendArgs(const FrontendOptions &Opts, for (const auto &ModuleFile : Opts.ModuleFiles) GenerateArg(Args, OPT_fmodule_file, ModuleFile, SA); - if (Opts.AuxTargetCPU) + if (Opts.AuxTargetCPU.hasValue()) GenerateArg(Args, OPT_aux_target_cpu, *Opts.AuxTargetCPU, SA); - if (Opts.AuxTargetFeatures) + if (Opts.AuxTargetFeatures.hasValue()) for (const auto &Feature : *Opts.AuxTargetFeatures) GenerateArg(Args, OPT_aux_target_feature, Feature, SA); diff --git a/clang/lib/Frontend/InitPreprocessor.cpp b/clang/lib/Frontend/InitPreprocessor.cpp index 033f332..1032cb2 100644 --- a/clang/lib/Frontend/InitPreprocessor.cpp +++ b/clang/lib/Frontend/InitPreprocessor.cpp @@ -831,12 +831,12 @@ static void InitializePredefinedMacros(const TargetInfo &TI, VersionTuple tuple = LangOpts.ObjCRuntime.getVersion(); unsigned minor = 0; - if (tuple.getMinor()) - minor = *tuple.getMinor(); + if (tuple.getMinor().hasValue()) + minor = tuple.getMinor().getValue(); unsigned subminor = 0; - if (tuple.getSubminor()) - subminor = *tuple.getSubminor(); + if (tuple.getSubminor().hasValue()) + subminor = tuple.getSubminor().getValue(); Builder.defineMacro("__OBJFW_RUNTIME_ABI__", Twine(tuple.getMajor() * 10000 + minor * 100 + diff --git a/clang/lib/Lex/DependencyDirectivesScanner.cpp b/clang/lib/Lex/DependencyDirectivesScanner.cpp index d7c40e2..d858384 100644 --- a/clang/lib/Lex/DependencyDirectivesScanner.cpp +++ b/clang/lib/Lex/DependencyDirectivesScanner.cpp @@ -549,8 +549,8 @@ Scanner::tryLexIdentifierOrSkipLine(const char *&First, const char *const End) { StringRef Scanner::lexIdentifier(const char *&First, const char *const End) { Optional<StringRef> Id = tryLexIdentifierOrSkipLine(First, End); - assert(Id && "expected identifier token"); - return *Id; + assert(Id.hasValue() && "expected identifier token"); + return Id.getValue(); } bool Scanner::isNextIdentifierOrSkipLine(StringRef Id, const char *&First, diff --git a/clang/lib/Lex/MacroInfo.cpp b/clang/lib/Lex/MacroInfo.cpp index 54445d9..4a8127d 100644 --- a/clang/lib/Lex/MacroInfo.cpp +++ b/clang/lib/Lex/MacroInfo.cpp @@ -209,11 +209,12 @@ MacroDirective::DefInfo MacroDirective::getDefinition() { } VisibilityMacroDirective *VisMD = cast<VisibilityMacroDirective>(MD); - if (!isPublic) + if (!isPublic.hasValue()) isPublic = VisMD->isPublic(); } - return DefInfo(nullptr, UndefLoc, !isPublic || *isPublic); + return DefInfo(nullptr, UndefLoc, + !isPublic.hasValue() || isPublic.getValue()); } const MacroDirective::DefInfo diff --git a/clang/lib/Lex/ModuleMap.cpp b/clang/lib/Lex/ModuleMap.cpp index 57e3446..c791e3e 100644 --- a/clang/lib/Lex/ModuleMap.cpp +++ b/clang/lib/Lex/ModuleMap.cpp @@ -1219,8 +1219,8 @@ void ModuleMap::resolveHeaderDirectives( Module *Mod, llvm::Optional<const FileEntry *> File) const { bool NeedsFramework = false; SmallVector<Module::UnresolvedHeaderDirective, 1> NewHeaders; - const auto Size = File ? File.value()->getSize() : 0; - const auto ModTime = File ? File.value()->getModificationTime() : 0; + const auto Size = File ? File.getValue()->getSize() : 0; + const auto ModTime = File ? File.getValue()->getModificationTime() : 0; for (auto &Header : Mod->UnresolvedHeaders) { if (File && ((Header.ModTime && Header.ModTime != ModTime) || diff --git a/clang/lib/Lex/PPMacroExpansion.cpp b/clang/lib/Lex/PPMacroExpansion.cpp index fb0d67d..49e1473 100644 --- a/clang/lib/Lex/PPMacroExpansion.cpp +++ b/clang/lib/Lex/PPMacroExpansion.cpp @@ -1325,11 +1325,11 @@ already_lexed: // The last ')' has been reached; return the value if one found or // a diagnostic and a dummy value. - if (Result) { - OS << *Result; + if (Result.hasValue()) { + OS << Result.getValue(); // For strict conformance to __has_cpp_attribute rules, use 'L' // suffix for dated literals. - if (*Result > 1) + if (Result.getValue() > 1) OS << 'L'; } else { OS << 0; diff --git a/clang/lib/Lex/PreprocessingRecord.cpp b/clang/lib/Lex/PreprocessingRecord.cpp index 66610c4..432068b 100644 --- a/clang/lib/Lex/PreprocessingRecord.cpp +++ b/clang/lib/Lex/PreprocessingRecord.cpp @@ -114,8 +114,8 @@ bool PreprocessingRecord::isEntityInFileID(iterator PPEI, FileID FID) { // deserializing it. Optional<bool> IsInFile = ExternalSource->isPreprocessedEntityInFileID(LoadedIndex, FID); - if (IsInFile) - return *IsInFile; + if (IsInFile.hasValue()) + return IsInFile.getValue(); // The external source did not provide a definite answer, go and deserialize // the entity to check it. diff --git a/clang/lib/Parse/ParseOpenMP.cpp b/clang/lib/Parse/ParseOpenMP.cpp index d508d2d..1fa82a1 100644 --- a/clang/lib/Parse/ParseOpenMP.cpp +++ b/clang/lib/Parse/ParseOpenMP.cpp @@ -1873,13 +1873,14 @@ void Parser::ParseOMPDeclareTargetClauses( if (IsDeviceTypeClause) { Optional<SimpleClauseData> DevTypeData = parseOpenMPSimpleClause(*this, OMPC_device_type); - if (DevTypeData) { + if (DevTypeData.hasValue()) { if (DeviceTypeLoc.isValid()) { // We already saw another device_type clause, diagnose it. - Diag(DevTypeData->Loc, diag::warn_omp_more_one_device_type_clause); + Diag(DevTypeData.getValue().Loc, + diag::warn_omp_more_one_device_type_clause); break; } - switch (static_cast<OpenMPDeviceType>(DevTypeData->Type)) { + switch (static_cast<OpenMPDeviceType>(DevTypeData.getValue().Type)) { case OMPC_DEVICE_TYPE_any: DTCI.DT = OMPDeclareTargetDeclAttr::DT_Any; break; @@ -2312,9 +2313,9 @@ Parser::DeclGroupPtrTy Parser::ParseOpenMPDeclarativeDirectiveWithExtDecl( Sema::DeclareTargetContextInfo DTCI(DKind, DTLoc); if (HasClauses) ParseOMPDeclareTargetClauses(DTCI); - bool HasImplicitMappings = DKind == OMPD_begin_declare_target || - !HasClauses || - (DTCI.ExplicitlyMapped.empty() && DTCI.Indirect); + bool HasImplicitMappings = + DKind == OMPD_begin_declare_target || !HasClauses || + (DTCI.ExplicitlyMapped.empty() && DTCI.Indirect.hasValue()); // Skip the last annot_pragma_openmp_end. ConsumeAnyToken(); @@ -3619,18 +3620,20 @@ OMPClause *Parser::ParseOpenMPSimpleClause(OpenMPClauseKind Kind, if (!Val || ParseOnly) return nullptr; if (getLangOpts().OpenMP < 51 && Kind == OMPC_default && - (static_cast<DefaultKind>(Val->Type) == OMP_DEFAULT_private || - static_cast<DefaultKind>(Val->Type) == OMP_DEFAULT_firstprivate)) { - Diag(Val->LOpen, diag::err_omp_invalid_dsa) - << getOpenMPClauseName(static_cast<DefaultKind>(Val->Type) == + (static_cast<DefaultKind>(Val.getValue().Type) == OMP_DEFAULT_private || + static_cast<DefaultKind>(Val.getValue().Type) == + OMP_DEFAULT_firstprivate)) { + Diag(Val.getValue().LOpen, diag::err_omp_invalid_dsa) + << getOpenMPClauseName(static_cast<DefaultKind>(Val.getValue().Type) == OMP_DEFAULT_private ? OMPC_private : OMPC_firstprivate) << getOpenMPClauseName(OMPC_default) << "5.1"; return nullptr; } - return Actions.ActOnOpenMPSimpleClause(Kind, Val->Type, Val->TypeLoc, - Val->LOpen, Val->Loc, Val->RLoc); + return Actions.ActOnOpenMPSimpleClause( + Kind, Val.getValue().Type, Val.getValue().TypeLoc, Val.getValue().LOpen, + Val.getValue().Loc, Val.getValue().RLoc); } /// Parsing of OpenMP clauses like 'ordered'. diff --git a/clang/lib/Sema/SemaCUDA.cpp b/clang/lib/Sema/SemaCUDA.cpp index a0bc1b5..a3b15fe 100644 --- a/clang/lib/Sema/SemaCUDA.cpp +++ b/clang/lib/Sema/SemaCUDA.cpp @@ -381,12 +381,13 @@ bool Sema::inferCUDATargetForImplicitSpecialMember(CXXRecordDecl *ClassDecl, InferredTarget = BaseMethodTarget; } else { bool ResolutionError = resolveCalleeCUDATargetConflict( - *InferredTarget, BaseMethodTarget, InferredTarget.getPointer()); + InferredTarget.getValue(), BaseMethodTarget, + InferredTarget.getPointer()); if (ResolutionError) { if (Diagnose) { Diag(ClassDecl->getLocation(), diag::note_implicit_member_target_infer_collision) - << (unsigned)CSM << *InferredTarget << BaseMethodTarget; + << (unsigned)CSM << InferredTarget.getValue() << BaseMethodTarget; } MemberDecl->addAttr(CUDAInvalidTargetAttr::CreateImplicit(Context)); return true; @@ -424,12 +425,14 @@ bool Sema::inferCUDATargetForImplicitSpecialMember(CXXRecordDecl *ClassDecl, InferredTarget = FieldMethodTarget; } else { bool ResolutionError = resolveCalleeCUDATargetConflict( - *InferredTarget, FieldMethodTarget, InferredTarget.getPointer()); + InferredTarget.getValue(), FieldMethodTarget, + InferredTarget.getPointer()); if (ResolutionError) { if (Diagnose) { Diag(ClassDecl->getLocation(), diag::note_implicit_member_target_infer_collision) - << (unsigned)CSM << *InferredTarget << FieldMethodTarget; + << (unsigned)CSM << InferredTarget.getValue() + << FieldMethodTarget; } MemberDecl->addAttr(CUDAInvalidTargetAttr::CreateImplicit(Context)); return true; @@ -441,10 +444,10 @@ bool Sema::inferCUDATargetForImplicitSpecialMember(CXXRecordDecl *ClassDecl, // If no target was inferred, mark this member as __host__ __device__; // it's the least restrictive option that can be invoked from any target. bool NeedsH = true, NeedsD = true; - if (InferredTarget) { - if (*InferredTarget == CFT_Device) + if (InferredTarget.hasValue()) { + if (InferredTarget.getValue() == CFT_Device) NeedsH = false; - else if (*InferredTarget == CFT_Host) + else if (InferredTarget.getValue() == CFT_Host) NeedsD = false; } diff --git a/clang/lib/Sema/SemaChecking.cpp b/clang/lib/Sema/SemaChecking.cpp index c83f648..28cfdfc 100644 --- a/clang/lib/Sema/SemaChecking.cpp +++ b/clang/lib/Sema/SemaChecking.cpp @@ -1873,9 +1873,9 @@ static ExprResult SemaBuiltinLaunder(Sema &S, CallExpr *TheCall) { return 2; return llvm::Optional<unsigned>{}; }(); - if (DiagSelect) { + if (DiagSelect.hasValue()) { S.Diag(TheCall->getBeginLoc(), diag::err_builtin_launder_invalid_arg) - << *DiagSelect << TheCall->getSourceRange(); + << DiagSelect.getValue() << TheCall->getSourceRange(); return ExprError(); } diff --git a/clang/lib/Sema/SemaCodeComplete.cpp b/clang/lib/Sema/SemaCodeComplete.cpp index 86bad73..8c9ed53 100644 --- a/clang/lib/Sema/SemaCodeComplete.cpp +++ b/clang/lib/Sema/SemaCodeComplete.cpp @@ -5362,8 +5362,8 @@ private: // Overwrite existing if the new member has more info. // The preference of . vs :: vs -> is fairly arbitrary. if (/*Inserted*/ R.second || - std::make_tuple(M.ArgTypes.has_value(), M.ResultType != nullptr, - M.Operator) > std::make_tuple(O.ArgTypes.has_value(), + std::make_tuple(M.ArgTypes.hasValue(), M.ResultType != nullptr, + M.Operator) > std::make_tuple(O.ArgTypes.hasValue(), O.ResultType != nullptr, O.Operator)) O = std::move(M); diff --git a/clang/lib/Sema/SemaDecl.cpp b/clang/lib/Sema/SemaDecl.cpp index c9c32f9..2e06207 100644 --- a/clang/lib/Sema/SemaDecl.cpp +++ b/clang/lib/Sema/SemaDecl.cpp @@ -15444,9 +15444,9 @@ void Sema::AddKnownFunctionAttributesForReplaceableGlobalAllocationFunction( // (3.1) If the allocation function takes an argument of type // std​::​align_Âval_Ât, the storage will have the alignment // specified by the value of this argument. - if (AlignmentParam && !FD->hasAttr<AllocAlignAttr>()) { + if (AlignmentParam.hasValue() && !FD->hasAttr<AllocAlignAttr>()) { FD->addAttr(AllocAlignAttr::CreateImplicit( - Context, ParamIdx(*AlignmentParam, FD), FD->getLocation())); + Context, ParamIdx(AlignmentParam.getValue(), FD), FD->getLocation())); } // FIXME: @@ -19102,12 +19102,12 @@ Sema::FunctionEmissionStatus Sema::getEmissionStatus(FunctionDecl *FD, // #pragma omp declare target to(*) device_type(*). // Therefore DevTy having no value does not imply host. The emission status // will be checked again at the end of compilation unit with Final = true. - if (DevTy) + if (DevTy.hasValue()) if (*DevTy == OMPDeclareTargetDeclAttr::DT_Host) return FunctionEmissionStatus::OMPDiscarded; // If we have an explicit value for the device type, or we are in a target // declare context, we need to emit all extern and used symbols. - if (isInOpenMPDeclareTargetContext() || DevTy) + if (isInOpenMPDeclareTargetContext() || DevTy.hasValue()) if (IsEmittedForExternalSymbol()) return FunctionEmissionStatus::Emitted; // Device mode only emits what it must, if it wasn't tagged yet and needed, diff --git a/clang/lib/Sema/SemaDeclAttr.cpp b/clang/lib/Sema/SemaDeclAttr.cpp index 942e7f1..73a4be5 100644 --- a/clang/lib/Sema/SemaDeclAttr.cpp +++ b/clang/lib/Sema/SemaDeclAttr.cpp @@ -2673,19 +2673,19 @@ static void handleAvailabilityAttr(Sema &S, Decl *D, const ParsedAttr &AL) { if (IOSToWatchOSMapping) { if (auto MappedVersion = IOSToWatchOSMapping->map( Version, MinimumWatchOSVersion, None)) { - return *MappedVersion; + return MappedVersion.getValue(); } } auto Major = Version.getMajor(); auto NewMajor = Major >= 9 ? Major - 7 : 0; if (NewMajor >= 2) { - if (Version.getMinor()) { - if (Version.getSubminor()) - return VersionTuple(NewMajor, *Version.getMinor(), - *Version.getSubminor()); + if (Version.getMinor().hasValue()) { + if (Version.getSubminor().hasValue()) + return VersionTuple(NewMajor, Version.getMinor().getValue(), + Version.getSubminor().getValue()); else - return VersionTuple(NewMajor, *Version.getMinor()); + return VersionTuple(NewMajor, Version.getMinor().getValue()); } return VersionTuple(NewMajor); } diff --git a/clang/lib/Sema/SemaExprCXX.cpp b/clang/lib/Sema/SemaExprCXX.cpp index 1e7975e..bb1cf4b 100644 --- a/clang/lib/Sema/SemaExprCXX.cpp +++ b/clang/lib/Sema/SemaExprCXX.cpp @@ -2274,10 +2274,10 @@ Sema::BuildCXXNew(SourceRange Range, bool UseGlobal, // How many bytes do we want to allocate here? llvm::Optional<llvm::APInt> AllocationSize; - if (!ArraySize && !AllocType->isDependentType()) { + if (!ArraySize.hasValue() && !AllocType->isDependentType()) { // For non-array operator new, we only want to allocate one element. AllocationSize = SingleEltSize; - } else if (KnownArraySize && !AllocType->isDependentType()) { + } else if (KnownArraySize.hasValue() && !AllocType->isDependentType()) { // For array operator new, only deal with static array size case. bool Overflow; AllocationSize = llvm::APInt(SizeTyWidth, *KnownArraySize) diff --git a/clang/lib/Sema/SemaOpenMP.cpp b/clang/lib/Sema/SemaOpenMP.cpp index fbea99d..7395e67 100644 --- a/clang/lib/Sema/SemaOpenMP.cpp +++ b/clang/lib/Sema/SemaOpenMP.cpp @@ -822,29 +822,29 @@ public: /// false - otherwise. bool isOrderedRegion() const { if (const SharingMapTy *Top = getTopOfStackOrNull()) - return Top->OrderedRegion.has_value(); + return Top->OrderedRegion.hasValue(); return false; } /// Returns optional parameter for the ordered region. std::pair<const Expr *, OMPOrderedClause *> getOrderedRegionParam() const { if (const SharingMapTy *Top = getTopOfStackOrNull()) - if (Top->OrderedRegion) - return *Top->OrderedRegion; + if (Top->OrderedRegion.hasValue()) + return Top->OrderedRegion.getValue(); return std::make_pair(nullptr, nullptr); } /// Returns true, if parent region is ordered (has associated /// 'ordered' clause), false - otherwise. bool isParentOrderedRegion() const { if (const SharingMapTy *Parent = getSecondOnStackOrNull()) - return Parent->OrderedRegion.has_value(); + return Parent->OrderedRegion.hasValue(); return false; } /// Returns optional parameter for the ordered region. std::pair<const Expr *, OMPOrderedClause *> getParentOrderedRegionParam() const { if (const SharingMapTy *Parent = getSecondOnStackOrNull()) - if (Parent->OrderedRegion) - return *Parent->OrderedRegion; + if (Parent->OrderedRegion.hasValue()) + return Parent->OrderedRegion.getValue(); return std::make_pair(nullptr, nullptr); } /// Marks current region as nowait (it has a 'nowait' clause). @@ -7653,9 +7653,9 @@ public: /// Return true if any expression is dependent. bool dependent() const; /// Returns true if the initializer forms non-rectangular loop. - bool doesInitDependOnLC() const { return InitDependOnLC.has_value(); } + bool doesInitDependOnLC() const { return InitDependOnLC.hasValue(); } /// Returns true if the condition forms non-rectangular loop. - bool doesCondDependOnLC() const { return CondDependOnLC.has_value(); } + bool doesCondDependOnLC() const { return CondDependOnLC.hasValue(); } /// Returns index of the loop we depend on (starting from 1), or 0 otherwise. unsigned getLoopDependentIdx() const { return InitDependOnLC.value_or(CondDependOnLC.value_or(0)); @@ -7761,20 +7761,21 @@ bool OpenMPIterationSpaceChecker::setStep(Expr *NewStep, bool Subtract) { bool IsConstZero = Result && !Result->getBoolValue(); // != with increment is treated as <; != with decrement is treated as > - if (!TestIsLessOp) + if (!TestIsLessOp.hasValue()) TestIsLessOp = IsConstPos || (IsUnsigned && !Subtract); - if (UB && (IsConstZero || - (*TestIsLessOp ? (IsConstNeg || (IsUnsigned && Subtract)) - : (IsConstPos || (IsUnsigned && !Subtract))))) { + if (UB && + (IsConstZero || (TestIsLessOp.getValue() + ? (IsConstNeg || (IsUnsigned && Subtract)) + : (IsConstPos || (IsUnsigned && !Subtract))))) { SemaRef.Diag(NewStep->getExprLoc(), diag::err_omp_loop_incr_not_compatible) - << LCDecl << *TestIsLessOp << NewStep->getSourceRange(); + << LCDecl << TestIsLessOp.getValue() << NewStep->getSourceRange(); SemaRef.Diag(ConditionLoc, diag::note_omp_loop_cond_requres_compatible_incr) - << *TestIsLessOp << ConditionSrcRange; + << TestIsLessOp.getValue() << ConditionSrcRange; return true; } - if (*TestIsLessOp == Subtract) { + if (TestIsLessOp.getValue() == Subtract) { NewStep = SemaRef.CreateBuiltinUnaryOp(NewStep->getExprLoc(), UO_Minus, NewStep) .get(); @@ -8529,8 +8530,8 @@ Expr *OpenMPIterationSpaceChecker::buildNumIterations( UBVal = MinUB.get(); } } - Expr *UBExpr = *TestIsLessOp ? UBVal : LBVal; - Expr *LBExpr = *TestIsLessOp ? LBVal : UBVal; + Expr *UBExpr = TestIsLessOp.getValue() ? UBVal : LBVal; + Expr *LBExpr = TestIsLessOp.getValue() ? LBVal : UBVal; Expr *Upper = tryBuildCapture(SemaRef, UBExpr, Captures).get(); Expr *Lower = tryBuildCapture(SemaRef, LBExpr, Captures).get(); if (!Upper || !Lower) @@ -8593,12 +8594,12 @@ std::pair<Expr *, Expr *> OpenMPIterationSpaceChecker::buildMinMaxValues( // init value. Expr *MinExpr = nullptr; Expr *MaxExpr = nullptr; - Expr *LBExpr = *TestIsLessOp ? LB : UB; - Expr *UBExpr = *TestIsLessOp ? UB : LB; - bool LBNonRect = - *TestIsLessOp ? InitDependOnLC.has_value() : CondDependOnLC.has_value(); - bool UBNonRect = - *TestIsLessOp ? CondDependOnLC.has_value() : InitDependOnLC.has_value(); + Expr *LBExpr = TestIsLessOp.getValue() ? LB : UB; + Expr *UBExpr = TestIsLessOp.getValue() ? UB : LB; + bool LBNonRect = TestIsLessOp.getValue() ? InitDependOnLC.hasValue() + : CondDependOnLC.hasValue(); + bool UBNonRect = TestIsLessOp.getValue() ? CondDependOnLC.hasValue() + : InitDependOnLC.hasValue(); Expr *Lower = LBNonRect ? LBExpr : tryBuildCapture(SemaRef, LBExpr, Captures).get(); Expr *Upper = @@ -8720,11 +8721,11 @@ Expr *OpenMPIterationSpaceChecker::buildPreCond( if (!NewLB.isUsable() || !NewUB.isUsable()) return nullptr; - ExprResult CondExpr = - SemaRef.BuildBinOp(S, DefaultLoc, - *TestIsLessOp ? (TestIsStrictOp ? BO_LT : BO_LE) - : (TestIsStrictOp ? BO_GT : BO_GE), - NewLB.get(), NewUB.get()); + ExprResult CondExpr = SemaRef.BuildBinOp( + S, DefaultLoc, + TestIsLessOp.getValue() ? (TestIsStrictOp ? BO_LT : BO_LE) + : (TestIsStrictOp ? BO_GT : BO_GE), + NewLB.get(), NewUB.get()); if (CondExpr.isUsable()) { if (!SemaRef.Context.hasSameUnqualifiedType(CondExpr.get()->getType(), SemaRef.Context.BoolTy)) @@ -8799,10 +8800,12 @@ Expr *OpenMPIterationSpaceChecker::buildOrderedLoopData( !SemaRef.getLangOpts().CPlusPlus) return nullptr; // Upper - Lower - Expr *Upper = - *TestIsLessOp ? Cnt : tryBuildCapture(SemaRef, LB, Captures).get(); - Expr *Lower = - *TestIsLessOp ? tryBuildCapture(SemaRef, LB, Captures).get() : Cnt; + Expr *Upper = TestIsLessOp.getValue() + ? Cnt + : tryBuildCapture(SemaRef, LB, Captures).get(); + Expr *Lower = TestIsLessOp.getValue() + ? tryBuildCapture(SemaRef, LB, Captures).get() + : Cnt; if (!Upper || !Lower) return nullptr; @@ -22177,27 +22180,27 @@ void Sema::ActOnOpenMPDeclareTargetName(NamedDecl *ND, SourceLocation Loc, auto *VD = cast<ValueDecl>(ND); llvm::Optional<OMPDeclareTargetDeclAttr *> ActiveAttr = OMPDeclareTargetDeclAttr::getActiveAttr(VD); - if (ActiveAttr && (*ActiveAttr)->getDevType() != DTCI.DT && - (*ActiveAttr)->getLevel() == Level) { + if (ActiveAttr.hasValue() && ActiveAttr.getValue()->getDevType() != DTCI.DT && + ActiveAttr.getValue()->getLevel() == Level) { Diag(Loc, diag::err_omp_device_type_mismatch) << OMPDeclareTargetDeclAttr::ConvertDevTypeTyToStr(DTCI.DT) << OMPDeclareTargetDeclAttr::ConvertDevTypeTyToStr( - ActiveAttr.value()->getDevType()); + ActiveAttr.getValue()->getDevType()); return; } - if (ActiveAttr && (*ActiveAttr)->getMapType() != MT && - (*ActiveAttr)->getLevel() == Level) { + if (ActiveAttr.hasValue() && ActiveAttr.getValue()->getMapType() != MT && + ActiveAttr.getValue()->getLevel() == Level) { Diag(Loc, diag::err_omp_declare_target_to_and_link) << ND; return; } - if (ActiveAttr && (*ActiveAttr)->getLevel() == Level) + if (ActiveAttr.hasValue() && ActiveAttr.getValue()->getLevel() == Level) return; Expr *IndirectE = nullptr; bool IsIndirect = false; - if (DTCI.Indirect) { - IndirectE = *DTCI.Indirect; + if (DTCI.Indirect.hasValue()) { + IndirectE = DTCI.Indirect.getValue(); if (!IndirectE) IsIndirect = true; } @@ -22291,13 +22294,13 @@ void Sema::checkDeclIsAllowedInOpenMPTarget(Expr *E, Decl *D, llvm::Optional<OMPDeclareTargetDeclAttr *> ActiveAttr = OMPDeclareTargetDeclAttr::getActiveAttr(VD); unsigned Level = DeclareTargetNesting.size(); - if (ActiveAttr && (*ActiveAttr)->getLevel() >= Level) + if (ActiveAttr.hasValue() && ActiveAttr.getValue()->getLevel() >= Level) return; DeclareTargetContextInfo &DTCI = DeclareTargetNesting.back(); Expr *IndirectE = nullptr; bool IsIndirect = false; - if (DTCI.Indirect) { - IndirectE = *DTCI.Indirect; + if (DTCI.Indirect.hasValue()) { + IndirectE = DTCI.Indirect.getValue(); if (!IndirectE) IsIndirect = true; } diff --git a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp index 4352e7ec..d755801 100644 --- a/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp +++ b/clang/lib/Sema/SemaTemplateInstantiateDecl.cpp @@ -469,8 +469,8 @@ static void instantiateOMPDeclareVariantAttr( if (!DeclVarData) return; - E = DeclVarData->second; - FD = DeclVarData->first; + E = DeclVarData.getValue().second; + FD = DeclVarData.getValue().first; if (auto *VariantDRE = dyn_cast<DeclRefExpr>(E->IgnoreParenImpCasts())) { if (auto *VariantFD = dyn_cast<FunctionDecl>(VariantDRE->getDecl())) { diff --git a/clang/lib/Serialization/ASTWriter.cpp b/clang/lib/Serialization/ASTWriter.cpp index f58f166..1787909 100644 --- a/clang/lib/Serialization/ASTWriter.cpp +++ b/clang/lib/Serialization/ASTWriter.cpp @@ -1888,8 +1888,8 @@ void ASTWriter::WriteHeaderSearch(const HeaderSearch &HS) { // without this file existing on disk. if (!U.Size || (!U.ModTime && IncludeTimestamps)) { PP->Diag(U.FileNameLoc, diag::err_module_no_size_mtime_for_header) - << WritingModule->getFullModuleName() << U.Size.has_value() - << U.FileName; + << WritingModule->getFullModuleName() << U.Size.hasValue() + << U.FileName; continue; } diff --git a/clang/lib/StaticAnalyzer/Checkers/BasicObjCFoundationChecks.cpp b/clang/lib/StaticAnalyzer/Checkers/BasicObjCFoundationChecks.cpp index 16e0b8a..970bfd2 100644 --- a/clang/lib/StaticAnalyzer/Checkers/BasicObjCFoundationChecks.cpp +++ b/clang/lib/StaticAnalyzer/Checkers/BasicObjCFoundationChecks.cpp @@ -766,10 +766,10 @@ void VariadicMethodTypeChecker::checkPreObjCMessage(const ObjCMethodCall &msg, continue; // Generate only one error node to use for all bug reports. - if (!errorNode) + if (!errorNode.hasValue()) errorNode = C.generateNonFatalErrorNode(); - if (!*errorNode) + if (!errorNode.getValue()) continue; SmallString<128> sbuf; @@ -786,8 +786,8 @@ void VariadicMethodTypeChecker::checkPreObjCMessage(const ObjCMethodCall &msg, ArgTy.print(os, C.getLangOpts()); os << "'"; - auto R = - std::make_unique<PathSensitiveBugReport>(*BT, os.str(), *errorNode); + auto R = std::make_unique<PathSensitiveBugReport>(*BT, os.str(), + errorNode.getValue()); R->addRange(msg.getArgSourceRange(I)); C.emitReport(std::move(R)); } diff --git a/clang/lib/StaticAnalyzer/Checkers/GTestChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/GTestChecker.cpp index dbfdff4..0e27377 100644 --- a/clang/lib/StaticAnalyzer/Checkers/GTestChecker.cpp +++ b/clang/lib/StaticAnalyzer/Checkers/GTestChecker.cpp @@ -272,12 +272,12 @@ ProgramStateRef GTestChecker::assumeValuesEqual(SVal Val1, SVal Val2, CheckerContext &C) { auto DVal1 = Val1.getAs<DefinedOrUnknownSVal>(); auto DVal2 = Val2.getAs<DefinedOrUnknownSVal>(); - if (!DVal1 || !DVal2) + if (!DVal1.hasValue() || !DVal2.hasValue()) return State; auto ValuesEqual = C.getSValBuilder().evalEQ(State, *DVal1, *DVal2).getAs<DefinedSVal>(); - if (!ValuesEqual) + if (!ValuesEqual.hasValue()) return State; State = C.getConstraintManager().assume(State, *ValuesEqual, true); diff --git a/clang/lib/StaticAnalyzer/Checkers/MallocChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/MallocChecker.cpp index 2aeb32d..552d042 100644 --- a/clang/lib/StaticAnalyzer/Checkers/MallocChecker.cpp +++ b/clang/lib/StaticAnalyzer/Checkers/MallocChecker.cpp @@ -1190,8 +1190,8 @@ MallocChecker::performKernelMalloc(const CallEvent &Call, CheckerContext &C, NonLoc Flags = V.castAs<NonLoc>(); NonLoc ZeroFlag = C.getSValBuilder() - .makeIntVal(*KernelZeroFlagVal, FlagsEx->getType()) - .castAs<NonLoc>(); + .makeIntVal(KernelZeroFlagVal.getValue(), FlagsEx->getType()) + .castAs<NonLoc>(); SVal MaskedFlagsUC = C.getSValBuilder().evalBinOpNN(State, BO_And, Flags, ZeroFlag, FlagsEx->getType()); @@ -1238,8 +1238,8 @@ void MallocChecker::checkKernelMalloc(const CallEvent &Call, ProgramStateRef State = C.getState(); llvm::Optional<ProgramStateRef> MaybeState = performKernelMalloc(Call, C, State); - if (MaybeState) - State = *MaybeState; + if (MaybeState.hasValue()) + State = MaybeState.getValue(); else State = MallocMemAux(C, Call, Call.getArgExpr(0), UndefinedVal(), State, AF_Malloc); @@ -3571,13 +3571,13 @@ void MallocChecker::printState(raw_ostream &Out, ProgramStateRef State, const RefState *RefS = State->get<RegionState>(I.getKey()); AllocationFamily Family = RefS->getAllocationFamily(); Optional<MallocChecker::CheckKind> CheckKind = getCheckIfTracked(Family); - if (!CheckKind) - CheckKind = getCheckIfTracked(Family, true); + if (!CheckKind.hasValue()) + CheckKind = getCheckIfTracked(Family, true); I.getKey()->dumpToStream(Out); Out << " : "; I.getData().dump(Out); - if (CheckKind) + if (CheckKind.hasValue()) Out << " (" << CheckNames[*CheckKind].getName() << ")"; Out << NL; } diff --git a/clang/lib/StaticAnalyzer/Checkers/NonNullParamChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/NonNullParamChecker.cpp index fd47e19..3481936 100644 --- a/clang/lib/StaticAnalyzer/Checkers/NonNullParamChecker.cpp +++ b/clang/lib/StaticAnalyzer/Checkers/NonNullParamChecker.cpp @@ -136,10 +136,10 @@ void NonNullParamChecker::checkPreCall(const CallEvent &Call, if (!DV) continue; - assert(!HasRefTypeParam || isa<Loc>(*DV)); + assert(!HasRefTypeParam || isa<Loc>(DV.getValue())); // Process the case when the argument is not a location. - if (ExpectedToBeNonNull && !isa<Loc>(*DV)) { + if (ExpectedToBeNonNull && !isa<Loc>(DV.getValue())) { // If the argument is a union type, we want to handle a potential // transparent_union GCC extension. if (!ArgE) diff --git a/clang/lib/StaticAnalyzer/Checkers/UnixAPIChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/UnixAPIChecker.cpp index 19b63a1..9da44d5 100644 --- a/clang/lib/StaticAnalyzer/Checkers/UnixAPIChecker.cpp +++ b/clang/lib/StaticAnalyzer/Checkers/UnixAPIChecker.cpp @@ -234,8 +234,7 @@ void UnixAPIMisuseChecker::CheckOpenVariant(CheckerContext &C, } NonLoc oflags = V.castAs<NonLoc>(); NonLoc ocreateFlag = C.getSValBuilder() - .makeIntVal(*Val_O_CREAT, oflagsEx->getType()) - .castAs<NonLoc>(); + .makeIntVal(Val_O_CREAT.getValue(), oflagsEx->getType()).castAs<NonLoc>(); SVal maskedFlagsUC = C.getSValBuilder().evalBinOpNN(state, BO_And, oflags, ocreateFlag, oflagsEx->getType()); diff --git a/clang/lib/StaticAnalyzer/Core/AnalyzerOptions.cpp b/clang/lib/StaticAnalyzer/Core/AnalyzerOptions.cpp index 3b01ec6..de94cb7 100644 --- a/clang/lib/StaticAnalyzer/Core/AnalyzerOptions.cpp +++ b/clang/lib/StaticAnalyzer/Core/AnalyzerOptions.cpp @@ -77,8 +77,8 @@ AnalyzerOptions::getExplorationStrategy() const { .Case("bfs_block_dfs_contents", ExplorationStrategyKind::BFSBlockDFSContents) .Default(None); - assert(K && "User mode is invalid."); - return *K; + assert(K.hasValue() && "User mode is invalid."); + return K.getValue(); } CTUPhase1InliningKind AnalyzerOptions::getCTUPhase1Inlining() const { @@ -88,8 +88,8 @@ CTUPhase1InliningKind AnalyzerOptions::getCTUPhase1Inlining() const { .Case("small", CTUPhase1InliningKind::Small) .Case("all", CTUPhase1InliningKind::All) .Default(None); - assert(K && "CTU inlining mode is invalid."); - return *K; + assert(K.hasValue() && "CTU inlining mode is invalid."); + return K.getValue(); } IPAKind AnalyzerOptions::getIPAMode() const { @@ -100,9 +100,9 @@ IPAKind AnalyzerOptions::getIPAMode() const { .Case("dynamic", IPAK_DynamicDispatch) .Case("dynamic-bifurcate", IPAK_DynamicDispatchBifurcate) .Default(None); - assert(K && "IPA Mode is invalid."); + assert(K.hasValue() && "IPA Mode is invalid."); - return *K; + return K.getValue(); } bool diff --git a/clang/lib/StaticAnalyzer/Core/BugReporter.cpp b/clang/lib/StaticAnalyzer/Core/BugReporter.cpp index 4d6b82e..a2efe14 100644 --- a/clang/lib/StaticAnalyzer/Core/BugReporter.cpp +++ b/clang/lib/StaticAnalyzer/Core/BugReporter.cpp @@ -2363,15 +2363,15 @@ PathSensitiveBugReport::getInterestingnessKind(const MemRegion *R) const { } bool PathSensitiveBugReport::isInteresting(SVal V) const { - return getInterestingnessKind(V).has_value(); + return getInterestingnessKind(V).hasValue(); } bool PathSensitiveBugReport::isInteresting(SymbolRef sym) const { - return getInterestingnessKind(sym).has_value(); + return getInterestingnessKind(sym).hasValue(); } bool PathSensitiveBugReport::isInteresting(const MemRegion *R) const { - return getInterestingnessKind(R).has_value(); + return getInterestingnessKind(R).hasValue(); } bool PathSensitiveBugReport::isInteresting(const LocationContext *LC) const { diff --git a/clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp b/clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp index 9d89069..339a675 100644 --- a/clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp +++ b/clang/lib/StaticAnalyzer/Core/BugReporterVisitors.cpp @@ -2949,8 +2949,8 @@ PathDiagnosticPieceRef ConditionBRVisitor::VisitTrueTest( PathDiagnosticLocation Loc(Cond, SM, LCtx); auto event = std::make_shared<PathDiagnosticEventPiece>(Loc, Message); - if (shouldPrune) - event->setPrunable(*shouldPrune); + if (shouldPrune.hasValue()) + event->setPrunable(shouldPrune.getValue()); return event; } @@ -3084,9 +3084,9 @@ bool ConditionBRVisitor::printValue(const Expr *CondVarExpr, raw_ostream &Out, Out << (TookTrue ? "not equal to 0" : "0"); } else { if (Ty->isBooleanType()) - Out << (IntValue.value()->getBoolValue() ? "true" : "false"); + Out << (IntValue.getValue()->getBoolValue() ? "true" : "false"); else - Out << *IntValue.value(); + Out << *IntValue.getValue(); } return true; @@ -3279,10 +3279,10 @@ void FalsePositiveRefutationBRVisitor::finalizeVisitor( // And check for satisfiability Optional<bool> IsSAT = RefutationSolver->check(); - if (!IsSAT) + if (!IsSAT.hasValue()) return; - if (!*IsSAT) + if (!IsSAT.getValue()) BR.markInvalid("Infeasible constraints", EndPathNode->getLocationContext()); } diff --git a/clang/lib/StaticAnalyzer/Core/ExprEngineCallAndReturn.cpp b/clang/lib/StaticAnalyzer/Core/ExprEngineCallAndReturn.cpp index b03af13..326a3b1 100644 --- a/clang/lib/StaticAnalyzer/Core/ExprEngineCallAndReturn.cpp +++ b/clang/lib/StaticAnalyzer/Core/ExprEngineCallAndReturn.cpp @@ -1015,8 +1015,8 @@ bool ExprEngine::shouldInlineCall(const CallEvent &Call, const Decl *D, // Check if this function has been marked as non-inlinable. Optional<bool> MayInline = Engine.FunctionSummaries->mayInline(D); - if (MayInline) { - if (!*MayInline) + if (MayInline.hasValue()) { + if (!MayInline.getValue()) return false; } else { diff --git a/clang/lib/StaticAnalyzer/Core/PlistDiagnostics.cpp b/clang/lib/StaticAnalyzer/Core/PlistDiagnostics.cpp index 56f441e..93c19a6 100644 --- a/clang/lib/StaticAnalyzer/Core/PlistDiagnostics.cpp +++ b/clang/lib/StaticAnalyzer/Core/PlistDiagnostics.cpp @@ -407,11 +407,11 @@ void PlistPrinter::ReportMacroExpansions(raw_ostream &o, unsigned indent) { // Output the macro name. Indent(o, indent) << "<key>name</key>"; - EmitString(o, *MacroName) << '\n'; + EmitString(o, MacroName.getValue()) << '\n'; // Output what it expands into. Indent(o, indent) << "<key>expansion</key>"; - EmitString(o, *ExpansionText) << '\n'; + EmitString(o, ExpansionText.getValue()) << '\n'; // Finish up. --indent; diff --git a/clang/lib/Support/RISCVVIntrinsicUtils.cpp b/clang/lib/Support/RISCVVIntrinsicUtils.cpp index 3f7c131..ebfe1a1 100644 --- a/clang/lib/Support/RISCVVIntrinsicUtils.cpp +++ b/clang/lib/Support/RISCVVIntrinsicUtils.cpp @@ -114,11 +114,11 @@ bool RVVType::verifyType() const { return false; if (isScalar()) return true; - if (!Scale) + if (!Scale.hasValue()) return false; if (isFloat() && ElementBitwidth == 8) return false; - unsigned V = *Scale; + unsigned V = Scale.getValue(); switch (ElementBitwidth) { case 1: case 8: @@ -799,10 +799,10 @@ RVVType::computeTypes(BasicType BT, int Log2LMUL, unsigned NF, RVVTypes Types; for (const PrototypeDescriptor &Proto : Prototype) { auto T = computeType(BT, Log2LMUL, Proto); - if (!T) + if (!T.hasValue()) return llvm::None; // Record legal type index - Types.push_back(*T); + Types.push_back(T.getValue()); } return Types; } diff --git a/clang/lib/Tooling/Core/Replacement.cpp b/clang/lib/Tooling/Core/Replacement.cpp index aca2afce..30e1923 100644 --- a/clang/lib/Tooling/Core/Replacement.cpp +++ b/clang/lib/Tooling/Core/Replacement.cpp @@ -179,9 +179,9 @@ static std::string getReplacementErrString(replacement_error Err) { std::string ReplacementError::message() const { std::string Message = getReplacementErrString(Err); - if (NewReplacement) + if (NewReplacement.hasValue()) Message += "\nNew replacement: " + NewReplacement->toString(); - if (ExistingReplacement) + if (ExistingReplacement.hasValue()) Message += "\nExisting replacement: " + ExistingReplacement->toString(); return Message; } diff --git a/clang/tools/driver/driver.cpp b/clang/tools/driver/driver.cpp index 7231297..fa1f09b 100644 --- a/clang/tools/driver/driver.cpp +++ b/clang/tools/driver/driver.cpp @@ -406,18 +406,18 @@ int clang_main(int Argc, char **Argv) { if (ClangCLMode) { // Arguments in "CL" are prepended. llvm::Optional<std::string> OptCL = llvm::sys::Process::GetEnv("CL"); - if (OptCL) { + if (OptCL.hasValue()) { SmallVector<const char *, 8> PrependedOpts; - getCLEnvVarOptions(*OptCL, Saver, PrependedOpts); + getCLEnvVarOptions(OptCL.getValue(), Saver, PrependedOpts); // Insert right after the program name to prepend to the argument list. Args.insert(Args.begin() + 1, PrependedOpts.begin(), PrependedOpts.end()); } // Arguments in "_CL_" are appended. llvm::Optional<std::string> Opt_CL_ = llvm::sys::Process::GetEnv("_CL_"); - if (Opt_CL_) { + if (Opt_CL_.hasValue()) { SmallVector<const char *, 8> AppendedOpts; - getCLEnvVarOptions(*Opt_CL_, Saver, AppendedOpts); + getCLEnvVarOptions(Opt_CL_.getValue(), Saver, AppendedOpts); // Insert at the end of the argument list to append. Args.append(AppendedOpts.begin(), AppendedOpts.end()); diff --git a/clang/tools/libclang/CIndex.cpp b/clang/tools/libclang/CIndex.cpp index 8d6c16e..cba265b 100644 --- a/clang/tools/libclang/CIndex.cpp +++ b/clang/tools/libclang/CIndex.cpp @@ -536,9 +536,9 @@ bool CursorVisitor::VisitChildren(CXCursor Cursor) { TLEnd = CXXUnit->top_level_end(); TL != TLEnd; ++TL) { const Optional<bool> V = handleDeclForVisitation(*TL); - if (!V) + if (!V.hasValue()) continue; - return *V; + return V.getValue(); } } else if (VisitDeclContext( CXXUnit->getASTContext().getTranslationUnitDecl())) @@ -641,9 +641,9 @@ bool CursorVisitor::VisitDeclContext(DeclContext *DC) { if (OMD->isSynthesizedAccessorStub()) continue; const Optional<bool> V = handleDeclForVisitation(D); - if (!V) + if (!V.hasValue()) continue; - return *V; + return V.getValue(); } return false; } @@ -675,9 +675,9 @@ Optional<bool> CursorVisitor::handleDeclForVisitation(const Decl *D) { } const Optional<bool> V = shouldVisitCursor(Cursor); - if (!V) + if (!V.hasValue()) return None; - if (!*V) + if (!V.getValue()) return false; if (Visit(Cursor, true)) return true; @@ -1074,9 +1074,9 @@ bool CursorVisitor::VisitObjCContainerDecl(ObjCContainerDecl *D) { I != E; ++I) { CXCursor Cursor = MakeCXCursor(*I, TU, RegionOfInterest); const Optional<bool> &V = shouldVisitCursor(Cursor); - if (!V) + if (!V.hasValue()) continue; - if (!*V) + if (!V.getValue()) return false; if (Visit(Cursor, true)) return true; @@ -8178,13 +8178,13 @@ static CXVersion convertVersion(VersionTuple In) { Out.Major = In.getMajor(); Optional<unsigned> Minor = In.getMinor(); - if (Minor) + if (Minor.hasValue()) Out.Minor = *Minor; else return Out; Optional<unsigned> Subminor = In.getSubminor(); - if (Subminor) + if (Subminor.hasValue()) Out.Subminor = *Subminor; return Out; diff --git a/clang/unittests/ASTMatchers/Dynamic/ParserTest.cpp b/clang/unittests/ASTMatchers/Dynamic/ParserTest.cpp index 312b9af..eaba6b7 100644 --- a/clang/unittests/ASTMatchers/Dynamic/ParserTest.cpp +++ b/clang/unittests/ASTMatchers/Dynamic/ParserTest.cpp @@ -449,27 +449,27 @@ TEST(ParserTest, ParseMultiline) { ) )matcher"; Diagnostics Error; - EXPECT_TRUE(Parser::parseMatcherExpression(Code, &Error)); + EXPECT_TRUE(Parser::parseMatcherExpression(Code, &Error).hasValue()); } { Code = R"matcher(decl(decl() , decl()))matcher"; Diagnostics Error; - EXPECT_TRUE(Parser::parseMatcherExpression(Code, &Error).has_value()); + EXPECT_TRUE(Parser::parseMatcherExpression(Code, &Error).hasValue()); } { Code = R"matcher(decl(decl(), decl()))matcher"; Diagnostics Error; - EXPECT_TRUE(Parser::parseMatcherExpression(Code, &Error).has_value()); + EXPECT_TRUE(Parser::parseMatcherExpression(Code, &Error).hasValue()); } { Code = "namedDecl(hasName(\"n\"\n))"; Diagnostics Error; - EXPECT_TRUE(Parser::parseMatcherExpression(Code, &Error).has_value()); + EXPECT_TRUE(Parser::parseMatcherExpression(Code, &Error).hasValue()); } { diff --git a/clang/unittests/Analysis/FlowSensitive/TestingSupport.cpp b/clang/unittests/Analysis/FlowSensitive/TestingSupport.cpp index 7c50453..4c5efa7 100644 --- a/clang/unittests/Analysis/FlowSensitive/TestingSupport.cpp +++ b/clang/unittests/Analysis/FlowSensitive/TestingSupport.cpp @@ -40,8 +40,9 @@ isAnnotationDirectlyAfterStatement(const Stmt *Stmt, unsigned AnnotationBegin, auto NextToken = Lexer::findNextToken(Stmt->getEndLoc(), SourceManager, LangOptions); - while (NextToken && SourceManager.getFileOffset(NextToken->getLocation()) < - AnnotationBegin) { + while (NextToken.hasValue() && + SourceManager.getFileOffset(NextToken->getLocation()) < + AnnotationBegin) { if (NextToken->isNot(tok::semi)) return false; diff --git a/clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp b/clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp index 27b7671..594764b 100644 --- a/clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp +++ b/clang/unittests/Analysis/FlowSensitive/TypeErasedDataflowAnalysisTest.cpp @@ -82,8 +82,8 @@ TEST(DataflowAnalysisTest, NoopAnalysis) { return NoopAnalysis(C, false); })); EXPECT_EQ(BlockStates.size(), 2u); - EXPECT_TRUE(BlockStates[0].has_value()); - EXPECT_TRUE(BlockStates[1].has_value()); + EXPECT_TRUE(BlockStates[0].hasValue()); + EXPECT_TRUE(BlockStates[1].hasValue()); } struct NonConvergingLattice { diff --git a/clang/unittests/Analysis/MacroExpansionContextTest.cpp b/clang/unittests/Analysis/MacroExpansionContextTest.cpp index 8864230..7cee64c 100644 --- a/clang/unittests/Analysis/MacroExpansionContextTest.cpp +++ b/clang/unittests/Analysis/MacroExpansionContextTest.cpp @@ -121,14 +121,14 @@ TEST_F(MacroExpansionContextTest, IgnoresPragmas) { EXPECT_EQ("\n=============== ExpansionRanges ===============\n", dumpExpansionRanges(*Ctx)); - EXPECT_FALSE(Ctx->getExpandedText(at(2, 1)).has_value()); - EXPECT_FALSE(Ctx->getOriginalText(at(2, 1)).has_value()); + EXPECT_FALSE(Ctx->getExpandedText(at(2, 1)).hasValue()); + EXPECT_FALSE(Ctx->getOriginalText(at(2, 1)).hasValue()); - EXPECT_FALSE(Ctx->getExpandedText(at(2, 3)).has_value()); - EXPECT_FALSE(Ctx->getOriginalText(at(2, 3)).has_value()); + EXPECT_FALSE(Ctx->getExpandedText(at(2, 3)).hasValue()); + EXPECT_FALSE(Ctx->getOriginalText(at(2, 3)).hasValue()); - EXPECT_FALSE(Ctx->getExpandedText(at(3, 3)).has_value()); - EXPECT_FALSE(Ctx->getOriginalText(at(3, 3)).has_value()); + EXPECT_FALSE(Ctx->getExpandedText(at(3, 3)).hasValue()); + EXPECT_FALSE(Ctx->getOriginalText(at(3, 3)).hasValue()); } TEST_F(MacroExpansionContextTest, NoneForNonExpansionLocations) { @@ -142,33 +142,33 @@ EMPTY zz // zz // That's the beginning of the definition of EMPTY. - EXPECT_FALSE(Ctx->getExpandedText(at(2, 11)).has_value()); - EXPECT_FALSE(Ctx->getOriginalText(at(2, 11)).has_value()); + EXPECT_FALSE(Ctx->getExpandedText(at(2, 11)).hasValue()); + EXPECT_FALSE(Ctx->getOriginalText(at(2, 11)).hasValue()); // The space before the first expansion of EMPTY. - EXPECT_FALSE(Ctx->getExpandedText(at(3, 9)).has_value()); - EXPECT_FALSE(Ctx->getOriginalText(at(3, 9)).has_value()); + EXPECT_FALSE(Ctx->getExpandedText(at(3, 9)).hasValue()); + EXPECT_FALSE(Ctx->getOriginalText(at(3, 9)).hasValue()); // The beginning of the first expansion of EMPTY. - EXPECT_TRUE(Ctx->getExpandedText(at(3, 10)).has_value()); - EXPECT_TRUE(Ctx->getOriginalText(at(3, 10)).has_value()); + EXPECT_TRUE(Ctx->getExpandedText(at(3, 10)).hasValue()); + EXPECT_TRUE(Ctx->getOriginalText(at(3, 10)).hasValue()); // Pointing inside of the token EMPTY, but not at the beginning. // FIXME: We only deal with begin locations. - EXPECT_FALSE(Ctx->getExpandedText(at(3, 11)).has_value()); - EXPECT_FALSE(Ctx->getOriginalText(at(3, 11)).has_value()); + EXPECT_FALSE(Ctx->getExpandedText(at(3, 11)).hasValue()); + EXPECT_FALSE(Ctx->getOriginalText(at(3, 11)).hasValue()); // Same here. - EXPECT_FALSE(Ctx->getExpandedText(at(3, 12)).has_value()); - EXPECT_FALSE(Ctx->getOriginalText(at(3, 12)).has_value()); + EXPECT_FALSE(Ctx->getExpandedText(at(3, 12)).hasValue()); + EXPECT_FALSE(Ctx->getOriginalText(at(3, 12)).hasValue()); // The beginning of the last expansion of EMPTY. - EXPECT_TRUE(Ctx->getExpandedText(at(4, 1)).has_value()); - EXPECT_TRUE(Ctx->getOriginalText(at(4, 1)).has_value()); + EXPECT_TRUE(Ctx->getExpandedText(at(4, 1)).hasValue()); + EXPECT_TRUE(Ctx->getOriginalText(at(4, 1)).hasValue()); // Same as for the 3:11 case. - EXPECT_FALSE(Ctx->getExpandedText(at(4, 2)).has_value()); - EXPECT_FALSE(Ctx->getOriginalText(at(4, 2)).has_value()); + EXPECT_FALSE(Ctx->getExpandedText(at(4, 2)).hasValue()); + EXPECT_FALSE(Ctx->getOriginalText(at(4, 2)).hasValue()); } TEST_F(MacroExpansionContextTest, EmptyExpansions) { @@ -181,14 +181,14 @@ EMPTY zz // A b cd ef gh // zz - EXPECT_EQ("", *Ctx->getExpandedText(at(3, 10))); - EXPECT_EQ("EMPTY", *Ctx->getOriginalText(at(3, 10))); + EXPECT_EQ("", Ctx->getExpandedText(at(3, 10)).getValue()); + EXPECT_EQ("EMPTY", Ctx->getOriginalText(at(3, 10)).getValue()); - EXPECT_EQ("", *Ctx->getExpandedText(at(3, 19))); - EXPECT_EQ("EMPTY", *Ctx->getOriginalText(at(3, 19))); + EXPECT_EQ("", Ctx->getExpandedText(at(3, 19)).getValue()); + EXPECT_EQ("EMPTY", Ctx->getOriginalText(at(3, 19)).getValue()); - EXPECT_EQ("", *Ctx->getExpandedText(at(4, 1))); - EXPECT_EQ("EMPTY", *Ctx->getOriginalText(at(4, 1))); + EXPECT_EQ("", Ctx->getExpandedText(at(4, 1)).getValue()); + EXPECT_EQ("EMPTY", Ctx->getOriginalText(at(4, 1)).getValue()); } TEST_F(MacroExpansionContextTest, TransitiveExpansions) { @@ -200,10 +200,10 @@ TEST_F(MacroExpansionContextTest, TransitiveExpansions) { // After preprocessing: // A b cd ) 1 ef gh - EXPECT_EQ("WOOF", *Ctx->getOriginalText(at(4, 10))); + EXPECT_EQ("WOOF", Ctx->getOriginalText(at(4, 10)).getValue()); - EXPECT_EQ("", *Ctx->getExpandedText(at(4, 18))); - EXPECT_EQ("EMPTY", *Ctx->getOriginalText(at(4, 18))); + EXPECT_EQ("", Ctx->getExpandedText(at(4, 18)).getValue()); + EXPECT_EQ("EMPTY", Ctx->getOriginalText(at(4, 18)).getValue()); } TEST_F(MacroExpansionContextTest, MacroFunctions) { @@ -219,17 +219,17 @@ TEST_F(MacroExpansionContextTest, MacroFunctions) { // WOOF( ) ) ) 1 // bar barr( ) ) ) 1( ) ) ) 1),,),') - EXPECT_EQ("$$ ef ()))1", *Ctx->getExpandedText(at(4, 10))); - EXPECT_EQ("WOOF($$ ef)", *Ctx->getOriginalText(at(4, 10))); + EXPECT_EQ("$$ ef ()))1", Ctx->getExpandedText(at(4, 10)).getValue()); + EXPECT_EQ("WOOF($$ ef)", Ctx->getOriginalText(at(4, 10)).getValue()); - EXPECT_EQ("", Ctx->getExpandedText(at(4, 22)).value()); - EXPECT_EQ("EMPTY", Ctx->getOriginalText(at(4, 22)).value()); + EXPECT_EQ("", Ctx->getExpandedText(at(4, 22)).getValue()); + EXPECT_EQ("EMPTY", Ctx->getOriginalText(at(4, 22)).getValue()); - EXPECT_EQ("WOOF ()))1", Ctx->getExpandedText(at(5, 3)).value()); - EXPECT_EQ("WOOF(WOOF)", Ctx->getOriginalText(at(5, 3)).value()); + EXPECT_EQ("WOOF ()))1", Ctx->getExpandedText(at(5, 3)).getValue()); + EXPECT_EQ("WOOF(WOOF)", Ctx->getOriginalText(at(5, 3)).getValue()); - EXPECT_EQ("bar barr ()))1()))1", Ctx->getExpandedText(at(6, 3)).value()); - EXPECT_EQ("WOOF(WOOF(bar barr))", Ctx->getOriginalText(at(6, 3)).value()); + EXPECT_EQ("bar barr ()))1()))1", Ctx->getExpandedText(at(6, 3)).getValue()); + EXPECT_EQ("WOOF(WOOF(bar barr))", Ctx->getOriginalText(at(6, 3)).getValue()); } TEST_F(MacroExpansionContextTest, VariadicMacros) { @@ -251,23 +251,24 @@ TEST_F(MacroExpansionContextTest, VariadicMacros) { // fprintf (stderr, "success!\n" ); EXPECT_EQ(R"(fprintf (stderr ,"success!\n",))", - Ctx->getExpandedText(at(3, 3)).value()); + Ctx->getExpandedText(at(3, 3)).getValue()); EXPECT_EQ(R"(eprintf("success!\n", ))", - Ctx->getOriginalText(at(3, 3)).value()); + Ctx->getOriginalText(at(3, 3)).getValue()); EXPECT_EQ(R"(fprintf (stderr ,"success!\n",))", - Ctx->getExpandedText(at(4, 3)).value()); - EXPECT_EQ(R"(eprintf("success!\n"))", Ctx->getOriginalText(at(4, 3)).value()); + Ctx->getExpandedText(at(4, 3)).getValue()); + EXPECT_EQ(R"(eprintf("success!\n"))", + Ctx->getOriginalText(at(4, 3)).getValue()); EXPECT_EQ(R"(fprintf (stderr ,"success!\n"))", - Ctx->getExpandedText(at(8, 3)).value()); + Ctx->getExpandedText(at(8, 3)).getValue()); EXPECT_EQ(R"(eprintf2("success!\n", ))", - Ctx->getOriginalText(at(8, 3)).value()); + Ctx->getOriginalText(at(8, 3)).getValue()); EXPECT_EQ(R"(fprintf (stderr ,"success!\n"))", - Ctx->getExpandedText(at(9, 3)).value()); + Ctx->getExpandedText(at(9, 3)).getValue()); EXPECT_EQ(R"(eprintf2("success!\n"))", - Ctx->getOriginalText(at(9, 3)).value()); + Ctx->getOriginalText(at(9, 3)).getValue()); } TEST_F(MacroExpansionContextTest, ConcatenationMacros) { @@ -285,12 +286,12 @@ TEST_F(MacroExpansionContextTest, ConcatenationMacros) { // }; EXPECT_EQ(R"({"quit",quit_command })", - Ctx->getExpandedText(at(4, 5)).value()); - EXPECT_EQ("COMMAND(quit)", Ctx->getOriginalText(at(4, 5)).value()); + Ctx->getExpandedText(at(4, 5)).getValue()); + EXPECT_EQ("COMMAND(quit)", Ctx->getOriginalText(at(4, 5)).getValue()); EXPECT_EQ(R"({"help",help_command })", - Ctx->getExpandedText(at(5, 5)).value()); - EXPECT_EQ("COMMAND(help)", Ctx->getOriginalText(at(5, 5)).value()); + Ctx->getExpandedText(at(5, 5)).getValue()); + EXPECT_EQ("COMMAND(help)", Ctx->getOriginalText(at(5, 5)).getValue()); } TEST_F(MacroExpansionContextTest, StringizingMacros) { @@ -315,14 +316,14 @@ TEST_F(MacroExpansionContextTest, StringizingMacros) { EXPECT_EQ( R"(do {if (x ==0)fprintf (stderr ,"Warning: ""x == 0""\n");}while (0))", - Ctx->getExpandedText(at(6, 3)).value()); - EXPECT_EQ("WARN_IF (x == 0)", Ctx->getOriginalText(at(6, 3)).value()); + Ctx->getExpandedText(at(6, 3)).getValue()); + EXPECT_EQ("WARN_IF (x == 0)", Ctx->getOriginalText(at(6, 3)).getValue()); - EXPECT_EQ(R"("foo")", Ctx->getExpandedText(at(11, 3)).value()); - EXPECT_EQ("str (foo)", Ctx->getOriginalText(at(11, 3)).value()); + EXPECT_EQ(R"("foo")", Ctx->getExpandedText(at(11, 3)).getValue()); + EXPECT_EQ("str (foo)", Ctx->getOriginalText(at(11, 3)).getValue()); - EXPECT_EQ(R"("4")", Ctx->getExpandedText(at(12, 3)).value()); - EXPECT_EQ("xstr (foo)", Ctx->getOriginalText(at(12, 3)).value()); + EXPECT_EQ(R"("4")", Ctx->getExpandedText(at(12, 3)).getValue()); + EXPECT_EQ("xstr (foo)", Ctx->getOriginalText(at(12, 3)).getValue()); } TEST_F(MacroExpansionContextTest, StringizingVariadicMacros) { @@ -351,18 +352,18 @@ TEST_F(MacroExpansionContextTest, StringizingVariadicMacros) { EXPECT_EQ("zz !apple !x *apple !x !**y (apple )zz !apple !x *apple !x !**y " "(appleapple ))))", - Ctx->getExpandedText(at(11, 3)).value()); - EXPECT_EQ("q(g)", Ctx->getOriginalText(at(11, 3)).value()); + Ctx->getExpandedText(at(11, 3)).getValue()); + EXPECT_EQ("q(g)", Ctx->getOriginalText(at(11, 3)).getValue()); EXPECT_EQ(R"res("apple"(apple )"apple"(appleapple )))))res", - Ctx->getExpandedText(at(12, 3)).value()); - EXPECT_EQ("q(xstr)", Ctx->getOriginalText(at(12, 3)).value()); + Ctx->getExpandedText(at(12, 3)).getValue()); + EXPECT_EQ("q(xstr)", Ctx->getOriginalText(at(12, 3)).getValue()); - EXPECT_EQ("zz !*)!x )!**y ", Ctx->getExpandedText(at(13, 3)).value()); - EXPECT_EQ("g(RParen2x)", Ctx->getOriginalText(at(13, 3)).value()); + EXPECT_EQ("zz !*)!x )!**y ", Ctx->getExpandedText(at(13, 3)).getValue()); + EXPECT_EQ("g(RParen2x)", Ctx->getOriginalText(at(13, 3)).getValue()); - EXPECT_EQ("!))*))", Ctx->getExpandedText(at(14, 3)).value()); - EXPECT_EQ("f( RParen2x )", Ctx->getOriginalText(at(14, 3)).value()); + EXPECT_EQ("!))*))", Ctx->getExpandedText(at(14, 3)).getValue()); + EXPECT_EQ("f( RParen2x )", Ctx->getOriginalText(at(14, 3)).getValue()); } TEST_F(MacroExpansionContextTest, RedefUndef) { @@ -380,15 +381,15 @@ TEST_F(MacroExpansionContextTest, RedefUndef) { // Hi(Hi) // FIXME: Extra space follows every identifier. - EXPECT_EQ("Welcome Adam ", Ctx->getExpandedText(at(3, 3)).value()); - EXPECT_EQ("Hi(Adam)", Ctx->getOriginalText(at(3, 3)).value()); + EXPECT_EQ("Welcome Adam ", Ctx->getExpandedText(at(3, 3)).getValue()); + EXPECT_EQ("Hi(Adam)", Ctx->getOriginalText(at(3, 3)).getValue()); - EXPECT_EQ("Willkommen ", Ctx->getExpandedText(at(5, 3)).value()); - EXPECT_EQ("Hi", Ctx->getOriginalText(at(5, 3)).value()); + EXPECT_EQ("Willkommen ", Ctx->getExpandedText(at(5, 3)).getValue()); + EXPECT_EQ("Hi", Ctx->getOriginalText(at(5, 3)).getValue()); // There was no macro expansion at 7:3, we should expect None. - EXPECT_FALSE(Ctx->getExpandedText(at(7, 3)).has_value()); - EXPECT_FALSE(Ctx->getOriginalText(at(7, 3)).has_value()); + EXPECT_FALSE(Ctx->getExpandedText(at(7, 3)).hasValue()); + EXPECT_FALSE(Ctx->getOriginalText(at(7, 3)).hasValue()); } TEST_F(MacroExpansionContextTest, UnbalacedParenthesis) { @@ -410,11 +411,12 @@ TEST_F(MacroExpansionContextTest, UnbalacedParenthesis) { // fun(); // int x = ((1, fun(), 1, fun(), 1 )); - EXPECT_EQ("fun ()", Ctx->getExpandedText(at(8, 3)).value()); - EXPECT_EQ("applyInt )", Ctx->getOriginalText(at(8, 3)).value()); + EXPECT_EQ("fun ()", Ctx->getExpandedText(at(8, 3)).getValue()); + EXPECT_EQ("applyInt )", Ctx->getOriginalText(at(8, 3)).getValue()); - EXPECT_EQ("((1,fun (),1,fun (),1", Ctx->getExpandedText(at(13, 12)).value()); - EXPECT_EQ("f(f(1))", Ctx->getOriginalText(at(13, 12)).value()); + EXPECT_EQ("((1,fun (),1,fun (),1", + Ctx->getExpandedText(at(13, 12)).getValue()); + EXPECT_EQ("f(f(1))", Ctx->getOriginalText(at(13, 12)).getValue()); } } // namespace diff --git a/clang/unittests/Basic/DarwinSDKInfoTest.cpp b/clang/unittests/Basic/DarwinSDKInfoTest.cpp index d56e13d..8d720c2 100644 --- a/clang/unittests/Basic/DarwinSDKInfoTest.cpp +++ b/clang/unittests/Basic/DarwinSDKInfoTest.cpp @@ -64,14 +64,14 @@ TEST(DarwinSDKInfo, VersionMappingParseEmpty) { llvm::json::Object Obj({}); EXPECT_FALSE( DarwinSDKInfo::RelatedTargetVersionMapping::parseJSON(Obj, VersionTuple()) - .has_value()); + .hasValue()); } TEST(DarwinSDKInfo, VersionMappingParseError) { llvm::json::Object Obj({{"test", "1.2"}}); EXPECT_FALSE( DarwinSDKInfo::RelatedTargetVersionMapping::parseJSON(Obj, VersionTuple()) - .has_value()); + .hasValue()); } TEST(DarwinSDKInfoTest, ParseAndTestMappingMacCatalyst) { diff --git a/clang/unittests/DirectoryWatcher/DirectoryWatcherTest.cpp b/clang/unittests/DirectoryWatcher/DirectoryWatcherTest.cpp index d9c1245..5b76480 100644 --- a/clang/unittests/DirectoryWatcher/DirectoryWatcherTest.cpp +++ b/clang/unittests/DirectoryWatcher/DirectoryWatcherTest.cpp @@ -258,12 +258,12 @@ void checkEventualResultWithTimeout(VerifyingConsumer &TestConsumer) { std::future_status::ready) << "The expected result state wasn't reached before the time-out."; std::unique_lock<std::mutex> L(TestConsumer.Mtx); - EXPECT_TRUE(TestConsumer.result().has_value()); - if (TestConsumer.result()) { + EXPECT_TRUE(TestConsumer.result().hasValue()); + if (TestConsumer.result().hasValue()) { EXPECT_TRUE(*TestConsumer.result()); } - if ((TestConsumer.result() && !*TestConsumer.result()) || - !TestConsumer.result()) + if ((TestConsumer.result().hasValue() && !TestConsumer.result().getValue()) || + !TestConsumer.result().hasValue()) TestConsumer.printUnmetExpectations(llvm::outs()); } } // namespace diff --git a/clang/unittests/Lex/HeaderSearchTest.cpp b/clang/unittests/Lex/HeaderSearchTest.cpp index bd9d31d..87d1c01 100644 --- a/clang/unittests/Lex/HeaderSearchTest.cpp +++ b/clang/unittests/Lex/HeaderSearchTest.cpp @@ -200,9 +200,9 @@ TEST_F(HeaderSearchTest, HeaderFrameworkLookup) { /*RelativePath=*/nullptr, /*RequestingModule=*/nullptr, /*SuggestedModule=*/nullptr, /*IsMapped=*/nullptr, &IsFrameworkFound); - EXPECT_TRUE(FoundFile.has_value()); + EXPECT_TRUE(FoundFile.hasValue()); EXPECT_TRUE(IsFrameworkFound); - auto &FE = *FoundFile; + auto &FE = FoundFile.getValue(); auto FI = Search.getExistingFileInfo(FE); EXPECT_TRUE(FI); EXPECT_TRUE(FI->IsValid); @@ -269,9 +269,9 @@ TEST_F(HeaderSearchTest, HeaderMapFrameworkLookup) { /*SuggestedModule=*/nullptr, &IsMapped, /*IsFrameworkFound=*/nullptr); - EXPECT_TRUE(FoundFile.has_value()); + EXPECT_TRUE(FoundFile.hasValue()); EXPECT_TRUE(IsMapped); - auto &FE = *FoundFile; + auto &FE = FoundFile.getValue(); auto FI = Search.getExistingFileInfo(FE); EXPECT_TRUE(FI); EXPECT_TRUE(FI->IsValid); diff --git a/clang/unittests/StaticAnalyzer/SValTest.cpp b/clang/unittests/StaticAnalyzer/SValTest.cpp index c41a501..1a41faf 100644 --- a/clang/unittests/StaticAnalyzer/SValTest.cpp +++ b/clang/unittests/StaticAnalyzer/SValTest.cpp @@ -305,13 +305,13 @@ void foo(int x) { EXPECT_EQ("TestUnion", CRecordType->getDecl()->getName()); auto D = getByName("d").getAs<nonloc::CompoundVal>(); - ASSERT_TRUE(D.has_value()); + ASSERT_TRUE(D.hasValue()); auto Begin = D->begin(); ASSERT_NE(D->end(), Begin); ++Begin; ASSERT_EQ(D->end(), Begin); auto LD = D->begin()->getAs<nonloc::LazyCompoundVal>(); - ASSERT_TRUE(LD.has_value()); + ASSERT_TRUE(LD.hasValue()); auto LDT = LD->getType(Context); ASSERT_FALSE(LDT.isNull()); const auto *DRecordType = dyn_cast<RecordType>(LDT); diff --git a/clang/unittests/Tooling/RefactoringTest.cpp b/clang/unittests/Tooling/RefactoringTest.cpp index f0edff6..c71a724 100644 --- a/clang/unittests/Tooling/RefactoringTest.cpp +++ b/clang/unittests/Tooling/RefactoringTest.cpp @@ -118,18 +118,18 @@ static bool checkReplacementError(llvm::Error &&Error, OS << "Unexpected error code: " << int(RE.get()) << "\n"; if (ExpectedExisting != RE.getExistingReplacement()) { OS << "Expected Existing != Actual Existing.\n"; - if (ExpectedExisting) + if (ExpectedExisting.hasValue()) OS << "Expected existing replacement: " << ExpectedExisting->toString() << "\n"; - if (RE.getExistingReplacement()) + if (RE.getExistingReplacement().hasValue()) OS << "Actual existing replacement: " << RE.getExistingReplacement()->toString() << "\n"; } if (ExpectedNew != RE.getNewReplacement()) { OS << "Expected New != Actual New.\n"; - if (ExpectedNew) + if (ExpectedNew.hasValue()) OS << "Expected new replacement: " << ExpectedNew->toString() << "\n"; - if (RE.getNewReplacement()) + if (RE.getNewReplacement().hasValue()) OS << "Actual new replacement: " << RE.getNewReplacement()->toString() << "\n"; } diff --git a/clang/utils/TableGen/RISCVVEmitter.cpp b/clang/utils/TableGen/RISCVVEmitter.cpp index f6678cc..7987d89 100644 --- a/clang/utils/TableGen/RISCVVEmitter.cpp +++ b/clang/utils/TableGen/RISCVVEmitter.cpp @@ -217,22 +217,22 @@ void RVVEmitter::createHeader(raw_ostream &OS) { for (int Log2LMUL : Log2LMULs) { auto T = RVVType::computeType(BasicType::Int8, Log2LMUL, PrototypeDescriptor::Mask); - if (T) - printType(*T); + if (T.hasValue()) + printType(T.getValue()); } // Print RVV int/float types. for (char I : StringRef("csil")) { BasicType BT = ParseBasicType(I); for (int Log2LMUL : Log2LMULs) { auto T = RVVType::computeType(BT, Log2LMUL, PrototypeDescriptor::Vector); - if (T) { - printType(*T); + if (T.hasValue()) { + printType(T.getValue()); auto UT = RVVType::computeType( BT, Log2LMUL, PrototypeDescriptor(BaseTypeModifier::Vector, VectorTypeModifier::NoModifier, TypeModifier::UnsignedInteger)); - printType(*UT); + printType(UT.getValue()); } } } @@ -240,8 +240,8 @@ void RVVEmitter::createHeader(raw_ostream &OS) { for (int Log2LMUL : Log2LMULs) { auto T = RVVType::computeType(BasicType::Float16, Log2LMUL, PrototypeDescriptor::Vector); - if (T) - printType(*T); + if (T.hasValue()) + printType(T.getValue()); } OS << "#endif\n"; @@ -249,8 +249,8 @@ void RVVEmitter::createHeader(raw_ostream &OS) { for (int Log2LMUL : Log2LMULs) { auto T = RVVType::computeType(BasicType::Float32, Log2LMUL, PrototypeDescriptor::Vector); - if (T) - printType(*T); + if (T.hasValue()) + printType(T.getValue()); } OS << "#endif\n"; @@ -258,8 +258,8 @@ void RVVEmitter::createHeader(raw_ostream &OS) { for (int Log2LMUL : Log2LMULs) { auto T = RVVType::computeType(BasicType::Float64, Log2LMUL, PrototypeDescriptor::Vector); - if (T) - printType(*T); + if (T.hasValue()) + printType(T.getValue()); } OS << "#endif\n\n"; diff --git a/flang/include/flang/Lower/IterationSpace.h b/flang/include/flang/Lower/IterationSpace.h index ed906e9..055882c 100644 --- a/flang/include/flang/Lower/IterationSpace.h +++ b/flang/include/flang/Lower/IterationSpace.h @@ -446,9 +446,7 @@ public: /// `load` must be a LHS array_load. Returns `llvm::None` on error. llvm::Optional<size_t> findArgPosition(fir::ArrayLoadOp load); - bool isLHS(fir::ArrayLoadOp load) { - return findArgPosition(load).has_value(); - } + bool isLHS(fir::ArrayLoadOp load) { return findArgPosition(load).hasValue(); } /// `load` must be a LHS array_load. Determine the threaded inner argument /// corresponding to this load. @@ -467,15 +465,15 @@ public: llvm::Optional<fir::ArrayLoadOp> getLhsLoad(size_t i) { assert(i < lhsBases.size()); - if (lhsBases[counter]) - return findBinding(*lhsBases[counter]); + if (lhsBases[counter].hasValue()) + return findBinding(lhsBases[counter].getValue()); return llvm::None; } /// Return the outermost loop in this FORALL nest. fir::DoLoopOp getOuterLoop() { - assert(outerLoop); - return *outerLoop; + assert(outerLoop.hasValue()); + return outerLoop.getValue(); } /// Return the statement context for the entire, outermost FORALL construct. diff --git a/flang/lib/Lower/Bridge.cpp b/flang/lib/Lower/Bridge.cpp index 745a7d4..b7d180e 100644 --- a/flang/lib/Lower/Bridge.cpp +++ b/flang/lib/Lower/Bridge.cpp @@ -2227,10 +2227,10 @@ private: llvm_unreachable("unknown category"); } if (lhsIsWholeAllocatable) - fir::factory::finalizeRealloc(*builder, loc, *lhsMutableBox, - /*lbounds=*/llvm::None, - /*takeLboundsIfRealloc=*/false, - *lhsRealloc); + fir::factory::finalizeRealloc( + *builder, loc, lhsMutableBox.getValue(), + /*lbounds=*/llvm::None, /*takeLboundsIfRealloc=*/false, + lhsRealloc.getValue()); }, // [2] User defined assignment. If the context is a scalar diff --git a/flang/lib/Lower/ConvertExpr.cpp b/flang/lib/Lower/ConvertExpr.cpp index 0558a10..07eceb7 100644 --- a/flang/lib/Lower/ConvertExpr.cpp +++ b/flang/lib/Lower/ConvertExpr.cpp @@ -2607,9 +2607,9 @@ public: funcSymbolAttr, operands); if (caller.mustSaveResult()) - builder.create<fir::SaveResultOp>(loc, call.getResult(0), - fir::getBase(*allocatedResult), - arrayResultShape, resultLengths); + builder.create<fir::SaveResultOp>( + loc, call.getResult(0), fir::getBase(allocatedResult.getValue()), + arrayResultShape, resultLengths); if (allocatedResult) { allocatedResult->match( @@ -4110,10 +4110,10 @@ private: mlir::Value{}); } } else if (isBoundsRemap()) { - auto lbs = *lbounds; + auto lbs = lbounds.getValue(); if (lbs.size() > 0) { // Rebox the value with user-specified shift and shape. - auto shapeShiftArgs = flatZip(lbs, *ubounds); + auto shapeShiftArgs = flatZip(lbs, ubounds.getValue()); auto shapeTy = fir::ShapeShiftType::get(eleTy.getContext(), lbs.size()); mlir::Value shapeShift = builder.create<fir::ShapeShiftOp>(loc, shapeTy, shapeShiftArgs); @@ -4185,8 +4185,8 @@ private: auto [iterSpace, insPt] = genIterSpace(resultTy); auto exv = f(iterSpace); iterSpace.setElement(std::move(exv)); - auto lambda = ccStoreToDest - ? *ccStoreToDest + auto lambda = ccStoreToDest.hasValue() + ? ccStoreToDest.getValue() : defaultStoreToDestination(/*substring=*/nullptr); mlir::Value updVal = fir::getBase(lambda(iterSpace)); finalizeElementCtx(); @@ -4522,8 +4522,8 @@ private: } // Generate the lazy mask allocation, if one was given. - if (ccPrelude) - ccPrelude.value()(shape); + if (ccPrelude.hasValue()) + ccPrelude.getValue()(shape); // Now handle the implicit loops. mlir::Value inner = explicitSpaceIsActive() @@ -4582,8 +4582,8 @@ private: fir::ArrayLoadOp createAndLoadSomeArrayTemp(mlir::Type type, llvm::ArrayRef<mlir::Value> shape) { - if (ccLoadDest) - return ccLoadDest.value()(shape); + if (ccLoadDest.hasValue()) + return ccLoadDest.getValue()(shape); auto seqTy = type.dyn_cast<fir::SequenceType>(); assert(seqTy && "must be an array"); mlir::Location loc = getLoc(); @@ -5810,8 +5810,8 @@ private: // always loaded at the beginning of the statement and merged at the // end. destination = arrLoad; - auto lambda = ccStoreToDest - ? ccStoreToDest.value() + auto lambda = ccStoreToDest.hasValue() + ? ccStoreToDest.getValue() : defaultStoreToDestination(components.substring); return [=](IterSpace iters) -> ExtValue { return lambda(iters); }; } @@ -6464,8 +6464,8 @@ private: // Return the continuation. if (fir::isa_char(seqTy.getEleTy())) { - if (charLen) { - auto len = builder.create<fir::LoadOp>(loc, charLen.value()); + if (charLen.hasValue()) { + auto len = builder.create<fir::LoadOp>(loc, charLen.getValue()); return genarr(fir::CharArrayBoxValue{mem, len, extents}); } return genarr(fir::CharArrayBoxValue{mem, zero, extents}); @@ -7181,14 +7181,14 @@ private: void setUnordered(bool b) { unordered = b; } - inline bool isPointerAssignment() const { return lbounds.has_value(); } + inline bool isPointerAssignment() const { return lbounds.hasValue(); } inline bool isBoundsSpec() const { - return isPointerAssignment() && !ubounds.has_value(); + return isPointerAssignment() && !ubounds.hasValue(); } inline bool isBoundsRemap() const { - return isPointerAssignment() && ubounds.has_value(); + return isPointerAssignment() && ubounds.hasValue(); } void setPointerAssignmentBounds( @@ -7515,8 +7515,8 @@ void Fortran::lower::createArrayLoads( auto genLoad = [&](const auto *x) -> fir::ArrayLoadOp { return genArrayLoad(loc, converter, builder, x, symMap, stmtCtx); }; - if (esp.lhsBases[counter]) { - auto &base = *esp.lhsBases[counter]; + if (esp.lhsBases[counter].hasValue()) { + auto &base = esp.lhsBases[counter].getValue(); auto load = std::visit(genLoad, base); esp.initialArgs.push_back(load); esp.resetInnerArgs(); @@ -7535,13 +7535,13 @@ void Fortran::lower::createArrayMergeStores( // Gen the fir.array_merge_store ops for all LHS arrays. for (auto i : llvm::enumerate(esp.getOuterLoop().getResults())) if (llvm::Optional<fir::ArrayLoadOp> ldOpt = esp.getLhsLoad(i.index())) { - fir::ArrayLoadOp load = *ldOpt; + fir::ArrayLoadOp load = ldOpt.getValue(); builder.create<fir::ArrayMergeStoreOp>(loc, load, i.value(), load.getMemref(), load.getSlice(), load.getTypeparams()); } - if (esp.loopCleanup) { - esp.loopCleanup.value()(builder); + if (esp.loopCleanup.hasValue()) { + esp.loopCleanup.getValue()(builder); esp.loopCleanup = llvm::None; } esp.initialArgs.clear(); diff --git a/flang/lib/Lower/CustomIntrinsicCall.cpp b/flang/lib/Lower/CustomIntrinsicCall.cpp index 9548045..1127e28 100644 --- a/flang/lib/Lower/CustomIntrinsicCall.cpp +++ b/flang/lib/Lower/CustomIntrinsicCall.cpp @@ -195,12 +195,12 @@ lowerIshftc(fir::FirOpBuilder &builder, mlir::Location loc, isPresentCheck(2) && "only ISHFTC SIZE arg is expected to be dynamically optional here"); assert(retTy && "ISFHTC must have a return type"); - mlir::Type resultType = *retTy; + mlir::Type resultType = retTy.getValue(); llvm::SmallVector<fir::ExtendedValue> args; args.push_back(getOperand(0)); args.push_back(getOperand(1)); args.push_back(builder - .genIfOp(loc, {resultType}, *isPresentCheck(2), + .genIfOp(loc, {resultType}, isPresentCheck(2).getValue(), /*withElseRegion=*/true) .genThen([&]() { fir::ExtendedValue sizeExv = getOperand(2); diff --git a/flang/lib/Lower/IterationSpace.cpp b/flang/lib/Lower/IterationSpace.cpp index 4458086..4d7a7f8 100644 --- a/flang/lib/Lower/IterationSpace.cpp +++ b/flang/lib/Lower/IterationSpace.cpp @@ -862,12 +862,12 @@ void Fortran::lower::ExplicitIterSpace::conditionalCleanup() { llvm::Optional<size_t> Fortran::lower::ExplicitIterSpace::findArgPosition(fir::ArrayLoadOp load) { - if (lhsBases[counter]) { - auto ld = loadBindings.find(*lhsBases[counter]); + if (lhsBases[counter].hasValue()) { + auto ld = loadBindings.find(lhsBases[counter].getValue()); llvm::Optional<size_t> optPos; if (ld != loadBindings.end() && ld->second == load) optPos = static_cast<size_t>(0u); - assert(optPos && "load does not correspond to lhs"); + assert(optPos.hasValue() && "load does not correspond to lhs"); return optPos; } return llvm::None; @@ -919,8 +919,8 @@ Fortran::lower::operator<<(llvm::raw_ostream &s, s << "LHS bases:\n"; for (const llvm::Optional<Fortran::lower::ExplicitIterSpace::ArrayBases> &u : e.lhsBases) - if (u) - dump(*u); + if (u.hasValue()) + dump(u.getValue()); s << "RHS bases:\n"; for (const llvm::SmallVector<Fortran::lower::ExplicitIterSpace::ArrayBases> &bases : e.rhsBases) { diff --git a/flang/lib/Optimizer/CodeGen/BoxedProcedure.cpp b/flang/lib/Optimizer/CodeGen/BoxedProcedure.cpp index 4cb1cf8..e652ca7 100644 --- a/flang/lib/Optimizer/CodeGen/BoxedProcedure.cpp +++ b/flang/lib/Optimizer/CodeGen/BoxedProcedure.cpp @@ -252,11 +252,11 @@ public: auto toTy = typeConverter.convertType(unwrapRefType(ty)); bool isPinned = mem.getPinned(); llvm::StringRef uniqName; - if (mem.getUniqName()) - uniqName = mem.getUniqName().value(); + if (mem.getUniqName().hasValue()) + uniqName = mem.getUniqName().getValue(); llvm::StringRef bindcName; - if (mem.getBindcName()) - bindcName = mem.getBindcName().value(); + if (mem.getBindcName().hasValue()) + bindcName = mem.getBindcName().getValue(); rewriter.replaceOpWithNewOp<AllocaOp>( mem, toTy, uniqName, bindcName, isPinned, mem.getTypeparams(), mem.getShape()); @@ -267,11 +267,11 @@ public: rewriter.setInsertionPoint(mem); auto toTy = typeConverter.convertType(unwrapRefType(ty)); llvm::StringRef uniqName; - if (mem.getUniqName()) - uniqName = mem.getUniqName().value(); + if (mem.getUniqName().hasValue()) + uniqName = mem.getUniqName().getValue(); llvm::StringRef bindcName; - if (mem.getBindcName()) - bindcName = mem.getBindcName().value(); + if (mem.getBindcName().hasValue()) + bindcName = mem.getBindcName().getValue(); rewriter.replaceOpWithNewOp<AllocMemOp>( mem, toTy, uniqName, bindcName, mem.getTypeparams(), mem.getShape()); diff --git a/flang/lib/Optimizer/CodeGen/CodeGen.cpp b/flang/lib/Optimizer/CodeGen/CodeGen.cpp index 5fc2e17..ad59bd7 100644 --- a/flang/lib/Optimizer/CodeGen/CodeGen.cpp +++ b/flang/lib/Optimizer/CodeGen/CodeGen.cpp @@ -2636,9 +2636,9 @@ struct GlobalOpConversion : public FIROpConversion<fir::GlobalOp> { auto loc = global.getLoc(); mlir::Attribute initAttr; if (global.getInitVal()) - initAttr = *global.getInitVal(); + initAttr = global.getInitVal().getValue(); auto linkage = convertLinkage(global.getLinkName()); - auto isConst = global.getConstant().has_value(); + auto isConst = global.getConstant().hasValue(); auto g = rewriter.create<mlir::LLVM::GlobalOp>( loc, tyAttr, isConst, linkage, global.getSymName(), initAttr); auto &gr = g.getInitializerRegion(); @@ -2692,8 +2692,8 @@ struct GlobalOpConversion : public FIROpConversion<fir::GlobalOp> { // enumeration. mlir::LLVM::Linkage convertLinkage(llvm::Optional<llvm::StringRef> optLinkage) const { - if (optLinkage) { - auto name = *optLinkage; + if (optLinkage.hasValue()) { + auto name = optLinkage.getValue(); if (name == "internal") return mlir::LLVM::Linkage::Internal; if (name == "linkonce") @@ -2749,9 +2749,9 @@ static void genCondBrOp(mlir::Location loc, mlir::Value cmp, mlir::Block *dest, llvm::Optional<mlir::ValueRange> destOps, mlir::ConversionPatternRewriter &rewriter, mlir::Block *newBlock) { - if (destOps) - rewriter.create<mlir::LLVM::CondBrOp>(loc, cmp, dest, *destOps, newBlock, - mlir::ValueRange()); + if (destOps.hasValue()) + rewriter.create<mlir::LLVM::CondBrOp>(loc, cmp, dest, destOps.getValue(), + newBlock, mlir::ValueRange()); else rewriter.create<mlir::LLVM::CondBrOp>(loc, cmp, dest, newBlock); } @@ -2759,8 +2759,9 @@ static void genCondBrOp(mlir::Location loc, mlir::Value cmp, mlir::Block *dest, template <typename A, typename B> static void genBrOp(A caseOp, mlir::Block *dest, llvm::Optional<B> destOps, mlir::ConversionPatternRewriter &rewriter) { - if (destOps) - rewriter.replaceOpWithNewOp<mlir::LLVM::BrOp>(caseOp, *destOps, dest); + if (destOps.hasValue()) + rewriter.replaceOpWithNewOp<mlir::LLVM::BrOp>(caseOp, destOps.getValue(), + dest); else rewriter.replaceOpWithNewOp<mlir::LLVM::BrOp>(caseOp, llvm::None, dest); } @@ -2883,14 +2884,15 @@ static void selectMatchAndRewrite(fir::LLVMTypeConverter &lowering, OP select, const mlir::Attribute &attr = cases[t]; if (auto intAttr = attr.template dyn_cast<mlir::IntegerAttr>()) { destinations.push_back(dest); - destinationsOperands.push_back(destOps ? *destOps : mlir::ValueRange{}); + destinationsOperands.push_back(destOps.hasValue() ? *destOps + : mlir::ValueRange{}); caseValues.push_back(intAttr.getInt()); continue; } assert(attr.template dyn_cast_or_null<mlir::UnitAttr>()); assert((t + 1 == conds) && "unit must be last"); defaultDestination = dest; - defaultOperands = destOps ? *destOps : mlir::ValueRange{}; + defaultOperands = destOps.hasValue() ? *destOps : mlir::ValueRange{}; } // LLVM::SwitchOp takes a i32 type for the selector. diff --git a/flang/lib/Optimizer/CodeGen/TargetRewrite.cpp b/flang/lib/Optimizer/CodeGen/TargetRewrite.cpp index 9b744fe..f1e58d4 100644 --- a/flang/lib/Optimizer/CodeGen/TargetRewrite.cpp +++ b/flang/lib/Optimizer/CodeGen/TargetRewrite.cpp @@ -316,9 +316,9 @@ public: newOpers.insert(newOpers.end(), trailingOpers.begin(), trailingOpers.end()); if constexpr (std::is_same_v<std::decay_t<A>, fir::CallOp>) { fir::CallOp newCall; - if (callOp.getCallee()) { - newCall = - rewriter->create<A>(loc, *callOp.getCallee(), newResTys, newOpers); + if (callOp.getCallee().hasValue()) { + newCall = rewriter->create<A>(loc, callOp.getCallee().getValue(), + newResTys, newOpers); } else { // Force new type on the input operand. newOpers[0].setType(mlir::FunctionType::get( diff --git a/flang/lib/Optimizer/Dialect/FIROps.cpp b/flang/lib/Optimizer/Dialect/FIROps.cpp index 7a6da50..6443d5c 100644 --- a/flang/lib/Optimizer/Dialect/FIROps.cpp +++ b/flang/lib/Optimizer/Dialect/FIROps.cpp @@ -616,10 +616,10 @@ mlir::FunctionType fir::CallOp::getFunctionType() { } void fir::CallOp::print(mlir::OpAsmPrinter &p) { - bool isDirect = getCallee().has_value(); + bool isDirect = getCallee().hasValue(); p << ' '; if (isDirect) - p << *getCallee(); + p << getCallee().getValue(); else p << getOperand(0); p << '(' << (*this)->getOperands().drop_front(isDirect ? 0 : 1) << ')'; @@ -700,8 +700,9 @@ static void printCmpOp(mlir::OpAsmPrinter &p, OPTY op) { op->template getAttrOfType<mlir::IntegerAttr>( OPTY::getPredicateAttrName()) .getInt()); - assert(predSym && "invalid symbol value for predicate"); - p << '"' << mlir::arith::stringifyCmpFPredicate(*predSym) << '"' << ", "; + assert(predSym.hasValue() && "invalid symbol value for predicate"); + p << '"' << mlir::arith::stringifyCmpFPredicate(predSym.getValue()) << '"' + << ", "; p.printOperand(op.getLhs()); p << ", "; p.printOperand(op.getRhs()); @@ -776,8 +777,8 @@ void fir::buildCmpCOp(mlir::OpBuilder &builder, mlir::OperationState &result, mlir::arith::CmpFPredicate fir::CmpcOp::getPredicateByName(llvm::StringRef name) { auto pred = mlir::arith::symbolizeCmpFPredicate(name); - assert(pred && "invalid predicate name"); - return *pred; + assert(pred.hasValue() && "invalid predicate name"); + return pred.getValue(); } void fir::CmpcOp::print(mlir::OpAsmPrinter &p) { printCmpOp(p, *this); } @@ -1073,7 +1074,7 @@ mlir::ParseResult fir::DispatchTableOp::parse(mlir::OpAsmParser &parser, // Parse the optional table body. mlir::Region *body = result.addRegion(); mlir::OptionalParseResult parseResult = parser.parseOptionalRegion(*body); - if (parseResult.has_value() && failed(*parseResult)) + if (parseResult.hasValue() && failed(*parseResult)) return mlir::failure(); fir::DispatchTableOp::ensureTerminator(*body, parser.getBuilder(), @@ -1255,15 +1256,15 @@ mlir::ParseResult fir::GlobalOp::parse(mlir::OpAsmParser &parser, // Parse the optional initializer body. auto parseResult = parser.parseOptionalRegion(*result.addRegion(), /*arguments=*/{}); - if (parseResult.has_value() && mlir::failed(*parseResult)) + if (parseResult.hasValue() && mlir::failed(*parseResult)) return mlir::failure(); } return mlir::success(); } void fir::GlobalOp::print(mlir::OpAsmPrinter &p) { - if (getLinkName()) - p << ' ' << *getLinkName(); + if (getLinkName().hasValue()) + p << ' ' << getLinkName().getValue(); p << ' '; p.printAttributeWithoutType(getSymrefAttr()); if (auto val = getValueOrNull()) diff --git a/flang/lib/Optimizer/Dialect/FIRType.cpp b/flang/lib/Optimizer/Dialect/FIRType.cpp index 5347d85..3293cad 100644 --- a/flang/lib/Optimizer/Dialect/FIRType.cpp +++ b/flang/lib/Optimizer/Dialect/FIRType.cpp @@ -120,7 +120,7 @@ mlir::Type fir::parseFirType(FIROpsDialect *dialect, return {}; mlir::Type genType; auto parseResult = generatedTypeParser(parser, typeTag, genType); - if (parseResult.has_value()) + if (parseResult.hasValue()) return genType; parser.emitError(parser.getNameLoc(), "unknown fir type: ") << typeTag; return {}; diff --git a/flang/lib/Optimizer/Support/InternalNames.cpp b/flang/lib/Optimizer/Support/InternalNames.cpp index 19a2740..8e37df2 100644 --- a/flang/lib/Optimizer/Support/InternalNames.cpp +++ b/flang/lib/Optimizer/Support/InternalNames.cpp @@ -51,8 +51,8 @@ convertToStringRef(llvm::ArrayRef<std::string> from) { inline llvm::Optional<llvm::StringRef> convertToStringRef(const llvm::Optional<std::string> &from) { llvm::Optional<llvm::StringRef> to; - if (from) - to = *from; + if (from.hasValue()) + to = from.getValue(); return to; } diff --git a/flang/lib/Optimizer/Transforms/AbstractResult.cpp b/flang/lib/Optimizer/Transforms/AbstractResult.cpp index 68f3247..7dd8214 100644 --- a/flang/lib/Optimizer/Transforms/AbstractResult.cpp +++ b/flang/lib/Optimizer/Transforms/AbstractResult.cpp @@ -101,7 +101,7 @@ public: llvm::SmallVector<mlir::Value> newOperands = {arg}; newOperands.append(callOp.getOperands().begin(), callOp.getOperands().end()); - rewriter.create<fir::CallOp>(loc, callOp.getCallee().value(), + rewriter.create<fir::CallOp>(loc, callOp.getCallee().getValue(), newResultTypes, newOperands); } else { // Indirect calls. diff --git a/flang/lib/Optimizer/Transforms/AffinePromotion.cpp b/flang/lib/Optimizer/Transforms/AffinePromotion.cpp index dd7b259..3890721 100644 --- a/flang/lib/Optimizer/Transforms/AffinePromotion.cpp +++ b/flang/lib/Optimizer/Transforms/AffinePromotion.cpp @@ -171,11 +171,11 @@ struct AffineIfCondition { fromCmpIOp(condDef); } - bool hasIntegerSet() const { return integerSet.has_value(); } + bool hasIntegerSet() const { return integerSet.hasValue(); } mlir::IntegerSet getIntegerSet() const { assert(hasIntegerSet() && "integer set is missing"); - return *integerSet; + return integerSet.getValue(); } mlir::ValueRange getAffineArgs() const { return affineArgs; } @@ -188,8 +188,8 @@ private: MaybeAffineExpr affineBinaryOp(mlir::AffineExprKind kind, MaybeAffineExpr lhs, MaybeAffineExpr rhs) { - if (lhs && rhs) - return mlir::getAffineBinaryOpExpr(kind, *lhs, *rhs); + if (lhs.hasValue() && rhs.hasValue()) + return mlir::getAffineBinaryOpExpr(kind, lhs.getValue(), rhs.getValue()); return {}; } @@ -233,14 +233,15 @@ private: void fromCmpIOp(mlir::arith::CmpIOp cmpOp) { auto lhsAffine = toAffineExpr(cmpOp.getLhs()); auto rhsAffine = toAffineExpr(cmpOp.getRhs()); - if (!lhsAffine || !rhsAffine) + if (!lhsAffine.hasValue() || !rhsAffine.hasValue()) return; - auto constraintPair = - constraint(cmpOp.getPredicate(), *rhsAffine - *lhsAffine); + auto constraintPair = constraint( + cmpOp.getPredicate(), rhsAffine.getValue() - lhsAffine.getValue()); if (!constraintPair) return; - integerSet = mlir::IntegerSet::get( - dimCount, symCount, {constraintPair->first}, {constraintPair->second}); + integerSet = mlir::IntegerSet::get(dimCount, symCount, + {constraintPair.getValue().first}, + {constraintPair.getValue().second}); return; } @@ -483,8 +484,8 @@ private: std::pair<mlir::AffineForOp, mlir::Value> createAffineFor(fir::DoLoopOp op, mlir::PatternRewriter &rewriter) const { if (auto constantStep = constantIntegerLike(op.getStep())) - if (*constantStep > 0) - return positiveConstantStep(op, *constantStep, rewriter); + if (constantStep.getValue() > 0) + return positiveConstantStep(op, constantStep.getValue(), rewriter); return genericBounds(op, rewriter); } diff --git a/flang/lib/Optimizer/Transforms/ExternalNameConversion.cpp b/flang/lib/Optimizer/Transforms/ExternalNameConversion.cpp index 42260ad..6170556 100644 --- a/flang/lib/Optimizer/Transforms/ExternalNameConversion.cpp +++ b/flang/lib/Optimizer/Transforms/ExternalNameConversion.cpp @@ -49,9 +49,9 @@ public: mlir::PatternRewriter &rewriter) const override { rewriter.startRootUpdate(op); auto callee = op.getCallee(); - if (callee) { - auto result = - fir::NameUniquer::deconstruct(callee->getRootReference().getValue()); + if (callee.hasValue()) { + auto result = fir::NameUniquer::deconstruct( + callee.getValue().getRootReference().getValue()); if (fir::NameUniquer::isExternalFacingUniquedName(result)) op.setCalleeAttr( SymbolRefAttr::get(op.getContext(), mangleExternalName(result))); @@ -137,9 +137,9 @@ void ExternalNameConversionPass::runOnOperation() { acc::OpenACCDialect, omp::OpenMPDialect>(); target.addDynamicallyLegalOp<fir::CallOp>([](fir::CallOp op) { - if (op.getCallee()) + if (op.getCallee().hasValue()) return !fir::NameUniquer::needExternalNameMangling( - op.getCallee()->getRootReference().getValue()); + op.getCallee().getValue().getRootReference().getValue()); return true; }); diff --git a/flang/unittests/Optimizer/Builder/FIRBuilderTest.cpp b/flang/unittests/Optimizer/Builder/FIRBuilderTest.cpp index 3172844..3997d8f 100644 --- a/flang/unittests/Optimizer/Builder/FIRBuilderTest.cpp +++ b/flang/unittests/Optimizer/Builder/FIRBuilderTest.cpp @@ -189,12 +189,12 @@ TEST_F(FIRBuilderTest, createGlobal1) { loc, i64Type, "global1", builder.createInternalLinkage(), {}, true); EXPECT_TRUE(mlir::isa<fir::GlobalOp>(global)); EXPECT_EQ("global1", global.getSymName()); - EXPECT_TRUE(global.getConstant().has_value()); + EXPECT_TRUE(global.getConstant().hasValue()); EXPECT_EQ(i64Type, global.getType()); - EXPECT_TRUE(global.getLinkName().has_value()); - EXPECT_EQ( - builder.createInternalLinkage().getValue(), global.getLinkName().value()); - EXPECT_FALSE(global.getInitVal().has_value()); + EXPECT_TRUE(global.getLinkName().hasValue()); + EXPECT_EQ(builder.createInternalLinkage().getValue(), + global.getLinkName().getValue()); + EXPECT_FALSE(global.getInitVal().hasValue()); auto g1 = builder.getNamedGlobal("global1"); EXPECT_EQ(global, g1); @@ -213,14 +213,15 @@ TEST_F(FIRBuilderTest, createGlobal2) { loc, i32Type, "global2", builder.createLinkOnceLinkage(), attr, false); EXPECT_TRUE(mlir::isa<fir::GlobalOp>(global)); EXPECT_EQ("global2", global.getSymName()); - EXPECT_FALSE(global.getConstant().has_value()); + EXPECT_FALSE(global.getConstant().hasValue()); EXPECT_EQ(i32Type, global.getType()); - EXPECT_TRUE(global.getInitVal().has_value()); - EXPECT_TRUE(global.getInitVal()->isa<mlir::IntegerAttr>()); - EXPECT_EQ(16, global.getInitVal()->cast<mlir::IntegerAttr>().getValue()); - EXPECT_TRUE(global.getLinkName().has_value()); + EXPECT_TRUE(global.getInitVal().hasValue()); + EXPECT_TRUE(global.getInitVal().getValue().isa<mlir::IntegerAttr>()); EXPECT_EQ( - builder.createLinkOnceLinkage().getValue(), global.getLinkName().value()); + 16, global.getInitVal().getValue().cast<mlir::IntegerAttr>().getValue()); + EXPECT_TRUE(global.getLinkName().hasValue()); + EXPECT_EQ(builder.createLinkOnceLinkage().getValue(), + global.getLinkName().getValue()); } TEST_F(FIRBuilderTest, uniqueCFIdent) { @@ -309,8 +310,8 @@ TEST_F(FIRBuilderTest, createStringLiteral) { auto addrOp = dyn_cast<fir::AddrOfOp>(addr.getDefiningOp()); auto symbol = addrOp.getSymbol().getRootReference().getValue(); auto global = builder.getNamedGlobal(symbol); - EXPECT_EQ( - builder.createLinkOnceLinkage().getValue(), global.getLinkName().value()); + EXPECT_EQ(builder.createLinkOnceLinkage().getValue(), + global.getLinkName().getValue()); EXPECT_EQ(fir::CharacterType::get(builder.getContext(), 1, strValue.size()), global.getType()); @@ -332,9 +333,9 @@ TEST_F(FIRBuilderTest, allocateLocal) { EXPECT_TRUE(mlir::isa<fir::AllocaOp>(var.getDefiningOp())); auto allocaOp = dyn_cast<fir::AllocaOp>(var.getDefiningOp()); EXPECT_EQ(builder.getI64Type(), allocaOp.getInType()); - EXPECT_TRUE(allocaOp.getBindcName().has_value()); - EXPECT_EQ(varName, allocaOp.getBindcName().value()); - EXPECT_FALSE(allocaOp.getUniqName().has_value()); + EXPECT_TRUE(allocaOp.getBindcName().hasValue()); + EXPECT_EQ(varName, allocaOp.getBindcName().getValue()); + EXPECT_FALSE(allocaOp.getUniqName().hasValue()); EXPECT_FALSE(allocaOp.getPinned()); EXPECT_EQ(0u, allocaOp.getTypeparams().size()); EXPECT_EQ(0u, allocaOp.getShape().size()); diff --git a/flang/unittests/Optimizer/Builder/Runtime/RuntimeCallTestBase.h b/flang/unittests/Optimizer/Builder/Runtime/RuntimeCallTestBase.h index 4b7c9f1..8d549c5 100644 --- a/flang/unittests/Optimizer/Builder/Runtime/RuntimeCallTestBase.h +++ b/flang/unittests/Optimizer/Builder/Runtime/RuntimeCallTestBase.h @@ -87,7 +87,7 @@ static inline void checkCallOp(mlir::Operation *op, llvm::StringRef fctName, unsigned nbArgs, bool addLocArgs = true) { EXPECT_TRUE(mlir::isa<fir::CallOp>(*op)); auto callOp = mlir::dyn_cast<fir::CallOp>(*op); - EXPECT_TRUE(callOp.getCallee().has_value()); + EXPECT_TRUE(callOp.getCallee().hasValue()); mlir::SymbolRefAttr callee = *callOp.getCallee(); EXPECT_EQ(fctName, callee.getRootReference().getValue()); // sourceFile and sourceLine are added arguments. diff --git a/lld/ELF/InputFiles.cpp b/lld/ELF/InputFiles.cpp index a9b00b7..926400d 100644 --- a/lld/ELF/InputFiles.cpp +++ b/lld/ELF/InputFiles.cpp @@ -744,9 +744,9 @@ static void updateARMVFPArgs(const ARMAttributeParser &attributes, static void updateSupportedARMFeatures(const ARMAttributeParser &attributes) { Optional<unsigned> attr = attributes.getAttributeValue(ARMBuildAttrs::CPU_arch); - if (!attr) + if (!attr.hasValue()) return; - auto arch = *attr; + auto arch = attr.getValue(); switch (arch) { case ARMBuildAttrs::Pre_v4: case ARMBuildAttrs::v4: diff --git a/lld/MachO/SectionPriorities.cpp b/lld/MachO/SectionPriorities.cpp index 0794217..cdabd3e 100644 --- a/lld/MachO/SectionPriorities.cpp +++ b/lld/MachO/SectionPriorities.cpp @@ -367,10 +367,10 @@ macho::PriorityBuilder::buildInputSectionPriorities() { auto addSym = [&](const Defined *sym) { Optional<size_t> symbolPriority = getSymbolPriority(sym); - if (!symbolPriority) + if (!symbolPriority.hasValue()) return; size_t &priority = sectionPriorities[sym->isec]; - priority = std::max(priority, *symbolPriority); + priority = std::max(priority, symbolPriority.getValue()); }; // TODO: Make sure this handles weak symbols correctly. diff --git a/lld/wasm/InputChunks.h b/lld/wasm/InputChunks.h index 066ca623..f962616 100644 --- a/lld/wasm/InputChunks.h +++ b/lld/wasm/InputChunks.h @@ -249,9 +249,9 @@ class InputFunction : public InputChunk { public: InputFunction(const WasmSignature &s, const WasmFunction *func, ObjFile *f) : InputChunk(f, InputChunk::Function, func->SymbolName), signature(s), - function(func), - exportName(func && func->ExportName ? (*func->ExportName).str() - : llvm::Optional<std::string>()) { + function(func), exportName(func && func->ExportName.hasValue() + ? (*func->ExportName).str() + : llvm::Optional<std::string>()) { inputSectionOffset = function->CodeSectionOffset; rawData = file->codeSection->Content.slice(inputSectionOffset, function->Size); @@ -268,17 +268,17 @@ public: } llvm::Optional<StringRef> getExportName() const { - return exportName ? llvm::Optional<StringRef>(*exportName) - : llvm::Optional<StringRef>(); + return exportName.hasValue() ? llvm::Optional<StringRef>(*exportName) + : llvm::Optional<StringRef>(); } void setExportName(std::string exportName) { this->exportName = exportName; } uint32_t getFunctionInputOffset() const { return getInputSectionOffset(); } uint32_t getFunctionCodeOffset() const { return function->CodeOffset; } - uint32_t getFunctionIndex() const { return *functionIndex; } - bool hasFunctionIndex() const { return functionIndex.has_value(); } + uint32_t getFunctionIndex() const { return functionIndex.getValue(); } + bool hasFunctionIndex() const { return functionIndex.hasValue(); } void setFunctionIndex(uint32_t index); - uint32_t getTableIndex() const { return *tableIndex; } - bool hasTableIndex() const { return tableIndex.has_value(); } + uint32_t getTableIndex() const { return tableIndex.getValue(); } + bool hasTableIndex() const { return tableIndex.hasValue(); } void setTableIndex(uint32_t index); void writeCompressed(uint8_t *buf) const; diff --git a/lld/wasm/InputElement.h b/lld/wasm/InputElement.h index 0d4e9b3..9bea90b 100644 --- a/lld/wasm/InputElement.h +++ b/lld/wasm/InputElement.h @@ -27,8 +27,8 @@ protected: public: StringRef getName() const { return name; } - uint32_t getAssignedIndex() const { return *assignedIndex; } - bool hasAssignedIndex() const { return assignedIndex.has_value(); } + uint32_t getAssignedIndex() const { return assignedIndex.getValue(); } + bool hasAssignedIndex() const { return assignedIndex.hasValue(); } void assignIndex(uint32_t index) { assert(!hasAssignedIndex()); assignedIndex = index; diff --git a/lld/wasm/Writer.cpp b/lld/wasm/Writer.cpp index 2de43ab..fa9802d 100644 --- a/lld/wasm/Writer.cpp +++ b/lld/wasm/Writer.cpp @@ -446,10 +446,10 @@ void Writer::populateTargetFeatures() { } // Only infer used features if user did not specify features - bool inferFeatures = !config->features.has_value(); + bool inferFeatures = !config->features.hasValue(); if (!inferFeatures) { - auto &explicitFeatures = config->features.value(); + auto &explicitFeatures = config->features.getValue(); allowed.insert(explicitFeatures.begin(), explicitFeatures.end()); if (!config->checkFeatures) goto done; diff --git a/lldb/include/lldb/Target/MemoryRegionInfo.h b/lldb/include/lldb/Target/MemoryRegionInfo.h index 8df7904..acca66e 100644 --- a/lldb/include/lldb/Target/MemoryRegionInfo.h +++ b/lldb/include/lldb/Target/MemoryRegionInfo.h @@ -124,8 +124,8 @@ public: void SetPageSize(int pagesize) { m_pagesize = pagesize; } void SetDirtyPageList(std::vector<lldb::addr_t> pagelist) { - if (m_dirty_pages) - m_dirty_pages->clear(); + if (m_dirty_pages.hasValue()) + m_dirty_pages.getValue().clear(); m_dirty_pages = std::move(pagelist); } diff --git a/lldb/source/API/SBMemoryRegionInfo.cpp b/lldb/source/API/SBMemoryRegionInfo.cpp index f4d78cf..d0f7437 100644 --- a/lldb/source/API/SBMemoryRegionInfo.cpp +++ b/lldb/source/API/SBMemoryRegionInfo.cpp @@ -135,8 +135,8 @@ uint32_t SBMemoryRegionInfo::GetNumDirtyPages() { uint32_t num_dirty_pages = 0; const llvm::Optional<std::vector<addr_t>> &dirty_page_list = m_opaque_up->GetDirtyPageList(); - if (dirty_page_list) - num_dirty_pages = dirty_page_list->size(); + if (dirty_page_list.hasValue()) + num_dirty_pages = dirty_page_list.getValue().size(); return num_dirty_pages; } @@ -147,8 +147,8 @@ addr_t SBMemoryRegionInfo::GetDirtyPageAddressAtIndex(uint32_t idx) { addr_t dirty_page_addr = LLDB_INVALID_ADDRESS; const llvm::Optional<std::vector<addr_t>> &dirty_page_list = m_opaque_up->GetDirtyPageList(); - if (dirty_page_list && idx < dirty_page_list->size()) - dirty_page_addr = dirty_page_list.value()[idx]; + if (dirty_page_list.hasValue() && idx < dirty_page_list.getValue().size()) + dirty_page_addr = dirty_page_list.getValue()[idx]; return dirty_page_addr; } diff --git a/lldb/source/Breakpoint/BreakpointIDList.cpp b/lldb/source/Breakpoint/BreakpointIDList.cpp index 20f75662..b434056 100644 --- a/lldb/source/Breakpoint/BreakpointIDList.cpp +++ b/lldb/source/Breakpoint/BreakpointIDList.cpp @@ -192,14 +192,16 @@ void BreakpointIDList::FindAndReplaceIDRanges(Args &old_args, Target *target, auto start_bp = BreakpointID::ParseCanonicalReference(range_from); auto end_bp = BreakpointID::ParseCanonicalReference(range_to); - if (!start_bp || !target->GetBreakpointByID(start_bp->GetBreakpointID())) { + if (!start_bp.hasValue() || + !target->GetBreakpointByID(start_bp->GetBreakpointID())) { new_args.Clear(); result.AppendErrorWithFormat("'%s' is not a valid breakpoint ID.\n", range_from.str().c_str()); return; } - if (!end_bp || !target->GetBreakpointByID(end_bp->GetBreakpointID())) { + if (!end_bp.hasValue() || + !target->GetBreakpointByID(end_bp->GetBreakpointID())) { new_args.Clear(); result.AppendErrorWithFormat("'%s' is not a valid breakpoint ID.\n", range_to.str().c_str()); diff --git a/lldb/source/Commands/CommandObjectFrame.cpp b/lldb/source/Commands/CommandObjectFrame.cpp index dfe1e14..4081e87 100644 --- a/lldb/source/Commands/CommandObjectFrame.cpp +++ b/lldb/source/Commands/CommandObjectFrame.cpp @@ -137,16 +137,16 @@ protected: ValueObjectSP valobj_sp; - if (m_options.address) { - if (m_options.reg || m_options.offset) { + if (m_options.address.hasValue()) { + if (m_options.reg.hasValue() || m_options.offset.hasValue()) { result.AppendError( "`frame diagnose --address` is incompatible with other arguments."); return false; } - valobj_sp = frame_sp->GuessValueForAddress(*m_options.address); - } else if (m_options.reg) { + valobj_sp = frame_sp->GuessValueForAddress(m_options.address.getValue()); + } else if (m_options.reg.hasValue()) { valobj_sp = frame_sp->GuessValueForRegisterAndOffset( - m_options.reg.value(), m_options.offset.value_or(0)); + m_options.reg.getValue(), m_options.offset.value_or(0)); } else { StopInfoSP stop_info_sp = thread->GetStopInfo(); if (!stop_info_sp) { diff --git a/lldb/source/Commands/CommandObjectMemory.cpp b/lldb/source/Commands/CommandObjectMemory.cpp index be887f1..117b5f4 100644 --- a/lldb/source/Commands/CommandObjectMemory.cpp +++ b/lldb/source/Commands/CommandObjectMemory.cpp @@ -1737,8 +1737,8 @@ protected: const llvm::Optional<std::vector<addr_t>> &dirty_page_list = range_info.GetDirtyPageList(); - if (dirty_page_list) { - const size_t page_count = dirty_page_list->size(); + if (dirty_page_list.hasValue()) { + const size_t page_count = dirty_page_list.getValue().size(); result.AppendMessageWithFormat( "Modified memory (dirty) page list provided, %zu entries.\n", page_count); diff --git a/lldb/source/Core/DataFileCache.cpp b/lldb/source/Core/DataFileCache.cpp index b38adfd..5f8568f 100644 --- a/lldb/source/Core/DataFileCache.cpp +++ b/lldb/source/Core/DataFileCache.cpp @@ -203,17 +203,17 @@ bool CacheSignature::Encode(DataEncoder &encoder) const { if (!IsValid()) return false; // Invalid signature, return false! - if (m_uuid) { + if (m_uuid.hasValue()) { llvm::ArrayRef<uint8_t> uuid_bytes = m_uuid->GetBytes(); encoder.AppendU8(eSignatureUUID); encoder.AppendU8(uuid_bytes.size()); encoder.AppendData(uuid_bytes); } - if (m_mod_time) { + if (m_mod_time.hasValue()) { encoder.AppendU8(eSignatureModTime); encoder.AppendU32(*m_mod_time); } - if (m_obj_mod_time) { + if (m_obj_mod_time.hasValue()) { encoder.AppendU8(eSignatureObjectModTime); encoder.AppendU32(*m_obj_mod_time); } diff --git a/lldb/source/Core/DumpDataExtractor.cpp b/lldb/source/Core/DumpDataExtractor.cpp index f96c232..211e16a 100644 --- a/lldb/source/Core/DumpDataExtractor.cpp +++ b/lldb/source/Core/DumpDataExtractor.cpp @@ -118,8 +118,8 @@ static lldb::offset_t DumpAPInt(Stream *s, const DataExtractor &data, lldb::offset_t offset, lldb::offset_t byte_size, bool is_signed, unsigned radix) { llvm::Optional<llvm::APInt> apint = GetAPInt(data, &offset, byte_size); - if (apint) { - std::string apint_str = toString(*apint, radix, is_signed); + if (apint.hasValue()) { + std::string apint_str = toString(apint.getValue(), radix, is_signed); switch (radix) { case 2: s->Write("0b", 2); @@ -670,8 +670,8 @@ lldb::offset_t lldb_private::DumpDataExtractor( (llvm::APFloat::getSizeInBits(semantics) + 7) / 8; llvm::Optional<llvm::APInt> apint = GetAPInt(DE, &offset, semantics_byte_size); - if (apint) { - llvm::APFloat apfloat(semantics, *apint); + if (apint.hasValue()) { + llvm::APFloat apfloat(semantics, apint.getValue()); apfloat.toString(sv, format_precision, format_max_padding); if (!sv.empty()) { s->Printf("%*.*s", (int)sv.size(), (int)sv.size(), sv.data()); diff --git a/lldb/source/Core/ValueObjectChild.cpp b/lldb/source/Core/ValueObjectChild.cpp index f0c91e4..a2beeb0 100644 --- a/lldb/source/Core/ValueObjectChild.cpp +++ b/lldb/source/Core/ValueObjectChild.cpp @@ -82,8 +82,8 @@ ConstString ValueObjectChild::GetDisplayTypeName() { } LazyBool ValueObjectChild::CanUpdateWithInvalidExecutionContext() { - if (m_can_update_with_invalid_exe_ctx) - return *m_can_update_with_invalid_exe_ctx; + if (m_can_update_with_invalid_exe_ctx.hasValue()) + return m_can_update_with_invalid_exe_ctx.getValue(); if (m_parent) { ValueObject *opinionated_parent = m_parent->FollowParentChain([](ValueObject *valobj) -> bool { @@ -93,11 +93,11 @@ LazyBool ValueObjectChild::CanUpdateWithInvalidExecutionContext() { if (opinionated_parent) return (m_can_update_with_invalid_exe_ctx = opinionated_parent->CanUpdateWithInvalidExecutionContext()) - .value(); + .getValue(); } return (m_can_update_with_invalid_exe_ctx = this->ValueObject::CanUpdateWithInvalidExecutionContext()) - .value(); + .getValue(); } bool ValueObjectChild::UpdateValue() { diff --git a/lldb/source/Host/common/File.cpp b/lldb/source/Host/common/File.cpp index 476ab23..760fb98 100644 --- a/lldb/source/Host/common/File.cpp +++ b/lldb/source/Host/common/File.cpp @@ -833,19 +833,22 @@ SerialPort::Create(int fd, OpenOptions options, Options serial_options, if (llvm::Error error = term.SetRaw()) return std::move(error); if (serial_options.BaudRate) { - if (llvm::Error error = term.SetBaudRate(*serial_options.BaudRate)) + if (llvm::Error error = + term.SetBaudRate(serial_options.BaudRate.getValue())) return std::move(error); } if (serial_options.Parity) { - if (llvm::Error error = term.SetParity(*serial_options.Parity)) + if (llvm::Error error = term.SetParity(serial_options.Parity.getValue())) return std::move(error); } if (serial_options.ParityCheck) { - if (llvm::Error error = term.SetParityCheck(*serial_options.ParityCheck)) + if (llvm::Error error = + term.SetParityCheck(serial_options.ParityCheck.getValue())) return std::move(error); } if (serial_options.StopBits) { - if (llvm::Error error = term.SetStopBits(*serial_options.StopBits)) + if (llvm::Error error = + term.SetStopBits(serial_options.StopBits.getValue())) return std::move(error); } diff --git a/lldb/source/Host/common/Terminal.cpp b/lldb/source/Host/common/Terminal.cpp index 6eb7332..831e9df 100644 --- a/lldb/source/Host/common/Terminal.cpp +++ b/lldb/source/Host/common/Terminal.cpp @@ -281,11 +281,11 @@ llvm::Error Terminal::SetBaudRate(unsigned int baud_rate) { return llvm::createStringError(llvm::inconvertibleErrorCode(), "baud rate %d unsupported by the platform", baud_rate); - if (::cfsetispeed(&fd_termios, *val) != 0) + if (::cfsetispeed(&fd_termios, val.getValue()) != 0) return llvm::createStringError( std::error_code(errno, std::generic_category()), "setting input baud rate failed"); - if (::cfsetospeed(&fd_termios, *val) != 0) + if (::cfsetospeed(&fd_termios, val.getValue()) != 0) return llvm::createStringError( std::error_code(errno, std::generic_category()), "setting output baud rate failed"); diff --git a/lldb/source/Plugins/ABI/X86/ABIX86.cpp b/lldb/source/Plugins/ABI/X86/ABIX86.cpp index 64c5d5a..2cd653f 100644 --- a/lldb/source/Plugins/ABI/X86/ABIX86.cpp +++ b/lldb/source/Plugins/ABI/X86/ABIX86.cpp @@ -100,8 +100,8 @@ addCombinedRegisters(std::vector<DynamicRegisterInfo::Register> ®s, if (regdata1->subreg_name != regdata2->subreg_name) continue; - uint32_t base_index1 = *regdata1->base_index; - uint32_t base_index2 = *regdata2->base_index; + uint32_t base_index1 = regdata1->base_index.getValue(); + uint32_t base_index2 = regdata2->base_index.getValue(); if (regs[base_index1].byte_size != base_size || regs[base_index2].byte_size != base_size) continue; diff --git a/lldb/source/Plugins/Disassembler/LLVMC/DisassemblerLLVMC.cpp b/lldb/source/Plugins/Disassembler/LLVMC/DisassemblerLLVMC.cpp index 1f5addc..e4c7e8f 100644 --- a/lldb/source/Plugins/Disassembler/LLVMC/DisassemblerLLVMC.cpp +++ b/lldb/source/Plugins/Disassembler/LLVMC/DisassemblerLLVMC.cpp @@ -1382,14 +1382,14 @@ const char *DisassemblerLLVMC::SymbolLookup(uint64_t value, uint64_t *type_ptr, // the ADRP's register and this ADD's register are the same, // then this is a pc-relative address calculation. if (*type_ptr == LLVMDisassembler_ReferenceType_In_ARM64_ADDXri && - m_adrp_insn && m_adrp_address == pc - 4 && - (*m_adrp_insn & 0x1f) == ((value >> 5) & 0x1f)) { + m_adrp_insn.hasValue() && m_adrp_address == pc - 4 && + (m_adrp_insn.getValue() & 0x1f) == ((value >> 5) & 0x1f)) { uint32_t addxri_inst; uint64_t adrp_imm, addxri_imm; // Get immlo and immhi bits, OR them together to get the ADRP imm // value. - adrp_imm = - ((*m_adrp_insn & 0x00ffffe0) >> 3) | ((*m_adrp_insn >> 29) & 0x3); + adrp_imm = ((m_adrp_insn.getValue() & 0x00ffffe0) >> 3) | + ((m_adrp_insn.getValue() >> 29) & 0x3); // if high bit of immhi after right-shifting set, sign extend if (adrp_imm & (1ULL << 20)) adrp_imm |= ~((1ULL << 21) - 1); diff --git a/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp b/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp index 4f23ff4..82f8258 100644 --- a/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp +++ b/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp @@ -218,10 +218,10 @@ void CPlusPlusLanguage::MethodName::Parse() { } else { CPlusPlusNameParser parser(m_full.GetStringRef()); if (auto function = parser.ParseAsFunctionDefinition()) { - m_basename = function->name.basename; - m_context = function->name.context; - m_arguments = function->arguments; - m_qualifiers = function->qualifiers; + m_basename = function.getValue().name.basename; + m_context = function.getValue().name.context; + m_arguments = function.getValue().arguments; + m_qualifiers = function.getValue().qualifiers; m_parse_error = false; } else { m_parse_error = true; @@ -329,8 +329,8 @@ bool CPlusPlusLanguage::ExtractContextAndIdentifier( CPlusPlusNameParser parser(name); if (auto full_name = parser.ParseAsFullName()) { - identifier = full_name->basename; - context = full_name->context; + identifier = full_name.getValue().basename; + context = full_name.getValue().context; return true; } return false; diff --git a/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusNameParser.cpp b/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusNameParser.cpp index 3a1fde2..eca36ff 100644 --- a/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusNameParser.cpp +++ b/lldb/source/Plugins/Language/CPlusPlus/CPlusPlusNameParser.cpp @@ -55,8 +55,8 @@ Optional<ParsedName> CPlusPlusNameParser::ParseAsFullName() { if (HasMoreTokens()) return None; ParsedName result; - result.basename = GetTextForRange(name_ranges->basename_range); - result.context = GetTextForRange(name_ranges->context_range); + result.basename = GetTextForRange(name_ranges.getValue().basename_range); + result.context = GetTextForRange(name_ranges.getValue().context_range); return result; } @@ -125,8 +125,8 @@ CPlusPlusNameParser::ParseFunctionImpl(bool expect_return_type) { size_t end_position = GetCurrentPosition(); ParsedFunction result; - result.name.basename = GetTextForRange(maybe_name->basename_range); - result.name.context = GetTextForRange(maybe_name->context_range); + result.name.basename = GetTextForRange(maybe_name.getValue().basename_range); + result.name.context = GetTextForRange(maybe_name.getValue().context_range); result.arguments = GetTextForRange(Range(argument_start, qualifiers_start)); result.qualifiers = GetTextForRange(Range(qualifiers_start, end_position)); start_position.Remove(); @@ -616,10 +616,10 @@ CPlusPlusNameParser::ParseFullNameImpl() { state == State::AfterTemplate) { ParsedNameRanges result; if (last_coloncolon_position) { - result.context_range = - Range(start_position.GetSavedPosition(), *last_coloncolon_position); + result.context_range = Range(start_position.GetSavedPosition(), + last_coloncolon_position.getValue()); result.basename_range = - Range(*last_coloncolon_position + 1, GetCurrentPosition()); + Range(last_coloncolon_position.getValue() + 1, GetCurrentPosition()); } else { result.basename_range = Range(start_position.GetSavedPosition(), GetCurrentPosition()); diff --git a/lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp b/lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp index 045bdd4..fdebfcd3 100644 --- a/lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp +++ b/lldb/source/Plugins/ObjectFile/Mach-O/ObjectFileMachO.cpp @@ -6516,8 +6516,8 @@ bool ObjectFileMachO::SaveCore(const lldb::ProcessSP &process_sp, addr_t pagesize = range_info.GetPageSize(); const llvm::Optional<std::vector<addr_t>> &dirty_page_list = range_info.GetDirtyPageList(); - if (dirty_pages_only && dirty_page_list) { - for (addr_t dirtypage : *dirty_page_list) { + if (dirty_pages_only && dirty_page_list.hasValue()) { + for (addr_t dirtypage : dirty_page_list.getValue()) { page_object obj; obj.addr = dirtypage; obj.size = pagesize; diff --git a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp index c44ace9..9f159f6 100644 --- a/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp +++ b/lldb/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp @@ -2722,12 +2722,12 @@ bool GDBRemoteCommunicationClient::SetCurrentThread(uint64_t tid, return true; llvm::Optional<PidTid> ret = SendSetCurrentThreadPacket(tid, pid, 'g'); - if (ret) { + if (ret.hasValue()) { if (ret->pid != LLDB_INVALID_PROCESS_ID) m_curr_pid = ret->pid; m_curr_tid = ret->tid; } - return ret.has_value(); + return ret.hasValue(); } bool GDBRemoteCommunicationClient::SetCurrentThreadForRun(uint64_t tid, @@ -2737,12 +2737,12 @@ bool GDBRemoteCommunicationClient::SetCurrentThreadForRun(uint64_t tid, return true; llvm::Optional<PidTid> ret = SendSetCurrentThreadPacket(tid, pid, 'c'); - if (ret) { + if (ret.hasValue()) { if (ret->pid != LLDB_INVALID_PROCESS_ID) m_curr_pid_run = ret->pid; m_curr_tid_run = ret->tid; } - return ret.has_value(); + return ret.hasValue(); } bool GDBRemoteCommunicationClient::GetStopReply( diff --git a/lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.cpp b/lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.cpp index b5615c3..11175a4 100644 --- a/lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.cpp +++ b/lldb/source/Plugins/SymbolFile/Breakpad/SymbolFileBreakpad.cpp @@ -674,9 +674,9 @@ SymbolFileBreakpad::ParseCFIUnwindPlan(const Bookmark &bookmark, plan_sp->AppendRow(row_sp); for (++It; It != End; ++It) { llvm::Optional<StackCFIRecord> record = StackCFIRecord::parse(*It); - if (!record) + if (!record.hasValue()) return nullptr; - if (record->Size) + if (record->Size.hasValue()) break; row_sp = std::make_shared<UnwindPlan::Row>(*row_sp); diff --git a/lldb/source/Target/Thread.cpp b/lldb/source/Target/Thread.cpp index 247913c..3803748 100644 --- a/lldb/source/Target/Thread.cpp +++ b/lldb/source/Target/Thread.cpp @@ -2022,8 +2022,7 @@ lldb::ValueObjectSP Thread::GetSiginfoValue() { llvm::Optional<uint64_t> type_size = type.GetByteSize(nullptr); assert(type_size); - llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>> data = - GetSiginfo(*type_size); + llvm::Expected<std::unique_ptr<llvm::MemoryBuffer>> data = GetSiginfo(type_size.getValue()); if (!data) return ValueObjectConstResult::Create(&target, Status(data.takeError())); diff --git a/lldb/source/Target/UnixSignals.cpp b/lldb/source/Target/UnixSignals.cpp index a92138a..de1fdb8 100644 --- a/lldb/source/Target/UnixSignals.cpp +++ b/lldb/source/Target/UnixSignals.cpp @@ -300,13 +300,14 @@ UnixSignals::GetFilteredSignals(llvm::Optional<bool> should_suppress, // If any of filtering conditions are not met, we move on to the next // signal. - if (should_suppress && signal_suppress != *should_suppress) + if (should_suppress.hasValue() && + signal_suppress != should_suppress.getValue()) continue; - if (should_stop && signal_stop != *should_stop) + if (should_stop.hasValue() && signal_stop != should_stop.getValue()) continue; - if (should_notify && signal_notify != *should_notify) + if (should_notify.hasValue() && signal_notify != should_notify.getValue()) continue; result.push_back(signo); diff --git a/lldb/source/Utility/SelectHelper.cpp b/lldb/source/Utility/SelectHelper.cpp index 69b2abf..eee6895 100644 --- a/lldb/source/Utility/SelectHelper.cpp +++ b/lldb/source/Utility/SelectHelper.cpp @@ -161,15 +161,15 @@ lldb_private::Status SelectHelper::Select() { fd_set write_fdset; fd_set error_fdset; - if (max_read_fd) { + if (max_read_fd.hasValue()) { FD_ZERO(&read_fdset); read_fdset_ptr = &read_fdset; } - if (max_write_fd) { + if (max_write_fd.hasValue()) { FD_ZERO(&write_fdset); write_fdset_ptr = &write_fdset; } - if (max_error_fd) { + if (max_error_fd.hasValue()) { FD_ZERO(&error_fdset); error_fdset_ptr = &error_fdset; } @@ -195,10 +195,10 @@ lldb_private::Status SelectHelper::Select() { while (true) { using namespace std::chrono; // Setup out relative timeout based on the end time if we have one - if (m_end_time) { + if (m_end_time.hasValue()) { tv_ptr = &tv; - const auto remaining_dur = - duration_cast<microseconds>(*m_end_time - steady_clock::now()); + const auto remaining_dur = duration_cast<microseconds>( + m_end_time.getValue() - steady_clock::now()); if (remaining_dur.count() > 0) { // Wait for a specific amount of time const auto dur_secs = duration_cast<seconds>(remaining_dur); diff --git a/lldb/unittests/Host/ConnectionFileDescriptorTest.cpp b/lldb/unittests/Host/ConnectionFileDescriptorTest.cpp index 14a0d17..eb4b824 100644 --- a/lldb/unittests/Host/ConnectionFileDescriptorTest.cpp +++ b/lldb/unittests/Host/ConnectionFileDescriptorTest.cpp @@ -28,7 +28,7 @@ public: std::string uri(connection_file_descriptor.GetURI()); EXPECT_EQ((URI{"connect", ip, socket->GetRemotePortNumber(), "/"}), - *URI::Parse(uri)); + URI::Parse(uri).getValue()); } }; diff --git a/lldb/unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp b/lldb/unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp index b80c44d..d15b852 100644 --- a/lldb/unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp +++ b/lldb/unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp @@ -190,14 +190,14 @@ TEST_F(GDBRemoteCommunicationClientTest, GetModulesInfo) { R"("file_path":"/foo/bar.so","file_offset":0,"file_size":1234}]])"); auto result = async_result.get(); - ASSERT_TRUE(result.has_value()); + ASSERT_TRUE(result.hasValue()); ASSERT_EQ(1u, result->size()); - EXPECT_EQ("/foo/bar.so", result.value()[0].GetFileSpec().GetPath()); - EXPECT_EQ(triple, result.value()[0].GetArchitecture().GetTriple()); + EXPECT_EQ("/foo/bar.so", result.getValue()[0].GetFileSpec().GetPath()); + EXPECT_EQ(triple, result.getValue()[0].GetArchitecture().GetTriple()); EXPECT_EQ(UUID::fromData("@ABCDEFGHIJKLMNO", 16), - result.value()[0].GetUUID()); - EXPECT_EQ(0u, result.value()[0].GetObjectOffset()); - EXPECT_EQ(1234u, result.value()[0].GetObjectSize()); + result.getValue()[0].GetUUID()); + EXPECT_EQ(0u, result.getValue()[0].GetObjectOffset()); + EXPECT_EQ(1234u, result.getValue()[0].GetObjectSize()); } TEST_F(GDBRemoteCommunicationClientTest, GetModulesInfo_UUID20) { @@ -215,14 +215,14 @@ TEST_F(GDBRemoteCommunicationClientTest, GetModulesInfo_UUID20) { R"("file_path":"/foo/bar.so","file_offset":0,"file_size":1234}]])"); auto result = async_result.get(); - ASSERT_TRUE(result.has_value()); + ASSERT_TRUE(result.hasValue()); ASSERT_EQ(1u, result->size()); - EXPECT_EQ("/foo/bar.so", result.value()[0].GetFileSpec().GetPath()); - EXPECT_EQ(triple, result.value()[0].GetArchitecture().GetTriple()); + EXPECT_EQ("/foo/bar.so", result.getValue()[0].GetFileSpec().GetPath()); + EXPECT_EQ(triple, result.getValue()[0].GetArchitecture().GetTriple()); EXPECT_EQ(UUID::fromData("@ABCDEFGHIJKLMNOPQRS", 20), - result.value()[0].GetUUID()); - EXPECT_EQ(0u, result.value()[0].GetObjectOffset()); - EXPECT_EQ(1234u, result.value()[0].GetObjectSize()); + result.getValue()[0].GetUUID()); + EXPECT_EQ(0u, result.getValue()[0].GetObjectOffset()); + EXPECT_EQ(1234u, result.getValue()[0].GetObjectSize()); } TEST_F(GDBRemoteCommunicationClientTest, GetModulesInfoInvalidResponse) { diff --git a/lldb/unittests/Process/minidump/MinidumpParserTest.cpp b/lldb/unittests/Process/minidump/MinidumpParserTest.cpp index 85a15b8..95e2cf3 100644 --- a/lldb/unittests/Process/minidump/MinidumpParserTest.cpp +++ b/lldb/unittests/Process/minidump/MinidumpParserTest.cpp @@ -183,7 +183,7 @@ Streams: )"), llvm::Succeeded()); llvm::Optional<LinuxProcStatus> proc_status = parser->GetLinuxProcStatus(); - ASSERT_TRUE(proc_status.has_value()); + ASSERT_TRUE(proc_status.hasValue()); lldb::pid_t pid = proc_status->GetPid(); ASSERT_EQ(16001UL, pid); } @@ -218,8 +218,8 @@ Streams: )"), llvm::Succeeded()); llvm::Optional<lldb::pid_t> pid = parser->GetPid(); - ASSERT_TRUE(pid.has_value()); - ASSERT_EQ(16001UL, *pid); + ASSERT_TRUE(pid.hasValue()); + ASSERT_EQ(16001UL, pid.getValue()); } TEST_F(MinidumpParserTest, GetFilteredModuleList) { @@ -260,7 +260,7 @@ TEST_F(MinidumpParserTest, GetExceptionStream) { void check_mem_range_exists(MinidumpParser &parser, const uint64_t range_start, const uint64_t range_size) { llvm::Optional<minidump::Range> range = parser.FindMemoryRange(range_start); - ASSERT_TRUE(range.has_value()) << "There is no range containing this address"; + ASSERT_TRUE(range.hasValue()) << "There is no range containing this address"; EXPECT_EQ(range_start, range->start); EXPECT_EQ(range_start + range_size, range->start + range->range_ref.size()); } @@ -321,14 +321,14 @@ TEST_F(MinidumpParserTest, FindMemoryRangeWithFullMemoryMinidump) { SetUpData("fizzbuzz_wow64.dmp"); // There are a lot of ranges in the file, just testing with some of them - EXPECT_FALSE(parser->FindMemoryRange(0x00).has_value()); - EXPECT_FALSE(parser->FindMemoryRange(0x2a).has_value()); + EXPECT_FALSE(parser->FindMemoryRange(0x00).hasValue()); + EXPECT_FALSE(parser->FindMemoryRange(0x2a).hasValue()); check_mem_range_exists(*parser, 0x10000, 65536); // first range check_mem_range_exists(*parser, 0x40000, 4096); - EXPECT_FALSE(parser->FindMemoryRange(0x40000 + 4096).has_value()); + EXPECT_FALSE(parser->FindMemoryRange(0x40000 + 4096).hasValue()); check_mem_range_exists(*parser, 0x77c12000, 8192); check_mem_range_exists(*parser, 0x7ffe0000, 4096); // last range - EXPECT_FALSE(parser->FindMemoryRange(0x7ffe0000 + 4096).has_value()); + EXPECT_FALSE(parser->FindMemoryRange(0x7ffe0000 + 4096).hasValue()); } constexpr auto yes = MemoryRegionInfo::eYes; @@ -544,23 +544,23 @@ TEST_F(MinidumpParserTest, GetMiscInfoWindows) { const MinidumpMiscInfo *misc_info = parser->GetMiscInfo(); ASSERT_NE(nullptr, misc_info); llvm::Optional<lldb::pid_t> pid = misc_info->GetPid(); - ASSERT_TRUE(pid.has_value()); - ASSERT_EQ(4440UL, *pid); + ASSERT_TRUE(pid.hasValue()); + ASSERT_EQ(4440UL, pid.getValue()); } TEST_F(MinidumpParserTest, GetPidWindows) { SetUpData("fizzbuzz_no_heap.dmp"); llvm::Optional<lldb::pid_t> pid = parser->GetPid(); - ASSERT_TRUE(pid.has_value()); - ASSERT_EQ(4440UL, *pid); + ASSERT_TRUE(pid.hasValue()); + ASSERT_EQ(4440UL, pid.getValue()); } // wow64 TEST_F(MinidumpParserTest, GetPidWow64) { SetUpData("fizzbuzz_wow64.dmp"); llvm::Optional<lldb::pid_t> pid = parser->GetPid(); - ASSERT_TRUE(pid.has_value()); - ASSERT_EQ(7836UL, *pid); + ASSERT_TRUE(pid.hasValue()); + ASSERT_EQ(7836UL, pid.getValue()); } // Register tests diff --git a/lldb/unittests/Target/FindFileTest.cpp b/lldb/unittests/Target/FindFileTest.cpp index 6715c34..77d374d 100644 --- a/lldb/unittests/Target/FindFileTest.cpp +++ b/lldb/unittests/Target/FindFileTest.cpp @@ -56,7 +56,7 @@ static void TestFileFindings(const PathMappingList &map, llvm::Optional<FileSpec> remapped; EXPECT_TRUE(bool(remapped = map.FindFile(match.original))); - EXPECT_TRUE(FileSpec(*remapped).GetPath() == + EXPECT_TRUE(FileSpec(remapped.getValue()).GetPath() == ConstString(match.remapped).GetStringRef()); } } diff --git a/lldb/unittests/Utility/StringExtractorGDBRemoteTest.cpp b/lldb/unittests/Utility/StringExtractorGDBRemoteTest.cpp index 922167c..88362c0 100644 --- a/lldb/unittests/Utility/StringExtractorGDBRemoteTest.cpp +++ b/lldb/unittests/Utility/StringExtractorGDBRemoteTest.cpp @@ -109,77 +109,77 @@ TEST(StringExtractorGDBRemoteTest, GetPidTid) { // pure thread id ex.Reset("-1"); - EXPECT_THAT(ex.GetPidTid(100).value(), + EXPECT_THAT(ex.GetPidTid(100).getValue(), ::testing::Pair(100, StringExtractorGDBRemote::AllThreads)); ex.Reset("1234"); - EXPECT_THAT(ex.GetPidTid(100).value(), ::testing::Pair(100, 0x1234ULL)); + EXPECT_THAT(ex.GetPidTid(100).getValue(), ::testing::Pair(100, 0x1234ULL)); ex.Reset("123456789ABCDEF0"); - EXPECT_THAT(ex.GetPidTid(100).value(), + EXPECT_THAT(ex.GetPidTid(100).getValue(), ::testing::Pair(100, 0x123456789ABCDEF0ULL)); // pure process id ex.Reset("p-1"); - EXPECT_THAT(ex.GetPidTid(100).value(), + EXPECT_THAT(ex.GetPidTid(100).getValue(), ::testing::Pair(StringExtractorGDBRemote::AllProcesses, StringExtractorGDBRemote::AllThreads)); ex.Reset("p1234"); - EXPECT_THAT(ex.GetPidTid(100).value(), + EXPECT_THAT(ex.GetPidTid(100).getValue(), ::testing::Pair(0x1234ULL, StringExtractorGDBRemote::AllThreads)); ex.Reset("p123456789ABCDEF0"); - EXPECT_THAT(ex.GetPidTid(100).value(), + EXPECT_THAT(ex.GetPidTid(100).getValue(), ::testing::Pair(0x123456789ABCDEF0ULL, StringExtractorGDBRemote::AllThreads)); ex.Reset("pFFFFFFFFFFFFFFFF"); - EXPECT_THAT(ex.GetPidTid(100).value(), + EXPECT_THAT(ex.GetPidTid(100).getValue(), ::testing::Pair(StringExtractorGDBRemote::AllProcesses, StringExtractorGDBRemote::AllThreads)); // combined thread id + process id ex.Reset("p-1.-1"); - EXPECT_THAT(ex.GetPidTid(100).value(), + EXPECT_THAT(ex.GetPidTid(100).getValue(), ::testing::Pair(StringExtractorGDBRemote::AllProcesses, StringExtractorGDBRemote::AllThreads)); ex.Reset("p1234.-1"); - EXPECT_THAT(ex.GetPidTid(100).value(), + EXPECT_THAT(ex.GetPidTid(100).getValue(), ::testing::Pair(0x1234ULL, StringExtractorGDBRemote::AllThreads)); ex.Reset("p1234.123456789ABCDEF0"); - EXPECT_THAT(ex.GetPidTid(100).value(), + EXPECT_THAT(ex.GetPidTid(100).getValue(), ::testing::Pair(0x1234ULL, 0x123456789ABCDEF0ULL)); ex.Reset("p123456789ABCDEF0.-1"); - EXPECT_THAT(ex.GetPidTid(100).value(), + EXPECT_THAT(ex.GetPidTid(100).getValue(), ::testing::Pair(0x123456789ABCDEF0ULL, StringExtractorGDBRemote::AllThreads)); ex.Reset("p123456789ABCDEF0.1234"); - EXPECT_THAT(ex.GetPidTid(100).value(), + EXPECT_THAT(ex.GetPidTid(100).getValue(), ::testing::Pair(0x123456789ABCDEF0ULL, 0x1234ULL)); ex.Reset("p123456789ABCDEF0.123456789ABCDEF0"); - EXPECT_THAT(ex.GetPidTid(100).value(), + EXPECT_THAT(ex.GetPidTid(100).getValue(), ::testing::Pair(0x123456789ABCDEF0ULL, 0x123456789ABCDEF0ULL)); ex.Reset("p123456789ABCDEF0.123456789ABCDEF0"); - EXPECT_THAT(ex.GetPidTid(100).value(), + EXPECT_THAT(ex.GetPidTid(100).getValue(), ::testing::Pair(0x123456789ABCDEF0ULL, 0x123456789ABCDEF0ULL)); } TEST(StringExtractorGDBRemoteTest, GetPidTidMultipleValues) { StringExtractorGDBRemote ex("1234;p12;p1234.-1"); - ASSERT_THAT(ex.GetPidTid(100).value(), ::testing::Pair(100, 0x1234ULL)); + ASSERT_THAT(ex.GetPidTid(100).getValue(), ::testing::Pair(100, 0x1234ULL)); ASSERT_EQ(ex.GetChar(), ';'); - ASSERT_THAT(ex.GetPidTid(100).value(), + ASSERT_THAT(ex.GetPidTid(100).getValue(), ::testing::Pair(0x12ULL, StringExtractorGDBRemote::AllThreads)); ASSERT_EQ(ex.GetChar(), ';'); - ASSERT_THAT(ex.GetPidTid(100).value(), + ASSERT_THAT(ex.GetPidTid(100).getValue(), ::testing::Pair(0x1234ULL, StringExtractorGDBRemote::AllThreads)); } diff --git a/lldb/unittests/tools/lldb-server/tests/TestClient.cpp b/lldb/unittests/tools/lldb-server/tests/TestClient.cpp index f65c33e..463dd22 100644 --- a/lldb/unittests/tools/lldb-server/tests/TestClient.cpp +++ b/lldb/unittests/tools/lldb-server/tests/TestClient.cpp @@ -251,7 +251,7 @@ Error TestClient::queryProcess() { } Error TestClient::Continue(StringRef message) { - assert(m_process_info.has_value()); + assert(m_process_info.hasValue()); auto StopReplyOr = SendMessage<StopReply>( message, m_process_info->GetEndian(), m_register_infos); diff --git a/llvm/include/llvm/ADT/Optional.h b/llvm/include/llvm/ADT/Optional.h index b2ebd17..d1615d9 100644 --- a/llvm/include/llvm/ADT/Optional.h +++ b/llvm/include/llvm/ADT/Optional.h @@ -92,40 +92,32 @@ public: } constexpr bool has_value() const noexcept { return hasVal; } -#if 0 constexpr bool hasValue() const noexcept { return hasVal; } -#endif T &value() &noexcept { assert(hasVal); return val; } -#if 0 T &getValue() &noexcept { assert(hasVal); return val; } -#endif constexpr T const &value() const &noexcept { assert(hasVal); return val; } -#if 0 constexpr T const &getValue() const &noexcept { assert(hasVal); return val; } -#endif T &&value() &&noexcept { assert(hasVal); return std::move(val); } -#if 0 T &&getValue() &&noexcept { assert(hasVal); return std::move(val); } -#endif template <class... Args> void emplace(Args &&...args) { reset(); @@ -211,40 +203,32 @@ public: } constexpr bool has_value() const noexcept { return hasVal; } -#if 0 constexpr bool hasValue() const noexcept { return hasVal; } -#endif T &value() &noexcept { assert(hasVal); return val; } -#if 0 T &getValue() &noexcept { assert(hasVal); return val; } -#endif constexpr T const &value() const &noexcept { assert(hasVal); return val; } -#if 0 constexpr T const &getValue() const &noexcept { assert(hasVal); return val; } -#endif T &&value() &&noexcept { assert(hasVal); return std::move(val); } -#if 0 T &&getValue() &&noexcept { assert(hasVal); return std::move(val); } -#endif template <class... Args> void emplace(Args &&...args) { reset(); @@ -319,19 +303,13 @@ public: constexpr const T *getPointer() const { return &Storage.value(); } T *getPointer() { return &Storage.value(); } constexpr const T &value() const & { return Storage.value(); } -#if 0 constexpr const T &getValue() const & { return Storage.value(); } -#endif T &value() & { return Storage.value(); } -#if 0 T &getValue() & { return Storage.value(); } -#endif constexpr explicit operator bool() const { return has_value(); } constexpr bool has_value() const { return Storage.has_value(); } -#if 0 constexpr bool hasValue() const { return Storage.has_value(); } -#endif constexpr const T *operator->() const { return getPointer(); } T *operator->() { return getPointer(); } constexpr const T &operator*() const & { return value(); } @@ -353,9 +331,7 @@ public: } T &&value() && { return std::move(Storage.value()); } -#if 0 T &&getValue() && { return std::move(Storage.value()); } -#endif T &&operator*() && { return std::move(Storage.value()); } template <typename U> T value_or(U &&alt) && { diff --git a/llvm/include/llvm/Analysis/BlockFrequencyInfoImpl.h b/llvm/include/llvm/Analysis/BlockFrequencyInfoImpl.h index 7208f11..d8e524d7 100644 --- a/llvm/include/llvm/Analysis/BlockFrequencyInfoImpl.h +++ b/llvm/include/llvm/Analysis/BlockFrequencyInfoImpl.h @@ -1277,10 +1277,10 @@ bool BlockFrequencyInfoImpl<BT>::computeMassInLoop(LoopData &Loop) { continue; } LLVM_DEBUG(dbgs() << getBlockName(HeaderNode) - << " has irr loop header weight " << *HeaderWeight - << "\n"); + << " has irr loop header weight " + << HeaderWeight.getValue() << "\n"); NumHeadersWithWeight++; - uint64_t HeaderWeightValue = *HeaderWeight; + uint64_t HeaderWeightValue = HeaderWeight.getValue(); if (!MinHeaderWeight || HeaderWeightValue < MinHeaderWeight) MinHeaderWeight = HeaderWeightValue; if (HeaderWeightValue) { @@ -1732,10 +1732,10 @@ raw_ostream &BlockFrequencyInfoImpl<BT>::print(raw_ostream &OS) const { if (Optional<uint64_t> ProfileCount = BlockFrequencyInfoImplBase::getBlockProfileCount( F->getFunction(), getNode(&BB))) - OS << ", count = " << *ProfileCount; + OS << ", count = " << ProfileCount.getValue(); if (Optional<uint64_t> IrrLoopHeaderWeight = BB.getIrrLoopHeaderWeight()) - OS << ", irr_loop_header_weight = " << *IrrLoopHeaderWeight; + OS << ", irr_loop_header_weight = " << IrrLoopHeaderWeight.getValue(); OS << "\n"; } diff --git a/llvm/include/llvm/Analysis/VectorUtils.h b/llvm/include/llvm/Analysis/VectorUtils.h index 6e4c468..df460cb 100644 --- a/llvm/include/llvm/Analysis/VectorUtils.h +++ b/llvm/include/llvm/Analysis/VectorUtils.h @@ -236,10 +236,10 @@ class VFDatabase { // ensuring that the variant described in the attribute has a // corresponding definition or declaration of the vector // function in the Module M. - if (Shape && (Shape->ScalarName == ScalarName)) { - assert(CI.getModule()->getFunction(Shape->VectorName) && + if (Shape.hasValue() && (Shape.getValue().ScalarName == ScalarName)) { + assert(CI.getModule()->getFunction(Shape.getValue().VectorName) && "Vector function is missing."); - Mappings.push_back(*Shape); + Mappings.push_back(Shape.getValue()); } } } diff --git a/llvm/include/llvm/Bitstream/BitstreamWriter.h b/llvm/include/llvm/Bitstream/BitstreamWriter.h index 3660ce5..be6bab5 100644 --- a/llvm/include/llvm/Bitstream/BitstreamWriter.h +++ b/llvm/include/llvm/Bitstream/BitstreamWriter.h @@ -386,12 +386,12 @@ private: const BitCodeAbbrevOp &Op = Abbv->getOperandInfo(i++); if (Op.isLiteral()) - EmitAbbreviatedLiteral(Op, *Code); + EmitAbbreviatedLiteral(Op, Code.getValue()); else { assert(Op.getEncoding() != BitCodeAbbrevOp::Array && Op.getEncoding() != BitCodeAbbrevOp::Blob && "Expected literal or scalar"); - EmitAbbreviatedField(Op, *Code); + EmitAbbreviatedField(Op, Code.getValue()); } } diff --git a/llvm/include/llvm/CodeGen/GlobalISel/InstructionSelectorImpl.h b/llvm/include/llvm/CodeGen/GlobalISel/InstructionSelectorImpl.h index 9e9fd65..fa6f904 100644 --- a/llvm/include/llvm/CodeGen/GlobalISel/InstructionSelectorImpl.h +++ b/llvm/include/llvm/CodeGen/GlobalISel/InstructionSelectorImpl.h @@ -674,8 +674,8 @@ bool InstructionSelector::executeMatchTable( ComplexRendererFns Renderer = (ISel.*ISelInfo.ComplexPredicates[ComplexPredicateID])( State.MIs[InsnID]->getOperand(OpIdx)); - if (Renderer) - State.Renderers[RendererID] = *Renderer; + if (Renderer.hasValue()) + State.Renderers[RendererID] = Renderer.getValue(); else if (handleReject() == RejectAndGiveUp) return false; diff --git a/llvm/include/llvm/DebugInfo/GSYM/FunctionInfo.h b/llvm/include/llvm/DebugInfo/GSYM/FunctionInfo.h index fb48f7f..a41b2fe 100644 --- a/llvm/include/llvm/DebugInfo/GSYM/FunctionInfo.h +++ b/llvm/include/llvm/DebugInfo/GSYM/FunctionInfo.h @@ -198,8 +198,8 @@ inline bool operator<(const FunctionInfo &LHS, const FunctionInfo &RHS) { return LHS.Range < RHS.Range; // Then sort by inline - if (LHS.Inline.has_value() != RHS.Inline.has_value()) - return RHS.Inline.has_value(); + if (LHS.Inline.hasValue() != RHS.Inline.hasValue()) + return RHS.Inline.hasValue(); return LHS.OptLineTable < RHS.OptLineTable; } diff --git a/llvm/include/llvm/IR/IRBuilder.h b/llvm/include/llvm/IR/IRBuilder.h index 1747826..2b387db 100644 --- a/llvm/include/llvm/IR/IRBuilder.h +++ b/llvm/include/llvm/IR/IRBuilder.h @@ -1168,12 +1168,12 @@ private: Value *getConstrainedFPRounding(Optional<RoundingMode> Rounding) { RoundingMode UseRounding = DefaultConstrainedRounding; - if (Rounding) - UseRounding = *Rounding; + if (Rounding.hasValue()) + UseRounding = Rounding.getValue(); Optional<StringRef> RoundingStr = convertRoundingModeToStr(UseRounding); - assert(RoundingStr && "Garbage strict rounding mode!"); - auto *RoundingMDS = MDString::get(Context, *RoundingStr); + assert(RoundingStr.hasValue() && "Garbage strict rounding mode!"); + auto *RoundingMDS = MDString::get(Context, RoundingStr.getValue()); return MetadataAsValue::get(Context, RoundingMDS); } @@ -1181,12 +1181,12 @@ private: Value *getConstrainedFPExcept(Optional<fp::ExceptionBehavior> Except) { fp::ExceptionBehavior UseExcept = DefaultConstrainedExcept; - if (Except) - UseExcept = *Except; + if (Except.hasValue()) + UseExcept = Except.getValue(); Optional<StringRef> ExceptStr = convertExceptionBehaviorToStr(UseExcept); - assert(ExceptStr && "Garbage strict exception behavior!"); - auto *ExceptMDS = MDString::get(Context, *ExceptStr); + assert(ExceptStr.hasValue() && "Garbage strict exception behavior!"); + auto *ExceptMDS = MDString::get(Context, ExceptStr.getValue()); return MetadataAsValue::get(Context, ExceptMDS); } diff --git a/llvm/include/llvm/MC/MCDwarf.h b/llvm/include/llvm/MC/MCDwarf.h index 8b2ae84..d0eb06e 100644 --- a/llvm/include/llvm/MC/MCDwarf.h +++ b/llvm/include/llvm/MC/MCDwarf.h @@ -296,8 +296,8 @@ public: RootFile.DirIndex = 0; RootFile.Checksum = Checksum; RootFile.Source = Source; - trackMD5Usage(Checksum.has_value()); - HasSource = Source.has_value(); + trackMD5Usage(Checksum.hasValue()); + HasSource = Source.hasValue(); } void resetFileTable() { @@ -374,8 +374,8 @@ public: Header.RootFile.DirIndex = 0; Header.RootFile.Checksum = Checksum; Header.RootFile.Source = Source; - Header.trackMD5Usage(Checksum.has_value()); - Header.HasSource = Source.has_value(); + Header.trackMD5Usage(Checksum.hasValue()); + Header.HasSource = Source.hasValue(); } void resetFileTable() { Header.resetFileTable(); } diff --git a/llvm/include/llvm/MC/MCSectionXCOFF.h b/llvm/include/llvm/MC/MCSectionXCOFF.h index 1b68d27..77f0b28 100644 --- a/llvm/include/llvm/MC/MCSectionXCOFF.h +++ b/llvm/include/llvm/MC/MCSectionXCOFF.h @@ -111,8 +111,8 @@ public: bool isVirtualSection() const override; StringRef getSymbolTableName() const { return SymbolTableName; } bool isMultiSymbolsAllowed() const { return MultiSymbolsAllowed; } - bool isCsect() const { return CsectProp.has_value(); } - bool isDwarfSect() const { return DwarfSubtypeFlags.has_value(); } + bool isCsect() const { return CsectProp.hasValue(); } + bool isDwarfSect() const { return DwarfSubtypeFlags.hasValue(); } Optional<XCOFF::DwarfSectionSubtypeFlags> getDwarfSubtypeFlags() const { return DwarfSubtypeFlags; } diff --git a/llvm/include/llvm/MC/MCSymbolWasm.h b/llvm/include/llvm/MC/MCSymbolWasm.h index 6d08685..5a4852e 100644 --- a/llvm/include/llvm/MC/MCSymbolWasm.h +++ b/llvm/include/llvm/MC/MCSymbolWasm.h @@ -86,10 +86,10 @@ public: bool omitFromLinkingSection() const { return OmitFromLinkingSection; } void setOmitFromLinkingSection() { OmitFromLinkingSection = true; } - bool hasImportModule() const { return ImportModule.has_value(); } + bool hasImportModule() const { return ImportModule.hasValue(); } StringRef getImportModule() const { - if (ImportModule) - return *ImportModule; + if (ImportModule.hasValue()) + return ImportModule.getValue(); // Use a default module name of "env" for now, for compatibility with // existing tools. // TODO(sbc): Find a way to specify a default value in the object format @@ -98,16 +98,16 @@ public: } void setImportModule(StringRef Name) { ImportModule = Name; } - bool hasImportName() const { return ImportName.has_value(); } + bool hasImportName() const { return ImportName.hasValue(); } StringRef getImportName() const { - if (ImportName) - return *ImportName; + if (ImportName.hasValue()) + return ImportName.getValue(); return getName(); } void setImportName(StringRef Name) { ImportName = Name; } - bool hasExportName() const { return ExportName.has_value(); } - StringRef getExportName() const { return *ExportName; } + bool hasExportName() const { return ExportName.hasValue(); } + StringRef getExportName() const { return ExportName.getValue(); } void setExportName(StringRef Name) { ExportName = Name; } bool isFunctionTable() const { @@ -129,15 +129,15 @@ public: void setSignature(wasm::WasmSignature *Sig) { Signature = Sig; } const wasm::WasmGlobalType &getGlobalType() const { - assert(GlobalType.has_value()); - return *GlobalType; + assert(GlobalType.hasValue()); + return GlobalType.getValue(); } void setGlobalType(wasm::WasmGlobalType GT) { GlobalType = GT; } - bool hasTableType() const { return TableType.has_value(); } + bool hasTableType() const { return TableType.hasValue(); } const wasm::WasmTableType &getTableType() const { assert(hasTableType()); - return *TableType; + return TableType.getValue(); } void setTableType(wasm::WasmTableType TT) { TableType = TT; } void setTableType(wasm::ValType VT) { diff --git a/llvm/include/llvm/MC/MCSymbolXCOFF.h b/llvm/include/llvm/MC/MCSymbolXCOFF.h index 4e21d39..752e1e7 100644 --- a/llvm/include/llvm/MC/MCSymbolXCOFF.h +++ b/llvm/include/llvm/MC/MCSymbolXCOFF.h @@ -39,8 +39,9 @@ public: }; XCOFF::StorageClass getStorageClass() const { - assert(StorageClass && "StorageClass not set on XCOFF MCSymbol."); - return *StorageClass; + assert(StorageClass.hasValue() && + "StorageClass not set on XCOFF MCSymbol."); + return StorageClass.getValue(); } StringRef getUnqualifiedName() const { return getUnqualifiedName(getName()); } diff --git a/llvm/include/llvm/ObjectYAML/ELFYAML.h b/llvm/include/llvm/ObjectYAML/ELFYAML.h index 95bf523..faff482 100644 --- a/llvm/include/llvm/ObjectYAML/ELFYAML.h +++ b/llvm/include/llvm/ObjectYAML/ELFYAML.h @@ -433,10 +433,10 @@ struct GnuHashSection : Section { GnuHashSection() : Section(ChunkKind::GnuHash) {} std::vector<std::pair<StringRef, bool>> getEntries() const override { - return {{"Header", Header.has_value()}, - {"BloomFilter", BloomFilter.has_value()}, - {"HashBuckets", HashBuckets.has_value()}, - {"HashValues", HashValues.has_value()}}; + return {{"Header", Header.hasValue()}, + {"BloomFilter", BloomFilter.hasValue()}, + {"HashBuckets", HashBuckets.hasValue()}, + {"HashValues", HashValues.hasValue()}}; }; static bool classof(const Chunk *S) { return S->Kind == ChunkKind::GnuHash; } diff --git a/llvm/include/llvm/Support/Casting.h b/llvm/include/llvm/Support/Casting.h index 7037cbf..21c981a 100644 --- a/llvm/include/llvm/Support/Casting.h +++ b/llvm/include/llvm/Support/Casting.h @@ -637,8 +637,10 @@ template <typename T, typename Enable = void> struct ValueIsPresent { // Optional provides its own way to check if something is present. template <typename T> struct ValueIsPresent<Optional<T>> { using UnwrappedType = T; - static inline bool isPresent(const Optional<T> &t) { return t.has_value(); } - static inline decltype(auto) unwrapValue(Optional<T> &t) { return *t; } + static inline bool isPresent(const Optional<T> &t) { return t.hasValue(); } + static inline decltype(auto) unwrapValue(Optional<T> &t) { + return t.getValue(); + } }; // If something is "nullable" then we just compare it to nullptr to see if it diff --git a/llvm/include/llvm/Support/Error.h b/llvm/include/llvm/Support/Error.h index 316e5dc..80a5212 100644 --- a/llvm/include/llvm/Support/Error.h +++ b/llvm/include/llvm/Support/Error.h @@ -1269,8 +1269,8 @@ public: void log(raw_ostream &OS) const override { assert(Err && "Trying to log after takeError()."); OS << "'" << FileName << "': "; - if (Line) - OS << "line " << *Line << ": "; + if (Line.hasValue()) + OS << "line " << Line.getValue() << ": "; Err->log(OS); } diff --git a/llvm/include/llvm/Support/YAMLTraits.h b/llvm/include/llvm/Support/YAMLTraits.h index 8ade9b1..dfe9b1b 100644 --- a/llvm/include/llvm/Support/YAMLTraits.h +++ b/llvm/include/llvm/Support/YAMLTraits.h @@ -1668,13 +1668,14 @@ template <typename T, typename Context> void IO::processKeyWithDefault(const char *Key, Optional<T> &Val, const Optional<T> &DefaultValue, bool Required, Context &Ctx) { - assert(!DefaultValue && "Optional<T> shouldn't have a value!"); + assert(DefaultValue.hasValue() == false && + "Optional<T> shouldn't have a value!"); void *SaveInfo; bool UseDefault = true; - const bool sameAsDefault = outputting() && !Val; - if (!outputting() && !Val) + const bool sameAsDefault = outputting() && !Val.hasValue(); + if (!outputting() && !Val.hasValue()) Val = T(); - if (Val && + if (Val.hasValue() && this->preflightKey(Key, Required, sameAsDefault, UseDefault, SaveInfo)) { // When reading an Optional<X> key from a YAML description, we allow the diff --git a/llvm/include/llvm/Transforms/IPO/Attributor.h b/llvm/include/llvm/Transforms/IPO/Attributor.h index 17e2969..6aa19b0 100644 --- a/llvm/include/llvm/Transforms/IPO/Attributor.h +++ b/llvm/include/llvm/Transforms/IPO/Attributor.h @@ -4884,10 +4884,12 @@ struct AAPointerInfo : public AbstractAttribute { Instruction *getRemoteInst() const { return RemoteI; } /// Return true if the value written is not known yet. - bool isWrittenValueYetUndetermined() const { return !Content; } + bool isWrittenValueYetUndetermined() const { return !Content.hasValue(); } /// Return true if the value written cannot be determined at all. - bool isWrittenValueUnknown() const { return Content && !*Content; } + bool isWrittenValueUnknown() const { + return Content.hasValue() && !*Content; + } /// Return the type associated with the access, if known. Type *getType() const { return Ty; } diff --git a/llvm/lib/Analysis/BranchProbabilityInfo.cpp b/llvm/lib/Analysis/BranchProbabilityInfo.cpp index 2bca424..1d88042 100644 --- a/llvm/lib/Analysis/BranchProbabilityInfo.cpp +++ b/llvm/lib/Analysis/BranchProbabilityInfo.cpp @@ -826,8 +826,9 @@ void BranchProbabilityInfo::computeEestimateBlockWeight( if (auto BBWeight = getInitialEstimatedBlockWeight(BB)) // If we were able to find estimated weight for the block set it to this // block and propagate up the IR. - propagateEstimatedBlockWeight(getLoopBlock(BB), DT, PDT, *BBWeight, - BlockWorkList, LoopWorkList); + propagateEstimatedBlockWeight(getLoopBlock(BB), DT, PDT, + BBWeight.getValue(), BlockWorkList, + LoopWorkList); // BlockWorklist/LoopWorkList contains blocks/loops with at least one // successor/exit having estimated weight. Try to propagate weight to such diff --git a/llvm/lib/Analysis/CFLAndersAliasAnalysis.cpp b/llvm/lib/Analysis/CFLAndersAliasAnalysis.cpp index 602a018..1216d03 100644 --- a/llvm/lib/Analysis/CFLAndersAliasAnalysis.cpp +++ b/llvm/lib/Analysis/CFLAndersAliasAnalysis.cpp @@ -831,14 +831,14 @@ CFLAndersAAResult::ensureCached(const Function &Fn) { scan(Fn); Iter = Cache.find(&Fn); assert(Iter != Cache.end()); - assert(Iter->second); + assert(Iter->second.hasValue()); } return Iter->second; } const AliasSummary *CFLAndersAAResult::getAliasSummary(const Function &Fn) { auto &FunInfo = ensureCached(Fn); - if (FunInfo) + if (FunInfo.hasValue()) return &FunInfo->getAliasSummary(); else return nullptr; diff --git a/llvm/lib/Analysis/CFLSteensAliasAnalysis.cpp b/llvm/lib/Analysis/CFLSteensAliasAnalysis.cpp index f92869c..b831a59 100644 --- a/llvm/lib/Analysis/CFLSteensAliasAnalysis.cpp +++ b/llvm/lib/Analysis/CFLSteensAliasAnalysis.cpp @@ -250,14 +250,14 @@ CFLSteensAAResult::ensureCached(Function *Fn) { scan(Fn); Iter = Cache.find(Fn); assert(Iter != Cache.end()); - assert(Iter->second); + assert(Iter->second.hasValue()); } return Iter->second; } const AliasSummary *CFLSteensAAResult::getAliasSummary(Function &Fn) { auto &FunInfo = ensureCached(&Fn); - if (FunInfo) + if (FunInfo.hasValue()) return &FunInfo->getAliasSummary(); else return nullptr; @@ -293,15 +293,15 @@ AliasResult CFLSteensAAResult::query(const MemoryLocation &LocA, assert(Fn != nullptr); auto &MaybeInfo = ensureCached(Fn); - assert(MaybeInfo); + assert(MaybeInfo.hasValue()); auto &Sets = MaybeInfo->getStratifiedSets(); auto MaybeA = Sets.find(InstantiatedValue{ValA, 0}); - if (!MaybeA) + if (!MaybeA.hasValue()) return AliasResult::MayAlias; auto MaybeB = Sets.find(InstantiatedValue{ValB, 0}); - if (!MaybeB) + if (!MaybeB.hasValue()) return AliasResult::MayAlias; auto SetA = *MaybeA; diff --git a/llvm/lib/Analysis/IRSimilarityIdentifier.cpp b/llvm/lib/Analysis/IRSimilarityIdentifier.cpp index 81aa854..c945050 100644 --- a/llvm/lib/Analysis/IRSimilarityIdentifier.cpp +++ b/llvm/lib/Analysis/IRSimilarityIdentifier.cpp @@ -183,9 +183,9 @@ CmpInst::Predicate IRInstructionData::getPredicate() const { assert(isa<CmpInst>(Inst) && "Can only get a predicate from a compare instruction"); - if (RevisedPredicate) - return *RevisedPredicate; - + if (RevisedPredicate.hasValue()) + return RevisedPredicate.getValue(); + return cast<CmpInst>(Inst)->getPredicate(); } diff --git a/llvm/lib/Analysis/InlineCost.cpp b/llvm/lib/Analysis/InlineCost.cpp index f2dcaa8..63fe651 100644 --- a/llvm/lib/Analysis/InlineCost.cpp +++ b/llvm/lib/Analysis/InlineCost.cpp @@ -703,8 +703,8 @@ class InlineCostCallAnalyzer final : public CallAnalyzer { BlockFrequencyInfo *BFI = &(GetBFI(F)); assert(BFI && "BFI must be available"); auto ProfileCount = BFI->getBlockProfileCount(BB); - assert(ProfileCount); - if (*ProfileCount == 0) + assert(ProfileCount.hasValue()); + if (ProfileCount.getValue() == 0) ColdSize += Cost - CostAtBBStart; } @@ -828,14 +828,14 @@ class InlineCostCallAnalyzer final : public CallAnalyzer { } auto ProfileCount = CalleeBFI->getBlockProfileCount(&BB); - assert(ProfileCount); - CurrentSavings *= *ProfileCount; + assert(ProfileCount.hasValue()); + CurrentSavings *= ProfileCount.getValue(); CycleSavings += CurrentSavings; } // Compute the cycle savings per call. auto EntryProfileCount = F.getEntryCount(); - assert(EntryProfileCount && EntryProfileCount->getCount()); + assert(EntryProfileCount.hasValue() && EntryProfileCount->getCount()); auto EntryCount = EntryProfileCount->getCount(); CycleSavings += EntryCount / 2; CycleSavings = CycleSavings.udiv(EntryCount); @@ -1800,12 +1800,12 @@ void InlineCostCallAnalyzer::updateThreshold(CallBase &Call, Function &Callee) { // return min(A, B) if B is valid. auto MinIfValid = [](int A, Optional<int> B) { - return B ? std::min(A, *B) : A; + return B ? std::min(A, B.getValue()) : A; }; // return max(A, B) if B is valid. auto MaxIfValid = [](int A, Optional<int> B) { - return B ? std::max(A, *B) : A; + return B ? std::max(A, B.getValue()) : A; }; // Various bonus percentages. These are multiplied by Threshold to get the diff --git a/llvm/lib/Analysis/InstructionSimplify.cpp b/llvm/lib/Analysis/InstructionSimplify.cpp index a7aec39..07e3392 100644 --- a/llvm/lib/Analysis/InstructionSimplify.cpp +++ b/llvm/lib/Analysis/InstructionSimplify.cpp @@ -6123,9 +6123,9 @@ static Value *simplifyIntrinsic(CallBase *Call, const SimplifyQuery &Q) { Value *Op1 = Call->getArgOperand(1); Value *Op2 = Call->getArgOperand(2); auto *FPI = cast<ConstrainedFPIntrinsic>(Call); - if (Value *V = - simplifyFPOp({Op0, Op1, Op2}, {}, Q, *FPI->getExceptionBehavior(), - *FPI->getRoundingMode())) + if (Value *V = simplifyFPOp({Op0, Op1, Op2}, {}, Q, + FPI->getExceptionBehavior().getValue(), + FPI->getRoundingMode().getValue())) return V; return nullptr; } @@ -6189,33 +6189,38 @@ static Value *simplifyIntrinsic(CallBase *Call, const SimplifyQuery &Q) { } case Intrinsic::experimental_constrained_fadd: { auto *FPI = cast<ConstrainedFPIntrinsic>(Call); - return simplifyFAddInst( - FPI->getArgOperand(0), FPI->getArgOperand(1), FPI->getFastMathFlags(), - Q, *FPI->getExceptionBehavior(), *FPI->getRoundingMode()); + return simplifyFAddInst(FPI->getArgOperand(0), FPI->getArgOperand(1), + FPI->getFastMathFlags(), Q, + FPI->getExceptionBehavior().getValue(), + FPI->getRoundingMode().getValue()); } case Intrinsic::experimental_constrained_fsub: { auto *FPI = cast<ConstrainedFPIntrinsic>(Call); - return simplifyFSubInst( - FPI->getArgOperand(0), FPI->getArgOperand(1), FPI->getFastMathFlags(), - Q, *FPI->getExceptionBehavior(), *FPI->getRoundingMode()); + return simplifyFSubInst(FPI->getArgOperand(0), FPI->getArgOperand(1), + FPI->getFastMathFlags(), Q, + FPI->getExceptionBehavior().getValue(), + FPI->getRoundingMode().getValue()); } case Intrinsic::experimental_constrained_fmul: { auto *FPI = cast<ConstrainedFPIntrinsic>(Call); - return simplifyFMulInst( - FPI->getArgOperand(0), FPI->getArgOperand(1), FPI->getFastMathFlags(), - Q, *FPI->getExceptionBehavior(), *FPI->getRoundingMode()); + return simplifyFMulInst(FPI->getArgOperand(0), FPI->getArgOperand(1), + FPI->getFastMathFlags(), Q, + FPI->getExceptionBehavior().getValue(), + FPI->getRoundingMode().getValue()); } case Intrinsic::experimental_constrained_fdiv: { auto *FPI = cast<ConstrainedFPIntrinsic>(Call); - return simplifyFDivInst( - FPI->getArgOperand(0), FPI->getArgOperand(1), FPI->getFastMathFlags(), - Q, *FPI->getExceptionBehavior(), *FPI->getRoundingMode()); + return simplifyFDivInst(FPI->getArgOperand(0), FPI->getArgOperand(1), + FPI->getFastMathFlags(), Q, + FPI->getExceptionBehavior().getValue(), + FPI->getRoundingMode().getValue()); } case Intrinsic::experimental_constrained_frem: { auto *FPI = cast<ConstrainedFPIntrinsic>(Call); - return simplifyFRemInst( - FPI->getArgOperand(0), FPI->getArgOperand(1), FPI->getFastMathFlags(), - Q, *FPI->getExceptionBehavior(), *FPI->getRoundingMode()); + return simplifyFRemInst(FPI->getArgOperand(0), FPI->getArgOperand(1), + FPI->getFastMathFlags(), Q, + FPI->getExceptionBehavior().getValue(), + FPI->getRoundingMode().getValue()); } default: return nullptr; diff --git a/llvm/lib/Analysis/LazyValueInfo.cpp b/llvm/lib/Analysis/LazyValueInfo.cpp index e82c3ae..5803c3d 100644 --- a/llvm/lib/Analysis/LazyValueInfo.cpp +++ b/llvm/lib/Analysis/LazyValueInfo.cpp @@ -918,10 +918,10 @@ Optional<ValueLatticeElement> LazyValueInfoImpl::solveBlockValueCast( // transfer rule on the full set since we may be able to locally infer // interesting facts. Optional<ConstantRange> LHSRes = getRangeFor(CI->getOperand(0), CI, BB); - if (!LHSRes) + if (!LHSRes.hasValue()) // More work to do before applying this transfer rule. return None; - const ConstantRange &LHSRange = *LHSRes; + const ConstantRange &LHSRange = LHSRes.getValue(); const unsigned ResultBitWidth = CI->getType()->getIntegerBitWidth(); @@ -946,8 +946,8 @@ Optional<ValueLatticeElement> LazyValueInfoImpl::solveBlockValueBinaryOpImpl( // More work to do before applying this transfer rule. return None; - const ConstantRange &LHSRange = *LHSRes; - const ConstantRange &RHSRange = *RHSRes; + const ConstantRange &LHSRange = LHSRes.getValue(); + const ConstantRange &RHSRange = RHSRes.getValue(); return ValueLatticeElement::getRange(OpFn(LHSRange, RHSRange)); } diff --git a/llvm/lib/Analysis/LoopCacheAnalysis.cpp b/llvm/lib/Analysis/LoopCacheAnalysis.cpp index 2cbf1f7..002e993 100644 --- a/llvm/lib/Analysis/LoopCacheAnalysis.cpp +++ b/llvm/lib/Analysis/LoopCacheAnalysis.cpp @@ -645,8 +645,8 @@ bool CacheCost::populateReferenceGroups(ReferenceGroupsTy &RefGroups) const { Optional<bool> HasSpacialReuse = R->hasSpacialReuse(Representative, CLS, AA); - if ((HasTemporalReuse && *HasTemporalReuse) || - (HasSpacialReuse && *HasSpacialReuse)) { + if ((HasTemporalReuse.hasValue() && *HasTemporalReuse) || + (HasSpacialReuse.hasValue() && *HasSpacialReuse)) { RefGroup.push_back(std::move(R)); Added = true; break; diff --git a/llvm/lib/Analysis/MemoryBuiltins.cpp b/llvm/lib/Analysis/MemoryBuiltins.cpp index ff303ce..3c0e494 100644 --- a/llvm/lib/Analysis/MemoryBuiltins.cpp +++ b/llvm/lib/Analysis/MemoryBuiltins.cpp @@ -270,53 +270,54 @@ static Optional<AllocFnsTy> getAllocationSize(const Value *V, /// allocates or reallocates memory (either malloc, calloc, realloc, or strdup /// like). bool llvm::isAllocationFn(const Value *V, const TargetLibraryInfo *TLI) { - return getAllocationData(V, AnyAlloc, TLI).has_value(); + return getAllocationData(V, AnyAlloc, TLI).hasValue(); } bool llvm::isAllocationFn( const Value *V, function_ref<const TargetLibraryInfo &(Function &)> GetTLI) { - return getAllocationData(V, AnyAlloc, GetTLI).has_value(); + return getAllocationData(V, AnyAlloc, GetTLI).hasValue(); } /// Tests if a value is a call or invoke to a library function that /// allocates uninitialized memory (such as malloc). static bool isMallocLikeFn(const Value *V, const TargetLibraryInfo *TLI) { - return getAllocationData(V, MallocOrOpNewLike, TLI).has_value(); + return getAllocationData(V, MallocOrOpNewLike, TLI).hasValue(); } /// Tests if a value is a call or invoke to a library function that /// allocates uninitialized memory with alignment (such as aligned_alloc). static bool isAlignedAllocLikeFn(const Value *V, const TargetLibraryInfo *TLI) { - return getAllocationData(V, AlignedAllocLike, TLI).has_value(); + return getAllocationData(V, AlignedAllocLike, TLI) + .hasValue(); } /// Tests if a value is a call or invoke to a library function that /// allocates zero-filled memory (such as calloc). static bool isCallocLikeFn(const Value *V, const TargetLibraryInfo *TLI) { - return getAllocationData(V, CallocLike, TLI).has_value(); + return getAllocationData(V, CallocLike, TLI).hasValue(); } /// Tests if a value is a call or invoke to a library function that /// allocates memory similar to malloc or calloc. bool llvm::isMallocOrCallocLikeFn(const Value *V, const TargetLibraryInfo *TLI) { - return getAllocationData(V, MallocOrCallocLike, TLI).has_value(); + return getAllocationData(V, MallocOrCallocLike, TLI).hasValue(); } /// Tests if a value is a call or invoke to a library function that /// allocates memory (either malloc, calloc, or strdup like). bool llvm::isAllocLikeFn(const Value *V, const TargetLibraryInfo *TLI) { - return getAllocationData(V, AllocLike, TLI).has_value(); + return getAllocationData(V, AllocLike, TLI).hasValue(); } /// Tests if a value is a call or invoke to a library function that /// reallocates memory (e.g., realloc). bool llvm::isReallocLikeFn(const Value *V, const TargetLibraryInfo *TLI) { - return getAllocationData(V, ReallocLike, TLI).has_value(); + return getAllocationData(V, ReallocLike, TLI).hasValue(); } /// Tests if a functions is a call or invoke to a library function that /// reallocates memory (e.g., realloc). bool llvm::isReallocLikeFn(const Function *F, const TargetLibraryInfo *TLI) { - return getAllocationDataForFunction(F, ReallocLike, TLI).has_value(); + return getAllocationDataForFunction(F, ReallocLike, TLI).hasValue(); } bool llvm::isAllocRemovable(const CallBase *CB, const TargetLibraryInfo *TLI) { @@ -500,18 +501,18 @@ Optional<StringRef> llvm::getAllocationFamily(const Value *I, if (!TLI || !TLI->getLibFunc(*Callee, TLIFn) || !TLI->has(TLIFn)) return None; const auto AllocData = getAllocationDataForFunction(Callee, AnyAlloc, TLI); - if (AllocData) - return mangledNameForMallocFamily(AllocData->Family); + if (AllocData.hasValue()) + return mangledNameForMallocFamily(AllocData.getValue().Family); const auto FreeData = getFreeFunctionDataForFunction(Callee, TLIFn); - if (FreeData) - return mangledNameForMallocFamily(FreeData->Family); + if (FreeData.hasValue()) + return mangledNameForMallocFamily(FreeData.getValue().Family); return None; } /// isLibFreeFunction - Returns true if the function is a builtin free() bool llvm::isLibFreeFunction(const Function *F, const LibFunc TLIFn) { Optional<FreeFnsTy> FnData = getFreeFunctionDataForFunction(F, TLIFn); - if (!FnData) + if (!FnData.hasValue()) return false; // Check free prototype. diff --git a/llvm/lib/Analysis/MemorySSA.cpp b/llvm/lib/Analysis/MemorySSA.cpp index 76371b8..f63898b 100644 --- a/llvm/lib/Analysis/MemorySSA.cpp +++ b/llvm/lib/Analysis/MemorySSA.cpp @@ -749,9 +749,9 @@ template <class AliasAnalysisType> class ClobberWalker { } bool operator==(const generic_def_path_iterator &O) const { - if (N.has_value() != O.N.has_value()) + if (N.hasValue() != O.N.hasValue()) return false; - return !N || *N == *O.N; + return !N.hasValue() || *N == *O.N; } private: diff --git a/llvm/lib/Analysis/MustExecute.cpp b/llvm/lib/Analysis/MustExecute.cpp index 8dbce26..c785b50 100644 --- a/llvm/lib/Analysis/MustExecute.cpp +++ b/llvm/lib/Analysis/MustExecute.cpp @@ -491,9 +491,9 @@ template <typename K, typename V, typename FnTy, typename... ArgsTy> static V getOrCreateCachedOptional(K Key, DenseMap<K, Optional<V>> &Map, FnTy &&Fn, ArgsTy&&... args) { Optional<V> &OptVal = Map[Key]; - if (!OptVal) + if (!OptVal.hasValue()) OptVal = Fn(std::forward<ArgsTy>(args)...); - return *OptVal; + return OptVal.getValue(); } const BasicBlock * diff --git a/llvm/lib/Analysis/ProfileSummaryInfo.cpp b/llvm/lib/Analysis/ProfileSummaryInfo.cpp index b564dbe..9d5fa6d 100644 --- a/llvm/lib/Analysis/ProfileSummaryInfo.cpp +++ b/llvm/lib/Analysis/ProfileSummaryInfo.cpp @@ -279,19 +279,19 @@ ProfileSummaryInfo::computeThreshold(int PercentileCutoff) const { } bool ProfileSummaryInfo::hasHugeWorkingSetSize() const { - return HasHugeWorkingSetSize && *HasHugeWorkingSetSize; + return HasHugeWorkingSetSize && HasHugeWorkingSetSize.getValue(); } bool ProfileSummaryInfo::hasLargeWorkingSetSize() const { - return HasLargeWorkingSetSize && *HasLargeWorkingSetSize; + return HasLargeWorkingSetSize && HasLargeWorkingSetSize.getValue(); } bool ProfileSummaryInfo::isHotCount(uint64_t C) const { - return HotCountThreshold && C >= *HotCountThreshold; + return HotCountThreshold && C >= HotCountThreshold.getValue(); } bool ProfileSummaryInfo::isColdCount(uint64_t C) const { - return ColdCountThreshold && C <= *ColdCountThreshold; + return ColdCountThreshold && C <= ColdCountThreshold.getValue(); } template <bool isHot> @@ -299,9 +299,9 @@ bool ProfileSummaryInfo::isHotOrColdCountNthPercentile(int PercentileCutoff, uint64_t C) const { auto CountThreshold = computeThreshold(PercentileCutoff); if (isHot) - return CountThreshold && C >= *CountThreshold; + return CountThreshold && C >= CountThreshold.getValue(); else - return CountThreshold && C <= *CountThreshold; + return CountThreshold && C <= CountThreshold.getValue(); } bool ProfileSummaryInfo::isHotCountNthPercentile(int PercentileCutoff, diff --git a/llvm/lib/Analysis/ScalarEvolution.cpp b/llvm/lib/Analysis/ScalarEvolution.cpp index 7951180..5eb5c6b 100644 --- a/llvm/lib/Analysis/ScalarEvolution.cpp +++ b/llvm/lib/Analysis/ScalarEvolution.cpp @@ -4847,16 +4847,16 @@ public: SelectInst *SI = cast<SelectInst>(I); Optional<const SCEV *> Res = compareWithBackedgeCondition(SI->getCondition()); - if (Res) { - bool IsOne = cast<SCEVConstant>(*Res)->getValue()->isOne(); + if (Res.hasValue()) { + bool IsOne = cast<SCEVConstant>(Res.getValue())->getValue()->isOne(); Result = SE.getSCEV(IsOne ? SI->getTrueValue() : SI->getFalseValue()); } break; } default: { Optional<const SCEV *> Res = compareWithBackedgeCondition(I); - if (Res) - Result = *Res; + if (Res.hasValue()) + Result = Res.getValue(); break; } } @@ -6596,9 +6596,9 @@ ScalarEvolution::getRangeRef(const SCEV *S, // Check if the IR explicitly contains !range metadata. Optional<ConstantRange> MDRange = GetRangeFromMetadata(U->getValue()); - if (MDRange) - ConservativeResult = - ConservativeResult.intersectWith(*MDRange, RangeType); + if (MDRange.hasValue()) + ConservativeResult = ConservativeResult.intersectWith(MDRange.getValue(), + RangeType); // Use facts about recurrences in the underlying IR. Note that add // recurrences are AddRecExprs and thus don't hit this path. This @@ -9710,15 +9710,15 @@ GetQuadraticEquation(const SCEVAddRecExpr *AddRec) { /// (b) if neither X nor Y exist, return None, /// (c) if exactly one of X and Y exists, return that value. static Optional<APInt> MinOptional(Optional<APInt> X, Optional<APInt> Y) { - if (X && Y) { + if (X.hasValue() && Y.hasValue()) { unsigned W = std::max(X->getBitWidth(), Y->getBitWidth()); APInt XW = X->sext(W); APInt YW = Y->sext(W); return XW.slt(YW) ? *X : *Y; } - if (!X && !Y) + if (!X.hasValue() && !Y.hasValue()) return None; - return X ? *X : *Y; + return X.hasValue() ? *X : *Y; } /// Helper function to truncate an optional APInt to a given BitWidth. @@ -9760,13 +9760,13 @@ SolveQuadraticAddRecExact(const SCEVAddRecExpr *AddRec, ScalarEvolution &SE) { APInt A, B, C, M; unsigned BitWidth; auto T = GetQuadraticEquation(AddRec); - if (!T) + if (!T.hasValue()) return None; std::tie(A, B, C, M, BitWidth) = *T; LLVM_DEBUG(dbgs() << __func__ << ": solving for unsigned overflow\n"); Optional<APInt> X = APIntOps::SolveQuadraticEquationWrap(A, B, C, BitWidth+1); - if (!X) + if (!X.hasValue()) return None; ConstantInt *CX = ConstantInt::get(SE.getContext(), *X); @@ -10471,8 +10471,8 @@ ScalarEvolution::getMonotonicPredicateType(const SCEVAddRecExpr *LHS, auto ResultSwapped = getMonotonicPredicateTypeImpl(LHS, ICmpInst::getSwappedPredicate(Pred)); - assert(ResultSwapped && "should be able to analyze both!"); - assert(*ResultSwapped != *Result && + assert(ResultSwapped.hasValue() && "should be able to analyze both!"); + assert(ResultSwapped.getValue() != Result.getValue() && "monotonicity should flip as we flip the predicate"); } #endif diff --git a/llvm/lib/Analysis/StratifiedSets.h b/llvm/lib/Analysis/StratifiedSets.h index 883ebd2..8468f2b 100644 --- a/llvm/lib/Analysis/StratifiedSets.h +++ b/llvm/lib/Analysis/StratifiedSets.h @@ -340,10 +340,10 @@ public: return StratifiedSets<T>(std::move(Values), std::move(StratLinks)); } - bool has(const T &Elem) const { return get(Elem).has_value(); } + bool has(const T &Elem) const { return get(Elem).hasValue(); } bool add(const T &Main) { - if (get(Main)) + if (get(Main).hasValue()) return false; auto NewIndex = getNewUnlinkedIndex(); diff --git a/llvm/lib/Analysis/VectorUtils.cpp b/llvm/lib/Analysis/VectorUtils.cpp index 56a5983..beb14c4 100644 --- a/llvm/lib/Analysis/VectorUtils.cpp +++ b/llvm/lib/Analysis/VectorUtils.cpp @@ -1501,8 +1501,8 @@ void VFABI::getVectorVariantNames( #ifndef NDEBUG LLVM_DEBUG(dbgs() << "VFABI: adding mapping '" << S << "'\n"); Optional<VFInfo> Info = VFABI::tryDemangleForVFABI(S, *(CI.getModule())); - assert(Info && "Invalid name for a VFABI variant."); - assert(CI.getModule()->getFunction(Info->VectorName) && + assert(Info.hasValue() && "Invalid name for a VFABI variant."); + assert(CI.getModule()->getFunction(Info.getValue().VectorName) && "Vector function is missing."); #endif VariantMappings.push_back(std::string(S)); diff --git a/llvm/lib/CodeGen/BasicBlockSections.cpp b/llvm/lib/CodeGen/BasicBlockSections.cpp index b6b018c..e6f4e39 100644 --- a/llvm/lib/CodeGen/BasicBlockSections.cpp +++ b/llvm/lib/CodeGen/BasicBlockSections.cpp @@ -234,8 +234,9 @@ assignSections(MachineFunction &MF, // If we already have one cluster containing eh_pads, this must be updated // to ExceptionSectionID. Otherwise, we set it equal to the current // section ID. - EHPadsSectionID = EHPadsSectionID ? MBBSectionID::ExceptionSectionID - : MBB.getSectionID(); + EHPadsSectionID = EHPadsSectionID.hasValue() + ? MBBSectionID::ExceptionSectionID + : MBB.getSectionID(); } } diff --git a/llvm/lib/CodeGen/GlobalISel/CombinerHelper.cpp b/llvm/lib/CodeGen/GlobalISel/CombinerHelper.cpp index 2c94f87..674649c 100644 --- a/llvm/lib/CodeGen/GlobalISel/CombinerHelper.cpp +++ b/llvm/lib/CodeGen/GlobalISel/CombinerHelper.cpp @@ -1291,12 +1291,12 @@ bool CombinerHelper::matchCombineConstantFoldFpUnary(MachineInstr &MI, Register SrcReg = MI.getOperand(1).getReg(); LLT DstTy = MRI.getType(DstReg); Cst = constantFoldFpUnary(MI.getOpcode(), DstTy, SrcReg, MRI); - return Cst.has_value(); + return Cst.hasValue(); } void CombinerHelper::applyCombineConstantFoldFpUnary(MachineInstr &MI, Optional<APFloat> &Cst) { - assert(Cst && "Optional is unexpectedly empty!"); + assert(Cst.hasValue() && "Optional is unexpectedly empty!"); Builder.setInstrAndDebugLoc(MI); MachineFunction &MF = Builder.getMF(); auto *FPVal = ConstantFP::get(MF.getFunction().getContext(), *Cst); diff --git a/llvm/lib/CodeGen/MIRParser/MIParser.cpp b/llvm/lib/CodeGen/MIRParser/MIParser.cpp index 5ddfc69..879ec00 100644 --- a/llvm/lib/CodeGen/MIRParser/MIParser.cpp +++ b/llvm/lib/CodeGen/MIRParser/MIParser.cpp @@ -741,8 +741,8 @@ bool MIParser::parseBasicBlockDefinition( MBB->setIsEHPad(IsLandingPad); MBB->setIsInlineAsmBrIndirectTarget(IsInlineAsmBrIndirectTarget); MBB->setIsEHFuncletEntry(IsEHFuncletEntry); - if (SectionID) { - MBB->setSectionID(*SectionID); + if (SectionID.hasValue()) { + MBB->setSectionID(SectionID.getValue()); MF.setBBSectionsType(BasicBlockSection::List); } return false; diff --git a/llvm/lib/CodeGen/MachineBasicBlock.cpp b/llvm/lib/CodeGen/MachineBasicBlock.cpp index a50e188a..c186d0b 100644 --- a/llvm/lib/CodeGen/MachineBasicBlock.cpp +++ b/llvm/lib/CodeGen/MachineBasicBlock.cpp @@ -450,8 +450,8 @@ void MachineBasicBlock::print(raw_ostream &OS, ModuleSlotTracker &MST, if (IrrLoopHeaderWeight && IsStandalone) { if (Indexes) OS << '\t'; - OS.indent(2) << "; Irreducible loop header weight: " << *IrrLoopHeaderWeight - << '\n'; + OS.indent(2) << "; Irreducible loop header weight: " + << IrrLoopHeaderWeight.getValue() << '\n'; } } diff --git a/llvm/lib/CodeGen/MachineFunctionSplitter.cpp b/llvm/lib/CodeGen/MachineFunctionSplitter.cpp index 3f55a82..7d0f294 100644 --- a/llvm/lib/CodeGen/MachineFunctionSplitter.cpp +++ b/llvm/lib/CodeGen/MachineFunctionSplitter.cpp @@ -106,8 +106,9 @@ bool MachineFunctionSplitter::runOnMachineFunction(MachineFunction &MF) { // We don't want to proceed further for cold functions // or functions of unknown hotness. Lukewarm functions have no prefix. Optional<StringRef> SectionPrefix = MF.getFunction().getSectionPrefix(); - if (SectionPrefix && - (SectionPrefix->equals("unlikely") || SectionPrefix->equals("unknown"))) { + if (SectionPrefix.hasValue() && + (SectionPrefix.getValue().equals("unlikely") || + SectionPrefix.getValue().equals("unknown"))) { return false; } diff --git a/llvm/lib/CodeGen/ModuloSchedule.cpp b/llvm/lib/CodeGen/ModuloSchedule.cpp index 37b851f..8e8cdb2 100644 --- a/llvm/lib/CodeGen/ModuloSchedule.cpp +++ b/llvm/lib/CodeGen/ModuloSchedule.cpp @@ -1447,8 +1447,8 @@ Register KernelRewriter::remapUse(Register Reg, MachineInstr &MI) { Register KernelRewriter::phi(Register LoopReg, Optional<Register> InitReg, const TargetRegisterClass *RC) { // If the init register is not undef, try and find an existing phi. - if (InitReg) { - auto I = Phis.find({LoopReg, *InitReg}); + if (InitReg.hasValue()) { + auto I = Phis.find({LoopReg, InitReg.getValue()}); if (I != Phis.end()) return I->second; } else { @@ -1469,10 +1469,10 @@ Register KernelRewriter::phi(Register LoopReg, Optional<Register> InitReg, return R; // Found a phi taking undef as input, so rewrite it to take InitReg. MachineInstr *MI = MRI.getVRegDef(R); - MI->getOperand(1).setReg(*InitReg); - Phis.insert({{LoopReg, *InitReg}, R}); + MI->getOperand(1).setReg(InitReg.getValue()); + Phis.insert({{LoopReg, InitReg.getValue()}, R}); const TargetRegisterClass *ConstrainRegClass = - MRI.constrainRegClass(R, MRI.getRegClass(*InitReg)); + MRI.constrainRegClass(R, MRI.getRegClass(InitReg.getValue())); assert(ConstrainRegClass && "Expected a valid constrained register class!"); (void)ConstrainRegClass; UndefPhis.erase(I); @@ -1483,18 +1483,18 @@ Register KernelRewriter::phi(Register LoopReg, Optional<Register> InitReg, if (!RC) RC = MRI.getRegClass(LoopReg); Register R = MRI.createVirtualRegister(RC); - if (InitReg) { + if (InitReg.hasValue()) { const TargetRegisterClass *ConstrainRegClass = MRI.constrainRegClass(R, MRI.getRegClass(*InitReg)); assert(ConstrainRegClass && "Expected a valid constrained register class!"); (void)ConstrainRegClass; } BuildMI(*BB, BB->getFirstNonPHI(), DebugLoc(), TII->get(TargetOpcode::PHI), R) - .addReg(InitReg ? *InitReg : undef(RC)) + .addReg(InitReg.hasValue() ? *InitReg : undef(RC)) .addMBB(PreheaderBB) .addReg(LoopReg) .addMBB(BB); - if (!InitReg) + if (!InitReg.hasValue()) UndefPhis[LoopReg] = R; else Phis[{LoopReg, *InitReg}] = R; diff --git a/llvm/lib/CodeGen/SelectOptimize.cpp b/llvm/lib/CodeGen/SelectOptimize.cpp index 4032227..c199b6a 100644 --- a/llvm/lib/CodeGen/SelectOptimize.cpp +++ b/llvm/lib/CodeGen/SelectOptimize.cpp @@ -870,8 +870,8 @@ bool SelectOptimize::computeLoopCosts( ORE->emit(ORmissL); return false; } - IPredCost += Scaled64::get(*ILatency); - INonPredCost += Scaled64::get(*ILatency); + IPredCost += Scaled64::get(ILatency.getValue()); + INonPredCost += Scaled64::get(ILatency.getValue()); // For a select that can be converted to branch, // compute its cost as a branch (non-predicated cost). diff --git a/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp b/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp index aa688d9d..38f440a 100644 --- a/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp +++ b/llvm/lib/CodeGen/SelectionDAG/DAGCombiner.cpp @@ -24514,8 +24514,9 @@ bool DAGCombiner::mayAlias(SDNode *Op0, SDNode *Op1) const { auto &Size0 = MUC0.NumBytes; auto &Size1 = MUC1.NumBytes; if (OrigAlignment0 == OrigAlignment1 && SrcValOffset0 != SrcValOffset1 && - Size0 && Size1 && *Size0 == *Size1 && OrigAlignment0 > *Size0 && - SrcValOffset0 % *Size0 == 0 && SrcValOffset1 % *Size1 == 0) { + Size0.hasValue() && Size1.hasValue() && *Size0 == *Size1 && + OrigAlignment0 > *Size0 && SrcValOffset0 % *Size0 == 0 && + SrcValOffset1 % *Size1 == 0) { int64_t OffAlign0 = SrcValOffset0 % OrigAlignment0.value(); int64_t OffAlign1 = SrcValOffset1 % OrigAlignment1.value(); @@ -24534,8 +24535,8 @@ bool DAGCombiner::mayAlias(SDNode *Op0, SDNode *Op1) const { UseAA = false; #endif - if (UseAA && AA && MUC0.MMO->getValue() && MUC1.MMO->getValue() && Size0 && - Size1) { + if (UseAA && AA && MUC0.MMO->getValue() && MUC1.MMO->getValue() && + Size0.hasValue() && Size1.hasValue()) { // Use alias analysis information. int64_t MinOffset = std::min(SrcValOffset0, SrcValOffset1); int64_t Overlap0 = *Size0 + SrcValOffset0 - MinOffset; diff --git a/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp b/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp index 103da92..15455eb 100644 --- a/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp +++ b/llvm/lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp @@ -703,8 +703,8 @@ static void getCopyToPartsVector(SelectionDAG &DAG, const SDLoc &DL, unsigned NumRegs; if (IsABIRegCopy) { NumRegs = TLI.getVectorTypeBreakdownForCallingConv( - *DAG.getContext(), *CallConv, ValueVT, IntermediateVT, NumIntermediates, - RegisterVT); + *DAG.getContext(), CallConv.getValue(), ValueVT, IntermediateVT, + NumIntermediates, RegisterVT); } else { NumRegs = TLI.getVectorTypeBreakdown(*DAG.getContext(), ValueVT, IntermediateVT, @@ -800,11 +800,11 @@ RegsForValue::RegsForValue(LLVMContext &Context, const TargetLowering &TLI, for (EVT ValueVT : ValueVTs) { unsigned NumRegs = isABIMangled() - ? TLI.getNumRegistersForCallingConv(Context, *CC, ValueVT) + ? TLI.getNumRegistersForCallingConv(Context, CC.getValue(), ValueVT) : TLI.getNumRegisters(Context, ValueVT); MVT RegisterVT = isABIMangled() - ? TLI.getRegisterTypeForCallingConv(Context, *CC, ValueVT) + ? TLI.getRegisterTypeForCallingConv(Context, CC.getValue(), ValueVT) : TLI.getRegisterType(Context, ValueVT); for (unsigned i = 0; i != NumRegs; ++i) Regs.push_back(Reg + i); @@ -831,10 +831,10 @@ SDValue RegsForValue::getCopyFromRegs(SelectionDAG &DAG, // Copy the legal parts from the registers. EVT ValueVT = ValueVTs[Value]; unsigned NumRegs = RegCount[Value]; - MVT RegisterVT = isABIMangled() - ? TLI.getRegisterTypeForCallingConv( - *DAG.getContext(), *CallConv, RegVTs[Value]) - : RegVTs[Value]; + MVT RegisterVT = isABIMangled() ? TLI.getRegisterTypeForCallingConv( + *DAG.getContext(), + CallConv.getValue(), RegVTs[Value]) + : RegVTs[Value]; Parts.resize(NumRegs); for (unsigned i = 0; i != NumRegs; ++i) { @@ -914,10 +914,10 @@ void RegsForValue::getCopyToRegs(SDValue Val, SelectionDAG &DAG, for (unsigned Value = 0, Part = 0, e = ValueVTs.size(); Value != e; ++Value) { unsigned NumParts = RegCount[Value]; - MVT RegisterVT = isABIMangled() - ? TLI.getRegisterTypeForCallingConv( - *DAG.getContext(), *CallConv, RegVTs[Value]) - : RegVTs[Value]; + MVT RegisterVT = isABIMangled() ? TLI.getRegisterTypeForCallingConv( + *DAG.getContext(), + CallConv.getValue(), RegVTs[Value]) + : RegVTs[Value]; if (ExtendKind == ISD::ANY_EXTEND && TLI.isZExtFree(Val, RegisterVT)) ExtendKind = ISD::ZERO_EXTEND; @@ -8867,10 +8867,10 @@ void SelectionDAGBuilder::visitInlineAsm(const CallBase &Call, : OpInfo; const auto RegError = getRegistersForValue(DAG, getCurSDLoc(), OpInfo, RefOpInfo); - if (RegError) { + if (RegError.hasValue()) { const MachineFunction &MF = DAG.getMachineFunction(); const TargetRegisterInfo &TRI = *MF.getSubtarget().getRegisterInfo(); - const char *RegName = TRI.getName(*RegError); + const char *RegName = TRI.getName(RegError.getValue()); emitInlineAsmError(Call, "register '" + Twine(RegName) + "' allocated for constraint '" + Twine(OpInfo.ConstraintCode) + diff --git a/llvm/lib/CodeGen/SelectionDAG/StatepointLowering.cpp b/llvm/lib/CodeGen/SelectionDAG/StatepointLowering.cpp index 68c53fd..b318c2a 100644 --- a/llvm/lib/CodeGen/SelectionDAG/StatepointLowering.cpp +++ b/llvm/lib/CodeGen/SelectionDAG/StatepointLowering.cpp @@ -196,10 +196,10 @@ static Optional<int> findPreviousSpillSlot(const Value *Val, for (auto &IncomingValue : Phi->incoming_values()) { Optional<int> SpillSlot = findPreviousSpillSlot(IncomingValue, Builder, LookUpDepth - 1); - if (!SpillSlot) + if (!SpillSlot.hasValue()) return None; - if (MergedResult && *MergedResult != *SpillSlot) + if (MergedResult.hasValue() && *MergedResult != *SpillSlot) return None; MergedResult = SpillSlot; @@ -530,14 +530,16 @@ lowerStatepointMetaArgs(SmallVectorImpl<SDValue> &Ops, GCStrategy &S = GFI->getStrategy(); for (const Value *V : SI.Bases) { auto Opt = S.isGCManagedPointer(V->getType()->getScalarType()); - if (Opt) { - assert(*Opt && "non gc managed base pointer found in statepoint"); + if (Opt.hasValue()) { + assert(Opt.getValue() && + "non gc managed base pointer found in statepoint"); } } for (const Value *V : SI.Ptrs) { auto Opt = S.isGCManagedPointer(V->getType()->getScalarType()); - if (Opt) { - assert(*Opt && "non gc managed derived pointer found in statepoint"); + if (Opt.hasValue()) { + assert(Opt.getValue() && + "non gc managed derived pointer found in statepoint"); } } assert(SI.Bases.size() == SI.Ptrs.size() && "Pointer without base!"); diff --git a/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp b/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp index c286d21..a6b471e 100644 --- a/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp +++ b/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp @@ -1972,9 +1972,9 @@ bool TargetLowering::SimplifyDemandedBits( KnownBits Known1 = TLO.DAG.computeKnownBits(Op1, DemandedElts, Depth + 1); Known = KnownBits::umin(Known0, Known1); if (Optional<bool> IsULE = KnownBits::ule(Known0, Known1)) - return TLO.CombineTo(Op, *IsULE ? Op0 : Op1); + return TLO.CombineTo(Op, IsULE.getValue() ? Op0 : Op1); if (Optional<bool> IsULT = KnownBits::ult(Known0, Known1)) - return TLO.CombineTo(Op, *IsULT ? Op0 : Op1); + return TLO.CombineTo(Op, IsULT.getValue() ? Op0 : Op1); break; } case ISD::UMAX: { @@ -1985,9 +1985,9 @@ bool TargetLowering::SimplifyDemandedBits( KnownBits Known1 = TLO.DAG.computeKnownBits(Op1, DemandedElts, Depth + 1); Known = KnownBits::umax(Known0, Known1); if (Optional<bool> IsUGE = KnownBits::uge(Known0, Known1)) - return TLO.CombineTo(Op, *IsUGE ? Op0 : Op1); + return TLO.CombineTo(Op, IsUGE.getValue() ? Op0 : Op1); if (Optional<bool> IsUGT = KnownBits::ugt(Known0, Known1)) - return TLO.CombineTo(Op, *IsUGT ? Op0 : Op1); + return TLO.CombineTo(Op, IsUGT.getValue() ? Op0 : Op1); break; } case ISD::BITREVERSE: { diff --git a/llvm/lib/DebugInfo/CodeView/CodeViewRecordIO.cpp b/llvm/lib/DebugInfo/CodeView/CodeViewRecordIO.cpp index a66f9af..c49c2e5 100644 --- a/llvm/lib/DebugInfo/CodeView/CodeViewRecordIO.cpp +++ b/llvm/lib/DebugInfo/CodeView/CodeViewRecordIO.cpp @@ -70,10 +70,10 @@ uint32_t CodeViewRecordIO::maxFieldLength() const { Optional<uint32_t> Min = Limits.front().bytesRemaining(Offset); for (auto X : makeArrayRef(Limits).drop_front()) { Optional<uint32_t> ThisMin = X.bytesRemaining(Offset); - if (ThisMin) - Min = Min ? std::min(*Min, *ThisMin) : *ThisMin; + if (ThisMin.hasValue()) + Min = (Min.hasValue()) ? std::min(*Min, *ThisMin) : *ThisMin; } - assert(Min && "Every field must have a maximum length!"); + assert(Min.hasValue() && "Every field must have a maximum length!"); return *Min; } diff --git a/llvm/lib/DebugInfo/CodeView/TypeRecordMapping.cpp b/llvm/lib/DebugInfo/CodeView/TypeRecordMapping.cpp index 27f63b9..9b35b23 100644 --- a/llvm/lib/DebugInfo/CodeView/TypeRecordMapping.cpp +++ b/llvm/lib/DebugInfo/CodeView/TypeRecordMapping.cpp @@ -228,8 +228,8 @@ static Error mapNameAndUniqueName(CodeViewRecordIO &IO, StringRef &Name, } Error TypeRecordMapping::visitTypeBegin(CVType &CVR) { - assert(!TypeKind && "Already in a type mapping!"); - assert(!MemberKind && "Already in a member mapping!"); + assert(!TypeKind.hasValue() && "Already in a type mapping!"); + assert(!MemberKind.hasValue() && "Already in a member mapping!"); // FieldList and MethodList records can be any length because they can be // split with continuation records. All other record types cannot be @@ -260,8 +260,8 @@ Error TypeRecordMapping::visitTypeBegin(CVType &CVR, TypeIndex Index) { } Error TypeRecordMapping::visitTypeEnd(CVType &Record) { - assert(TypeKind && "Not in a type mapping!"); - assert(!MemberKind && "Still in a member mapping!"); + assert(TypeKind.hasValue() && "Not in a type mapping!"); + assert(!MemberKind.hasValue() && "Still in a member mapping!"); error(IO.endRecord()); @@ -270,8 +270,8 @@ Error TypeRecordMapping::visitTypeEnd(CVType &Record) { } Error TypeRecordMapping::visitMemberBegin(CVMemberRecord &Record) { - assert(TypeKind && "Not in a type mapping!"); - assert(!MemberKind && "Already in a member mapping!"); + assert(TypeKind.hasValue() && "Not in a type mapping!"); + assert(!MemberKind.hasValue() && "Already in a member mapping!"); // The largest possible subrecord is one in which there is a record prefix, // followed by the subrecord, followed by a continuation, and that entire @@ -296,8 +296,8 @@ Error TypeRecordMapping::visitMemberBegin(CVMemberRecord &Record) { } Error TypeRecordMapping::visitMemberEnd(CVMemberRecord &Record) { - assert(TypeKind && "Not in a type mapping!"); - assert(MemberKind && "Not in a member mapping!"); + assert(TypeKind.hasValue() && "Not in a type mapping!"); + assert(MemberKind.hasValue() && "Not in a member mapping!"); if (IO.isReading()) { if (auto EC = IO.skipPadding()) diff --git a/llvm/lib/DebugInfo/DWARF/DWARFContext.cpp b/llvm/lib/DebugInfo/DWARF/DWARFContext.cpp index dd49ef8..c785026 100644 --- a/llvm/lib/DebugInfo/DWARF/DWARFContext.cpp +++ b/llvm/lib/DebugInfo/DWARF/DWARFContext.cpp @@ -1205,12 +1205,13 @@ void DWARFContext::addLocalsForDie(DWARFCompileUnit *CU, DWARFDie Subprogram, if (auto DeclFileAttr = Die.find(DW_AT_decl_file)) { if (const auto *LT = CU->getContext().getLineTableForUnit(CU)) LT->getFileNameByIndex( - *DeclFileAttr->getAsUnsignedConstant(), CU->getCompilationDir(), + DeclFileAttr->getAsUnsignedConstant().getValue(), + CU->getCompilationDir(), DILineInfoSpecifier::FileLineInfoKind::AbsoluteFilePath, Local.DeclFile); } if (auto DeclLineAttr = Die.find(DW_AT_decl_line)) - Local.DeclLine = *DeclLineAttr->getAsUnsignedConstant(); + Local.DeclLine = DeclLineAttr->getAsUnsignedConstant().getValue(); Result.push_back(Local); return; diff --git a/llvm/lib/DebugInfo/DWARF/DWARFDebugLine.cpp b/llvm/lib/DebugInfo/DWARF/DWARFDebugLine.cpp index 25d0b9f..2e0780e 100644 --- a/llvm/lib/DebugInfo/DWARF/DWARFDebugLine.cpp +++ b/llvm/lib/DebugInfo/DWARF/DWARFDebugLine.cpp @@ -327,20 +327,20 @@ parseV5DirFileTables(const DWARFDataExtractor &DebugLineData, FileEntry.Source = Value; break; case DW_LNCT_directory_index: - FileEntry.DirIdx = *Value.getAsUnsignedConstant(); + FileEntry.DirIdx = Value.getAsUnsignedConstant().getValue(); break; case DW_LNCT_timestamp: - FileEntry.ModTime = *Value.getAsUnsignedConstant(); + FileEntry.ModTime = Value.getAsUnsignedConstant().getValue(); break; case DW_LNCT_size: - FileEntry.Length = *Value.getAsUnsignedConstant(); + FileEntry.Length = Value.getAsUnsignedConstant().getValue(); break; case DW_LNCT_MD5: - if (!Value.getAsBlock() || Value.getAsBlock()->size() != 16) + if (!Value.getAsBlock() || Value.getAsBlock().getValue().size() != 16) return createStringError( errc::invalid_argument, "failed to parse file entry because the MD5 hash is invalid"); - std::uninitialized_copy_n(Value.getAsBlock()->begin(), 16, + std::uninitialized_copy_n(Value.getAsBlock().getValue().begin(), 16, FileEntry.Checksum.begin()); break; default: diff --git a/llvm/lib/DebugInfo/PDB/Native/DbiStreamBuilder.cpp b/llvm/lib/DebugInfo/PDB/Native/DbiStreamBuilder.cpp index 3a719bd..1cb332c 100644 --- a/llvm/lib/DebugInfo/PDB/Native/DbiStreamBuilder.cpp +++ b/llvm/lib/DebugInfo/PDB/Native/DbiStreamBuilder.cpp @@ -427,14 +427,14 @@ Error DbiStreamBuilder::commit(const msf::MSFLayout &Layout, for (auto &Stream : DbgStreams) { uint16_t StreamNumber = kInvalidStreamIndex; - if (Stream) + if (Stream.hasValue()) StreamNumber = Stream->StreamNumber; if (auto EC = Writer.writeInteger(StreamNumber)) return EC; } for (auto &Stream : DbgStreams) { - if (!Stream) + if (!Stream.hasValue()) continue; assert(Stream->StreamNumber != kInvalidStreamIndex); diff --git a/llvm/lib/Frontend/OpenMP/OMPContext.cpp b/llvm/lib/Frontend/OpenMP/OMPContext.cpp index 017548f..eea08b2 100644 --- a/llvm/lib/Frontend/OpenMP/OMPContext.cpp +++ b/llvm/lib/Frontend/OpenMP/OMPContext.cpp @@ -212,8 +212,9 @@ static int isVariantApplicableInContextHelper( return Ctx.matchesISATrait(RawString); }); - if (Optional<bool> Result = HandleTrait(Property, IsActiveTrait)) - return *Result; + Optional<bool> Result = HandleTrait(Property, IsActiveTrait); + if (Result.hasValue()) + return Result.getValue(); } if (!DeviceSetOnly) { @@ -232,8 +233,9 @@ static int isVariantApplicableInContextHelper( if (ConstructMatches) ConstructMatches->push_back(ConstructIdx - 1); - if (Optional<bool> Result = HandleTrait(Property, FoundInOrder)) - return *Result; + Optional<bool> Result = HandleTrait(Property, FoundInOrder); + if (Result.hasValue()) + return Result.getValue(); if (!FoundInOrder) { LLVM_DEBUG(dbgs() << "[" << DEBUG_TYPE << "] Construct property " diff --git a/llvm/lib/IR/Instructions.cpp b/llvm/lib/IR/Instructions.cpp index 7e718ac..22e8ca7 100644 --- a/llvm/lib/IR/Instructions.cpp +++ b/llvm/lib/IR/Instructions.cpp @@ -4423,9 +4423,10 @@ MDNode *SwitchInstProfUpdateWrapper::buildProfBranchWeightsMD() { assert(SI.getNumSuccessors() == Weights->size() && "num of prof branch_weights must accord with num of successors"); - bool AllZeroes = all_of(*Weights, [](uint32_t W) { return W == 0; }); + bool AllZeroes = + all_of(Weights.getValue(), [](uint32_t W) { return W == 0; }); - if (AllZeroes || Weights->size() < 2) + if (AllZeroes || Weights.getValue().size() < 2) return nullptr; return MDBuilder(SI.getParent()->getContext()).createBranchWeights(*Weights); @@ -4459,8 +4460,8 @@ SwitchInstProfUpdateWrapper::removeCase(SwitchInst::CaseIt I) { // Copy the last case to the place of the removed one and shrink. // This is tightly coupled with the way SwitchInst::removeCase() removes // the cases in SwitchInst::removeCase(CaseIt). - Weights.value()[I->getCaseIndex() + 1] = Weights->back(); - Weights->pop_back(); + Weights.getValue()[I->getCaseIndex() + 1] = Weights.getValue().back(); + Weights.getValue().pop_back(); } return SI.removeCase(I); } @@ -4473,10 +4474,10 @@ void SwitchInstProfUpdateWrapper::addCase( if (!Weights && W && *W) { Changed = true; Weights = SmallVector<uint32_t, 8>(SI.getNumSuccessors(), 0); - Weights.value()[SI.getNumSuccessors() - 1] = *W; + Weights.getValue()[SI.getNumSuccessors() - 1] = *W; } else if (Weights) { Changed = true; - Weights->push_back(W.value_or(0)); + Weights.getValue().push_back(W.value_or(0)); } if (Weights) assert(SI.getNumSuccessors() == Weights->size() && diff --git a/llvm/lib/IR/IntrinsicInst.cpp b/llvm/lib/IR/IntrinsicInst.cpp index 953090f..ac03b14 100644 --- a/llvm/lib/IR/IntrinsicInst.cpp +++ b/llvm/lib/IR/IntrinsicInst.cpp @@ -223,13 +223,13 @@ ConstrainedFPIntrinsic::getExceptionBehavior() const { bool ConstrainedFPIntrinsic::isDefaultFPEnvironment() const { Optional<fp::ExceptionBehavior> Except = getExceptionBehavior(); if (Except) { - if (*Except != fp::ebIgnore) + if (Except.getValue() != fp::ebIgnore) return false; } Optional<RoundingMode> Rounding = getRoundingMode(); if (Rounding) { - if (*Rounding != RoundingMode::NearestTiesToEven) + if (Rounding.getValue() != RoundingMode::NearestTiesToEven) return false; } @@ -363,14 +363,14 @@ VPIntrinsic::getVectorLengthParamPos(Intrinsic::ID IntrinsicID) { /// scatter. MaybeAlign VPIntrinsic::getPointerAlignment() const { Optional<unsigned> PtrParamOpt = getMemoryPointerParamPos(getIntrinsicID()); - assert(PtrParamOpt && "no pointer argument!"); - return getParamAlign(*PtrParamOpt); + assert(PtrParamOpt.hasValue() && "no pointer argument!"); + return getParamAlign(PtrParamOpt.getValue()); } /// \return The pointer operand of this load,store, gather or scatter. Value *VPIntrinsic::getMemoryPointerParam() const { if (auto PtrParamOpt = getMemoryPointerParamPos(getIntrinsicID())) - return getArgOperand(*PtrParamOpt); + return getArgOperand(PtrParamOpt.getValue()); return nullptr; } @@ -388,9 +388,10 @@ Optional<unsigned> VPIntrinsic::getMemoryPointerParamPos(Intrinsic::ID VPID) { /// \return The data (payload) operand of this store or scatter. Value *VPIntrinsic::getMemoryDataParam() const { - if (auto DataParamOpt = getMemoryDataParamPos(getIntrinsicID())) - return getArgOperand(*DataParamOpt); - return nullptr; + auto DataParamOpt = getMemoryDataParamPos(getIntrinsicID()); + if (!DataParamOpt.hasValue()) + return nullptr; + return getArgOperand(DataParamOpt.getValue()); } Optional<unsigned> VPIntrinsic::getMemoryDataParamPos(Intrinsic::ID VPID) { diff --git a/llvm/lib/IR/LLVMContextImpl.cpp b/llvm/lib/IR/LLVMContextImpl.cpp index 7e005b3..dc44a34 100644 --- a/llvm/lib/IR/LLVMContextImpl.cpp +++ b/llvm/lib/IR/LLVMContextImpl.cpp @@ -250,17 +250,17 @@ void LLVMContextImpl::setOptPassGate(OptPassGate& OPG) { } bool LLVMContextImpl::hasOpaquePointersValue() { - return OpaquePointers.has_value(); + return OpaquePointers.hasValue(); } bool LLVMContextImpl::getOpaquePointers() { - if (LLVM_UNLIKELY(!OpaquePointers)) + if (LLVM_UNLIKELY(!(OpaquePointers.hasValue()))) OpaquePointers = OpaquePointersCL; return *OpaquePointers; } void LLVMContextImpl::setOpaquePointers(bool OP) { - assert((!OpaquePointers || *OpaquePointers == OP) && + assert((!OpaquePointers.hasValue() || OpaquePointers.getValue() == OP) && "Cannot change opaque pointers mode once set"); OpaquePointers = OP; } diff --git a/llvm/lib/IR/VectorBuilder.cpp b/llvm/lib/IR/VectorBuilder.cpp index e7be7a9..82995ce 100644 --- a/llvm/lib/IR/VectorBuilder.cpp +++ b/llvm/lib/IR/VectorBuilder.cpp @@ -90,9 +90,9 @@ Value *VectorBuilder::createVectorInstruction(unsigned Opcode, Type *ReturnTy, } } - if (MaskPosOpt) + if (MaskPosOpt.hasValue()) IntrinParams[*MaskPosOpt] = &requestMask(); - if (VLenPosOpt) + if (VLenPosOpt.hasValue()) IntrinParams[*VLenPosOpt] = &requestEVL(); auto *VPDecl = VPIntrinsic::getDeclarationForParams(&getModule(), VPID, diff --git a/llvm/lib/IR/Verifier.cpp b/llvm/lib/IR/Verifier.cpp index cbdf1d1..8f857933 100644 --- a/llvm/lib/IR/Verifier.cpp +++ b/llvm/lib/IR/Verifier.cpp @@ -5844,10 +5844,10 @@ void Verifier::visitConstrainedFPIntrinsic(ConstrainedFPIntrinsic &FPI) { // match the specification in the intrinsic call table. Thus, no // argument type check is needed here. - Check(FPI.getExceptionBehavior().has_value(), + Check(FPI.getExceptionBehavior().hasValue(), "invalid exception behavior argument", &FPI); if (HasRoundingMD) { - Check(FPI.getRoundingMode().has_value(), "invalid rounding mode argument", + Check(FPI.getRoundingMode().hasValue(), "invalid rounding mode argument", &FPI); } } diff --git a/llvm/lib/InterfaceStub/IFSHandler.cpp b/llvm/lib/InterfaceStub/IFSHandler.cpp index c999387..71189e7 100644 --- a/llvm/lib/InterfaceStub/IFSHandler.cpp +++ b/llvm/lib/InterfaceStub/IFSHandler.cpp @@ -202,8 +202,8 @@ Error ifs::writeIFSToOutputStream(raw_ostream &OS, const IFSStub &Stub) { yaml::Output YamlOut(OS, nullptr, /*WrapColumn =*/0); std::unique_ptr<IFSStubTriple> CopyStub(new IFSStubTriple(Stub)); if (Stub.Target.Arch) { - CopyStub->Target.ArchString = - std::string(ELF::convertEMachineToArchName(*Stub.Target.Arch)); + CopyStub->Target.ArchString = std::string( + ELF::convertEMachineToArchName(Stub.Target.Arch.getValue())); } IFSTarget Target = Stub.Target; @@ -222,33 +222,36 @@ Error ifs::overrideIFSTarget(IFSStub &Stub, Optional<IFSArch> OverrideArch, Optional<std::string> OverrideTriple) { std::error_code OverrideEC(1, std::generic_category()); if (OverrideArch) { - if (Stub.Target.Arch && *Stub.Target.Arch != *OverrideArch) { + if (Stub.Target.Arch && + Stub.Target.Arch.getValue() != OverrideArch.getValue()) { return make_error<StringError>( "Supplied Arch conflicts with the text stub", OverrideEC); } - Stub.Target.Arch = *OverrideArch; + Stub.Target.Arch = OverrideArch.getValue(); } if (OverrideEndianness) { if (Stub.Target.Endianness && - *Stub.Target.Endianness != *OverrideEndianness) { + Stub.Target.Endianness.getValue() != OverrideEndianness.getValue()) { return make_error<StringError>( "Supplied Endianness conflicts with the text stub", OverrideEC); } - Stub.Target.Endianness = *OverrideEndianness; + Stub.Target.Endianness = OverrideEndianness.getValue(); } if (OverrideBitWidth) { - if (Stub.Target.BitWidth && *Stub.Target.BitWidth != *OverrideBitWidth) { + if (Stub.Target.BitWidth && + Stub.Target.BitWidth.getValue() != OverrideBitWidth.getValue()) { return make_error<StringError>( "Supplied BitWidth conflicts with the text stub", OverrideEC); } - Stub.Target.BitWidth = *OverrideBitWidth; + Stub.Target.BitWidth = OverrideBitWidth.getValue(); } if (OverrideTriple) { - if (Stub.Target.Triple && *Stub.Target.Triple != *OverrideTriple) { + if (Stub.Target.Triple && + Stub.Target.Triple.getValue() != OverrideTriple.getValue()) { return make_error<StringError>( "Supplied Triple conflicts with the text stub", OverrideEC); } - Stub.Target.Triple = *OverrideTriple; + Stub.Target.Triple = OverrideTriple.getValue(); } return Error::success(); } diff --git a/llvm/lib/MC/MCContext.cpp b/llvm/lib/MC/MCContext.cpp index e8f0987..1c0c711 100644 --- a/llvm/lib/MC/MCContext.cpp +++ b/llvm/lib/MC/MCContext.cpp @@ -767,13 +767,14 @@ MCSectionXCOFF *MCContext::getXCOFFSection( Optional<XCOFF::CsectProperties> CsectProp, bool MultiSymbolsAllowed, const char *BeginSymName, Optional<XCOFF::DwarfSectionSubtypeFlags> DwarfSectionSubtypeFlags) { - bool IsDwarfSec = DwarfSectionSubtypeFlags.has_value(); - assert((IsDwarfSec != CsectProp.has_value()) && "Invalid XCOFF section!"); + bool IsDwarfSec = DwarfSectionSubtypeFlags.hasValue(); + assert((IsDwarfSec != CsectProp.hasValue()) && "Invalid XCOFF section!"); // Do the lookup. If we have a hit, return it. auto IterBool = XCOFFUniquingMap.insert(std::make_pair( - IsDwarfSec ? XCOFFSectionKey(Section.str(), *DwarfSectionSubtypeFlags) - : XCOFFSectionKey(Section.str(), CsectProp->MappingClass), + IsDwarfSec + ? XCOFFSectionKey(Section.str(), DwarfSectionSubtypeFlags.getValue()) + : XCOFFSectionKey(Section.str(), CsectProp->MappingClass), nullptr)); auto &Entry = *IterBool.first; if (!IterBool.second) { @@ -803,9 +804,10 @@ MCSectionXCOFF *MCContext::getXCOFFSection( // CachedName contains invalid character(s) such as '$' for an XCOFF symbol. MCSectionXCOFF *Result = nullptr; if (IsDwarfSec) - Result = new (XCOFFAllocator.Allocate()) MCSectionXCOFF( - QualName->getUnqualifiedName(), Kind, QualName, - *DwarfSectionSubtypeFlags, Begin, CachedName, MultiSymbolsAllowed); + Result = new (XCOFFAllocator.Allocate()) + MCSectionXCOFF(QualName->getUnqualifiedName(), Kind, QualName, + DwarfSectionSubtypeFlags.getValue(), Begin, CachedName, + MultiSymbolsAllowed); else Result = new (XCOFFAllocator.Allocate()) MCSectionXCOFF(QualName->getUnqualifiedName(), CsectProp->MappingClass, diff --git a/llvm/lib/MC/MCDisassembler/MCDisassembler.cpp b/llvm/lib/MC/MCDisassembler/MCDisassembler.cpp index af52c34..c6035dc 100644 --- a/llvm/lib/MC/MCDisassembler/MCDisassembler.cpp +++ b/llvm/lib/MC/MCDisassembler/MCDisassembler.cpp @@ -83,13 +83,12 @@ bool XCOFFSymbolInfo::operator<(const XCOFFSymbolInfo &SymInfo) const { return SymInfo.IsLabel; // Symbols with a StorageMappingClass have higher priority than those without. - if (StorageMappingClass.has_value() != - SymInfo.StorageMappingClass.has_value()) - return SymInfo.StorageMappingClass.has_value(); + if (StorageMappingClass.hasValue() != SymInfo.StorageMappingClass.hasValue()) + return SymInfo.StorageMappingClass.hasValue(); - if (StorageMappingClass) { - return getSMCPriority(*StorageMappingClass) < - getSMCPriority(*SymInfo.StorageMappingClass); + if (StorageMappingClass.hasValue()) { + return getSMCPriority(StorageMappingClass.getValue()) < + getSMCPriority(SymInfo.StorageMappingClass.getValue()); } return false; diff --git a/llvm/lib/MC/MCParser/MasmParser.cpp b/llvm/lib/MC/MCParser/MasmParser.cpp index c4240ca..7ed37b0 100644 --- a/llvm/lib/MC/MCParser/MasmParser.cpp +++ b/llvm/lib/MC/MCParser/MasmParser.cpp @@ -4239,9 +4239,10 @@ bool MasmParser::parseStructInitializer(const StructInfo &Structure, auto &FieldInitializers = Initializer.FieldInitializers; size_t FieldIndex = 0; - if (EndToken) { + if (EndToken.hasValue()) { // Initialize all fields with given initializers. - while (getTok().isNot(*EndToken) && FieldIndex < Structure.Fields.size()) { + while (getTok().isNot(EndToken.getValue()) && + FieldIndex < Structure.Fields.size()) { const FieldInfo &Field = Structure.Fields[FieldIndex++]; if (parseOptionalToken(AsmToken::Comma)) { // Empty initializer; use the default and continue. (Also, allow line @@ -4271,11 +4272,11 @@ bool MasmParser::parseStructInitializer(const StructInfo &Structure, FieldInitializers.push_back(Field.Contents); } - if (EndToken) { - if (*EndToken == AsmToken::Greater) + if (EndToken.hasValue()) { + if (EndToken.getValue() == AsmToken::Greater) return parseAngleBracketClose(); - return parseToken(*EndToken); + return parseToken(EndToken.getValue()); } return false; diff --git a/llvm/lib/MC/MCSchedule.cpp b/llvm/lib/MC/MCSchedule.cpp index dd1ecce..db08e20 100644 --- a/llvm/lib/MC/MCSchedule.cpp +++ b/llvm/lib/MC/MCSchedule.cpp @@ -96,10 +96,10 @@ MCSchedModel::getReciprocalThroughput(const MCSubtargetInfo &STI, continue; unsigned NumUnits = SM.getProcResource(I->ProcResourceIdx)->NumUnits; double Temp = NumUnits * 1.0 / I->Cycles; - Throughput = Throughput ? std::min(*Throughput, Temp) : Temp; + Throughput = Throughput ? std::min(Throughput.getValue(), Temp) : Temp; } - if (Throughput) - return 1.0 / *Throughput; + if (Throughput.hasValue()) + return 1.0 / Throughput.getValue(); // If no throughput value was calculated, assume that we can execute at the // maximum issue width scaled by number of micro-ops for the schedule class. @@ -140,10 +140,10 @@ MCSchedModel::getReciprocalThroughput(unsigned SchedClass, if (!I->getCycles()) continue; double Temp = countPopulation(I->getUnits()) * 1.0 / I->getCycles(); - Throughput = Throughput ? std::min(*Throughput, Temp) : Temp; + Throughput = Throughput ? std::min(Throughput.getValue(), Temp) : Temp; } - if (Throughput) - return 1.0 / *Throughput; + if (Throughput.hasValue()) + return 1.0 / Throughput.getValue(); // If there are no execution resources specified for this class, then assume // that it can execute at the maximum default issue width. diff --git a/llvm/lib/MC/MCSectionXCOFF.cpp b/llvm/lib/MC/MCSectionXCOFF.cpp index 0f6d5d5..ee8fa04 100644 --- a/llvm/lib/MC/MCSectionXCOFF.cpp +++ b/llvm/lib/MC/MCSectionXCOFF.cpp @@ -110,8 +110,8 @@ void MCSectionXCOFF::printSwitchToSection(const MCAsmInfo &MAI, const Triple &T, // XCOFF debug sections. if (getKind().isMetadata() && isDwarfSect()) { - OS << "\n\t.dwsect " << format("0x%" PRIx32, *getDwarfSubtypeFlags()) - << '\n'; + OS << "\n\t.dwsect " + << format("0x%" PRIx32, getDwarfSubtypeFlags().getValue()) << '\n'; OS << MAI.getPrivateLabelPrefix() << getName() << ':' << '\n'; return; } diff --git a/llvm/lib/ObjCopy/ELF/ELFObjcopy.cpp b/llvm/lib/ObjCopy/ELF/ELFObjcopy.cpp index 01c0ae7..a7b7a47 100644 --- a/llvm/lib/ObjCopy/ELF/ELFObjcopy.cpp +++ b/llvm/lib/ObjCopy/ELF/ELFObjcopy.cpp @@ -601,8 +601,8 @@ handleUserSection(const NewSectionInfo &NewSection, static Error handleArgs(const CommonConfig &Config, const ELFConfig &ELFConfig, Object &Obj) { if (Config.OutputArch) { - Obj.Machine = Config.OutputArch->EMachine; - Obj.OSABI = Config.OutputArch->OSABI; + Obj.Machine = Config.OutputArch.getValue().EMachine; + Obj.OSABI = Config.OutputArch.getValue().OSABI; } if (!Config.SplitDWO.empty() && Config.ExtractDWO) { @@ -639,8 +639,8 @@ static Error handleArgs(const CommonConfig &Config, const ELFConfig &ELFConfig, if (Iter != Config.SectionsToRename.end()) { const SectionRename &SR = Iter->second; Sec.Name = std::string(SR.NewName); - if (SR.NewFlags) - setSectionFlagsAndType(Sec, *SR.NewFlags); + if (SR.NewFlags.hasValue()) + setSectionFlagsAndType(Sec, SR.NewFlags.getValue()); RenamedSections.insert(&Sec); } else if (RelocSec && !(Sec.Flags & SHF_ALLOC)) // Postpone processing relocation sections which are not specified in @@ -808,9 +808,9 @@ Error objcopy::elf::executeObjcopyOnBinary(const CommonConfig &Config, if (!Obj) return Obj.takeError(); // Prefer OutputArch (-O<format>) if set, otherwise infer it from the input. - const ElfType OutputElfType = Config.OutputArch - ? getOutputElfType(*Config.OutputArch) - : getOutputElfType(In); + const ElfType OutputElfType = + Config.OutputArch ? getOutputElfType(Config.OutputArch.getValue()) + : getOutputElfType(In); if (Error E = handleArgs(Config, ELFConfig, **Obj)) return createFileError(Config.InputFilename, std::move(E)); diff --git a/llvm/lib/Object/ELFObjectFile.cpp b/llvm/lib/Object/ELFObjectFile.cpp index 9ab0357..9bac454 100644 --- a/llvm/lib/Object/ELFObjectFile.cpp +++ b/llvm/lib/Object/ELFObjectFile.cpp @@ -167,12 +167,12 @@ SubtargetFeatures ELFObjectFileBase::getARMFeatures() const { bool isV7 = false; Optional<unsigned> Attr = Attributes.getAttributeValue(ARMBuildAttrs::CPU_arch); - if (Attr) - isV7 = *Attr == ARMBuildAttrs::v7; + if (Attr.hasValue()) + isV7 = Attr.getValue() == ARMBuildAttrs::v7; Attr = Attributes.getAttributeValue(ARMBuildAttrs::CPU_arch_profile); - if (Attr) { - switch (*Attr) { + if (Attr.hasValue()) { + switch (Attr.getValue()) { case ARMBuildAttrs::ApplicationProfile: Features.AddFeature("aclass"); break; @@ -190,8 +190,8 @@ SubtargetFeatures ELFObjectFileBase::getARMFeatures() const { } Attr = Attributes.getAttributeValue(ARMBuildAttrs::THUMB_ISA_use); - if (Attr) { - switch (*Attr) { + if (Attr.hasValue()) { + switch (Attr.getValue()) { default: break; case ARMBuildAttrs::Not_Allowed: @@ -205,8 +205,8 @@ SubtargetFeatures ELFObjectFileBase::getARMFeatures() const { } Attr = Attributes.getAttributeValue(ARMBuildAttrs::FP_arch); - if (Attr) { - switch (*Attr) { + if (Attr.hasValue()) { + switch (Attr.getValue()) { default: break; case ARMBuildAttrs::Not_Allowed: @@ -229,8 +229,8 @@ SubtargetFeatures ELFObjectFileBase::getARMFeatures() const { } Attr = Attributes.getAttributeValue(ARMBuildAttrs::Advanced_SIMD_arch); - if (Attr) { - switch (*Attr) { + if (Attr.hasValue()) { + switch (Attr.getValue()) { default: break; case ARMBuildAttrs::Not_Allowed: @@ -248,8 +248,8 @@ SubtargetFeatures ELFObjectFileBase::getARMFeatures() const { } Attr = Attributes.getAttributeValue(ARMBuildAttrs::MVE_arch); - if (Attr) { - switch (*Attr) { + if (Attr.hasValue()) { + switch (Attr.getValue()) { default: break; case ARMBuildAttrs::Not_Allowed: @@ -267,8 +267,8 @@ SubtargetFeatures ELFObjectFileBase::getARMFeatures() const { } Attr = Attributes.getAttributeValue(ARMBuildAttrs::DIV_use); - if (Attr) { - switch (*Attr) { + if (Attr.hasValue()) { + switch (Attr.getValue()) { default: break; case ARMBuildAttrs::DisallowDIV: @@ -521,8 +521,8 @@ void ELFObjectFileBase::setARMSubArch(Triple &TheTriple) const { Optional<unsigned> Attr = Attributes.getAttributeValue(ARMBuildAttrs::CPU_arch); - if (Attr) { - switch (*Attr) { + if (Attr.hasValue()) { + switch (Attr.getValue()) { case ARMBuildAttrs::v4: Triple += "v4"; break; @@ -553,8 +553,8 @@ void ELFObjectFileBase::setARMSubArch(Triple &TheTriple) const { case ARMBuildAttrs::v7: { Optional<unsigned> ArchProfileAttr = Attributes.getAttributeValue(ARMBuildAttrs::CPU_arch_profile); - if (ArchProfileAttr && - *ArchProfileAttr == ARMBuildAttrs::MicroControllerProfile) + if (ArchProfileAttr.hasValue() && + ArchProfileAttr.getValue() == ARMBuildAttrs::MicroControllerProfile) Triple += "v7m"; else Triple += "v7"; diff --git a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp index d51120b..9834b03 100644 --- a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp +++ b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp @@ -133,17 +133,17 @@ void DXContainerWriter::writeParts(raw_ostream &OS) { // Compute the optional fields if needed... if (P.Program->DXILOffset) - Header.Bitcode.Offset = *P.Program->DXILOffset; + Header.Bitcode.Offset = P.Program->DXILOffset.getValue(); else Header.Bitcode.Offset = sizeof(dxbc::BitcodeHeader); if (P.Program->DXILSize) - Header.Bitcode.Size = *P.Program->DXILSize; + Header.Bitcode.Size = P.Program->DXILSize.getValue(); else Header.Bitcode.Size = P.Program->DXIL ? P.Program->DXIL->size() : 0; if (P.Program->Size) - Header.Size = *P.Program->Size; + Header.Size = P.Program->Size.getValue(); else Header.Size = sizeof(dxbc::ProgramHeader) + Header.Bitcode.Size; diff --git a/llvm/lib/Support/Process.cpp b/llvm/lib/Support/Process.cpp index d93b7de..547b3b7 100644 --- a/llvm/lib/Support/Process.cpp +++ b/llvm/lib/Support/Process.cpp @@ -42,12 +42,12 @@ Optional<std::string> Process::FindInEnvPath(StringRef EnvName, assert(!path::is_absolute(FileName)); Optional<std::string> FoundPath; Optional<std::string> OptPath = Process::GetEnv(EnvName); - if (!OptPath) + if (!OptPath.hasValue()) return FoundPath; const char EnvPathSeparatorStr[] = {Separator, '\0'}; SmallVector<StringRef, 8> Dirs; - SplitString(*OptPath, Dirs, EnvPathSeparatorStr); + SplitString(OptPath.getValue(), Dirs, EnvPathSeparatorStr); for (StringRef Dir : Dirs) { if (Dir.empty()) diff --git a/llvm/lib/Support/VirtualFileSystem.cpp b/llvm/lib/Support/VirtualFileSystem.cpp index 9f6ad7e..9c6a0c0 100644 --- a/llvm/lib/Support/VirtualFileSystem.cpp +++ b/llvm/lib/Support/VirtualFileSystem.cpp @@ -2667,15 +2667,15 @@ void JSONWriter::write(ArrayRef<YAMLVFSEntry> Entries, OS << "{\n" " 'version': 0,\n"; - if (IsCaseSensitive) - OS << " 'case-sensitive': '" << (*IsCaseSensitive ? "true" : "false") - << "',\n"; - if (UseExternalNames) - OS << " 'use-external-names': '" << (*UseExternalNames ? "true" : "false") - << "',\n"; + if (IsCaseSensitive.hasValue()) + OS << " 'case-sensitive': '" + << (IsCaseSensitive.getValue() ? "true" : "false") << "',\n"; + if (UseExternalNames.hasValue()) + OS << " 'use-external-names': '" + << (UseExternalNames.getValue() ? "true" : "false") << "',\n"; bool UseOverlayRelative = false; - if (IsOverlayRelative) { - UseOverlayRelative = *IsOverlayRelative; + if (IsOverlayRelative.hasValue()) { + UseOverlayRelative = IsOverlayRelative.getValue(); OS << " 'overlay-relative': '" << (UseOverlayRelative ? "true" : "false") << "',\n"; } diff --git a/llvm/lib/Support/raw_ostream.cpp b/llvm/lib/Support/raw_ostream.cpp index 0c83259..7648dac 100644 --- a/llvm/lib/Support/raw_ostream.cpp +++ b/llvm/lib/Support/raw_ostream.cpp @@ -428,8 +428,8 @@ raw_ostream &raw_ostream::operator<<(const FormattedBytes &FB) { while (!Bytes.empty()) { indent(FB.IndentLevel); - if (FB.FirstByteOffset) { - uint64_t Offset = *FB.FirstByteOffset; + if (FB.FirstByteOffset.hasValue()) { + uint64_t Offset = FB.FirstByteOffset.getValue(); llvm::write_hex(*this, Offset + LineIndex, HPS, OffsetWidth); *this << ": "; } diff --git a/llvm/lib/TableGen/Record.cpp b/llvm/lib/TableGen/Record.cpp index 64f0953..e100251 100644 --- a/llvm/lib/TableGen/Record.cpp +++ b/llvm/lib/TableGen/Record.cpp @@ -2598,10 +2598,10 @@ Init *Record::getValueInit(StringRef FieldName) const { StringRef Record::getValueAsString(StringRef FieldName) const { llvm::Optional<StringRef> S = getValueAsOptionalString(FieldName); - if (!S) + if (!S.hasValue()) PrintFatalError(getLoc(), "Record `" + getName() + "' does not have a field named `" + FieldName + "'!\n"); - return *S; + return S.getValue(); } llvm::Optional<StringRef> diff --git a/llvm/lib/Target/AMDGPU/AMDGPUInstructionSelector.cpp b/llvm/lib/Target/AMDGPU/AMDGPUInstructionSelector.cpp index 4e2dfc6..76a39d0 100644 --- a/llvm/lib/Target/AMDGPU/AMDGPUInstructionSelector.cpp +++ b/llvm/lib/Target/AMDGPU/AMDGPUInstructionSelector.cpp @@ -1171,8 +1171,8 @@ bool AMDGPUInstructionSelector::selectBallot(MachineInstr &I) const { Optional<ValueAndVReg> Arg = getIConstantVRegValWithLookThrough(I.getOperand(2).getReg(), *MRI); - if (Arg) { - const int64_t Value = Arg->Value.getSExtValue(); + if (Arg.hasValue()) { + const int64_t Value = Arg.getValue().Value.getSExtValue(); if (Value == 0) { unsigned Opcode = Is64 ? AMDGPU::S_MOV_B64 : AMDGPU::S_MOV_B32; BuildMI(*BB, &I, DL, TII.get(Opcode), DstReg).addImm(0); @@ -4201,8 +4201,8 @@ AMDGPUInstructionSelector::selectMUBUFScratchOffen(MachineOperand &Root) const { MIB.addReg(Info->getScratchRSrcReg()); }, [=](MachineInstrBuilder &MIB) { // vaddr - if (FI) - MIB.addFrameIndex(*FI); + if (FI.hasValue()) + MIB.addFrameIndex(FI.getValue()); else MIB.addReg(VAddr); }, diff --git a/llvm/lib/Target/AMDGPU/AMDGPUMachineModuleInfo.h b/llvm/lib/Target/AMDGPU/AMDGPUMachineModuleInfo.h index 2572b04..1b513c4 100644 --- a/llvm/lib/Target/AMDGPU/AMDGPUMachineModuleInfo.h +++ b/llvm/lib/Target/AMDGPU/AMDGPUMachineModuleInfo.h @@ -131,8 +131,8 @@ public: bool IsAOneAddressSpace = isOneAddressSpace(A); bool IsBOneAddressSpace = isOneAddressSpace(B); - return *AIO >= *BIO && - (IsAOneAddressSpace == IsBOneAddressSpace || !IsAOneAddressSpace); + return AIO.getValue() >= BIO.getValue() && + (IsAOneAddressSpace == IsBOneAddressSpace || !IsAOneAddressSpace); } }; diff --git a/llvm/lib/Target/AMDGPU/SIMemoryLegalizer.cpp b/llvm/lib/Target/AMDGPU/SIMemoryLegalizer.cpp index 19989a3..8a66213 100644 --- a/llvm/lib/Target/AMDGPU/SIMemoryLegalizer.cpp +++ b/llvm/lib/Target/AMDGPU/SIMemoryLegalizer.cpp @@ -2329,13 +2329,13 @@ bool SIMemoryLegalizer::runOnMachineFunction(MachineFunction &MF) { continue; if (const auto &MOI = MOA.getLoadInfo(MI)) - Changed |= expandLoad(*MOI, MI); + Changed |= expandLoad(MOI.getValue(), MI); else if (const auto &MOI = MOA.getStoreInfo(MI)) - Changed |= expandStore(*MOI, MI); + Changed |= expandStore(MOI.getValue(), MI); else if (const auto &MOI = MOA.getAtomicFenceInfo(MI)) - Changed |= expandAtomicFence(*MOI, MI); + Changed |= expandAtomicFence(MOI.getValue(), MI); else if (const auto &MOI = MOA.getAtomicCmpxchgOrRmwInfo(MI)) - Changed |= expandAtomicCmpxchgOrRmw(*MOI, MI); + Changed |= expandAtomicCmpxchgOrRmw(MOI.getValue(), MI); } } diff --git a/llvm/lib/Target/ARM/MVEGatherScatterLowering.cpp b/llvm/lib/Target/ARM/MVEGatherScatterLowering.cpp index 310d3ed..3078534 100644 --- a/llvm/lib/Target/ARM/MVEGatherScatterLowering.cpp +++ b/llvm/lib/Target/ARM/MVEGatherScatterLowering.cpp @@ -351,13 +351,13 @@ Optional<int64_t> MVEGatherScatterLowering::getIfConst(const Value *V) { if (!Op0 || !Op1) return Optional<int64_t>{}; if (I->getOpcode() == Instruction::Add) - return Optional<int64_t>{*Op0 + *Op1}; + return Optional<int64_t>{Op0.getValue() + Op1.getValue()}; if (I->getOpcode() == Instruction::Mul) - return Optional<int64_t>{*Op0 * *Op1}; + return Optional<int64_t>{Op0.getValue() * Op1.getValue()}; if (I->getOpcode() == Instruction::Shl) - return Optional<int64_t>{*Op0 << *Op1}; + return Optional<int64_t>{Op0.getValue() << Op1.getValue()}; if (I->getOpcode() == Instruction::Or) - return Optional<int64_t>{*Op0 | *Op1}; + return Optional<int64_t>{Op0.getValue() | Op1.getValue()}; } return Optional<int64_t>{}; } diff --git a/llvm/lib/Target/Hexagon/HexagonFrameLowering.cpp b/llvm/lib/Target/Hexagon/HexagonFrameLowering.cpp index 9641791..56d471a 100644 --- a/llvm/lib/Target/Hexagon/HexagonFrameLowering.cpp +++ b/llvm/lib/Target/Hexagon/HexagonFrameLowering.cpp @@ -1021,9 +1021,11 @@ findCFILocation(MachineBasicBlock &B) { } void HexagonFrameLowering::insertCFIInstructions(MachineFunction &MF) const { - for (auto &B : MF) - if (auto At = findCFILocation(B)) - insertCFIInstructionsAt(B, *At); + for (auto &B : MF) { + auto At = findCFILocation(B); + if (At.hasValue()) + insertCFIInstructionsAt(B, At.getValue()); + } } void HexagonFrameLowering::insertCFIInstructionsAt(MachineBasicBlock &MBB, diff --git a/llvm/lib/Target/Lanai/AsmParser/LanaiAsmParser.cpp b/llvm/lib/Target/Lanai/AsmParser/LanaiAsmParser.cpp index 5ef28cc..660215c 100644 --- a/llvm/lib/Target/Lanai/AsmParser/LanaiAsmParser.cpp +++ b/llvm/lib/Target/Lanai/AsmParser/LanaiAsmParser.cpp @@ -704,15 +704,15 @@ LanaiAsmParser::parseRegister(bool RestoreOnFailure) { if (Lexer.getKind() == AsmToken::Identifier) { RegNum = MatchRegisterName(Lexer.getTok().getIdentifier()); if (RegNum == 0) { - if (PercentTok && RestoreOnFailure) - Lexer.UnLex(*PercentTok); + if (PercentTok.hasValue() && RestoreOnFailure) + Lexer.UnLex(PercentTok.getValue()); return nullptr; } Parser.Lex(); // Eat identifier token return LanaiOperand::createReg(RegNum, Start, End); } - if (PercentTok && RestoreOnFailure) - Lexer.UnLex(*PercentTok); + if (PercentTok.hasValue() && RestoreOnFailure) + Lexer.UnLex(PercentTok.getValue()); return nullptr; } diff --git a/llvm/lib/Target/NVPTX/NVPTXISelLowering.cpp b/llvm/lib/Target/NVPTX/NVPTXISelLowering.cpp index 312ab0a..e52b49e 100644 --- a/llvm/lib/Target/NVPTX/NVPTXISelLowering.cpp +++ b/llvm/lib/Target/NVPTX/NVPTXISelLowering.cpp @@ -1860,8 +1860,8 @@ SDValue NVPTXTargetLowering::LowerCall(TargetLowering::CallLoweringInfo &CLI, Chain = Ret.getValue(1); InFlag = Ret.getValue(2); - if (ProxyRegTruncates[i]) { - Ret = DAG.getNode(ISD::TRUNCATE, dl, *ProxyRegTruncates[i], Ret); + if (ProxyRegTruncates[i].hasValue()) { + Ret = DAG.getNode(ISD::TRUNCATE, dl, ProxyRegTruncates[i].getValue(), Ret); } InVals.push_back(Ret); diff --git a/llvm/lib/Target/PowerPC/PPCMacroFusion.cpp b/llvm/lib/Target/PowerPC/PPCMacroFusion.cpp index 58b74c6..caf1457 100644 --- a/llvm/lib/Target/PowerPC/PPCMacroFusion.cpp +++ b/llvm/lib/Target/PowerPC/PPCMacroFusion.cpp @@ -267,13 +267,13 @@ static bool shouldScheduleAdjacent(const TargetInstrInfo &TII, continue; auto DepOpIdx = Feature.depOpIdx(); - if (DepOpIdx) { + if (DepOpIdx.hasValue()) { // Checking if the result of the FirstMI is the desired operand of the // SecondMI if the DepOpIdx is set. Otherwise, ignore it. if (!matchingRegOps(*FirstMI, 0, SecondMI, *DepOpIdx)) return false; } - + // Checking more on the instruction operands. if (checkOpConstraints(Feature.getKind(), *FirstMI, SecondMI)) return true; diff --git a/llvm/lib/Target/PowerPC/PPCTargetMachine.cpp b/llvm/lib/Target/PowerPC/PPCTargetMachine.cpp index fe396cb..dd7a9fe 100644 --- a/llvm/lib/Target/PowerPC/PPCTargetMachine.cpp +++ b/llvm/lib/Target/PowerPC/PPCTargetMachine.cpp @@ -246,10 +246,10 @@ static PPCTargetMachine::PPCABI computeTargetABI(const Triple &TT, static Reloc::Model getEffectiveRelocModel(const Triple &TT, Optional<Reloc::Model> RM) { - assert((!TT.isOSAIX() || !RM || *RM == Reloc::PIC_) && + assert((!TT.isOSAIX() || !RM.hasValue() || *RM == Reloc::PIC_) && "Invalid relocation model for AIX."); - if (RM) + if (RM.hasValue()) return *RM; // Big Endian PPC and AIX default to PIC. diff --git a/llvm/lib/Target/VE/VVPISelLowering.cpp b/llvm/lib/Target/VE/VVPISelLowering.cpp index e4c35da..cd67a0f 100644 --- a/llvm/lib/Target/VE/VVPISelLowering.cpp +++ b/llvm/lib/Target/VE/VVPISelLowering.cpp @@ -39,9 +39,9 @@ SDValue VETargetLowering::lowerToVVP(SDValue Op, SelectionDAG &DAG) const { // Can we represent this as a VVP node. const unsigned Opcode = Op->getOpcode(); auto VVPOpcodeOpt = getVVPOpcode(Opcode); - if (!VVPOpcodeOpt) + if (!VVPOpcodeOpt.hasValue()) return SDValue(); - unsigned VVPOpcode = *VVPOpcodeOpt; + unsigned VVPOpcode = VVPOpcodeOpt.getValue(); const bool FromVP = ISD::isVPOpcode(Opcode); // The representative and legalized vector type of this operation. diff --git a/llvm/lib/Target/WebAssembly/AsmParser/WebAssemblyAsmTypeCheck.cpp b/llvm/lib/Target/WebAssembly/AsmParser/WebAssemblyAsmTypeCheck.cpp index abc6115..61097e1 100644 --- a/llvm/lib/Target/WebAssembly/AsmParser/WebAssemblyAsmTypeCheck.cpp +++ b/llvm/lib/Target/WebAssembly/AsmParser/WebAssemblyAsmTypeCheck.cpp @@ -86,15 +86,18 @@ bool WebAssemblyAsmTypeCheck::popType(SMLoc ErrorLoc, Optional<wasm::ValType> EVT) { if (Stack.empty()) { return typeError(ErrorLoc, - EVT ? StringRef("empty stack while popping ") + - WebAssembly::typeToString(*EVT) - : StringRef("empty stack while popping value")); + EVT.hasValue() + ? StringRef("empty stack while popping ") + + WebAssembly::typeToString(EVT.getValue()) + : StringRef( + "empty stack while popping value")); } auto PVT = Stack.pop_back_val(); - if (EVT && *EVT != PVT) { - return typeError(ErrorLoc, - StringRef("popped ") + WebAssembly::typeToString(PVT) + - ", expected " + WebAssembly::typeToString(*EVT)); + if (EVT.hasValue() && EVT.getValue() != PVT) { + return typeError( + ErrorLoc, StringRef("popped ") + WebAssembly::typeToString(PVT) + + ", expected " + + WebAssembly::typeToString(EVT.getValue())); } return false; } diff --git a/llvm/lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp b/llvm/lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp index 65aa709..f09758a 100644 --- a/llvm/lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp +++ b/llvm/lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp @@ -552,8 +552,8 @@ Value *WebAssemblyLowerEmscriptenEHSjLj::wrapInvoke(CallBase *CI) { Optional<unsigned> NEltArg; std::tie(SizeArg, NEltArg) = FnAttrs.getAllocSizeArgs(); SizeArg += 1; - if (NEltArg) - NEltArg = *NEltArg + 1; + if (NEltArg.hasValue()) + NEltArg = NEltArg.getValue() + 1; FnAttrs.addAllocSizeAttr(SizeArg, NEltArg); } // In case the callee has 'noreturn' attribute, We need to remove it, because diff --git a/llvm/lib/Transforms/IPO/Attributor.cpp b/llvm/lib/Transforms/IPO/Attributor.cpp index 284b9b3..769d79b 100644 --- a/llvm/lib/Transforms/IPO/Attributor.cpp +++ b/llvm/lib/Transforms/IPO/Attributor.cpp @@ -297,11 +297,11 @@ AA::combineOptionalValuesInAAValueLatice(const Optional<Value *> &A, const Optional<Value *> &B, Type *Ty) { if (A == B) return A; - if (!B) + if (!B.hasValue()) return A; if (*B == nullptr) return nullptr; - if (!A) + if (!A.hasValue()) return Ty ? getWithType(**B, *Ty) : nullptr; if (*A == nullptr) return nullptr; @@ -718,8 +718,8 @@ Argument *IRPosition::getAssociatedArgument() const { } // If we found a unique callback candidate argument, return it. - if (CBCandidateArg && *CBCandidateArg) - return *CBCandidateArg; + if (CBCandidateArg.hasValue() && CBCandidateArg.getValue()) + return CBCandidateArg.getValue(); // If no callbacks were found, or none used the underlying call site operand // exclusively, use the direct callee argument if available. @@ -1048,11 +1048,11 @@ Attributor::getAssumedConstant(const IRPosition &IRP, recordDependence(ValueSimplifyAA, AA, DepClassTy::OPTIONAL); return llvm::None; } - if (isa_and_nonnull<UndefValue>(*SimplifiedV)) { + if (isa_and_nonnull<UndefValue>(SimplifiedV.getValue())) { recordDependence(ValueSimplifyAA, AA, DepClassTy::OPTIONAL); return UndefValue::get(IRP.getAssociatedType()); } - Constant *CI = dyn_cast_or_null<Constant>(*SimplifiedV); + Constant *CI = dyn_cast_or_null<Constant>(SimplifiedV.getValue()); if (CI) CI = dyn_cast_or_null<Constant>( AA::getWithType(*CI, *IRP.getAssociatedType())); @@ -2695,10 +2695,10 @@ void InformationCache::initializeInformationCache(const Function &CF, while (!Worklist.empty()) { const Instruction *I = Worklist.pop_back_val(); Optional<short> &NumUses = AssumeUsesMap[I]; - if (!NumUses) + if (!NumUses.hasValue()) NumUses = I->getNumUses(); - NumUses = *NumUses - /* this assume */ 1; - if (*NumUses != 0) + NumUses = NumUses.getValue() - /* this assume */ 1; + if (NumUses.getValue() != 0) continue; AssumeOnlyValues.insert(I); for (const Value *Op : I->operands()) diff --git a/llvm/lib/Transforms/IPO/AttributorAttributes.cpp b/llvm/lib/Transforms/IPO/AttributorAttributes.cpp index 5483e42..b36c712 100644 --- a/llvm/lib/Transforms/IPO/AttributorAttributes.cpp +++ b/llvm/lib/Transforms/IPO/AttributorAttributes.cpp @@ -395,9 +395,9 @@ static bool genericValueTraversal( if (UseValueSimplify && !isa<Constant>(V)) { Optional<Value *> SimpleV = A.getAssumedSimplified(*V, QueryingAA, UsedAssumedInformation); - if (!SimpleV) + if (!SimpleV.hasValue()) continue; - Value *NewV = *SimpleV; + Value *NewV = SimpleV.getValue(); if (NewV && NewV != V) { if ((VS & AA::Interprocedural) || !CtxI || AA::isValidInScope(*NewV, CtxI->getFunction())) { @@ -1851,14 +1851,14 @@ ChangeStatus AAReturnedValuesImpl::manifest(Attributor &A) { // Check if we have an assumed unique return value that we could manifest. Optional<Value *> UniqueRV = getAssumedUniqueReturnValue(A); - if (!UniqueRV || !*UniqueRV) + if (!UniqueRV.hasValue() || !UniqueRV.getValue()) return Changed; // Bookkeeping. STATS_DECLTRACK(UniqueReturnValue, FunctionReturn, "Number of function with unique return"); // If the assumed unique return value is an argument, annotate it. - if (auto *UniqueRVArg = dyn_cast<Argument>(*UniqueRV)) { + if (auto *UniqueRVArg = dyn_cast<Argument>(UniqueRV.getValue())) { if (UniqueRVArg->getType()->canLosslesslyBitCastTo( getAssociatedFunction()->getReturnType())) { getIRPosition() = IRPosition::argument(*UniqueRVArg); @@ -2626,9 +2626,9 @@ struct AAUndefinedBehaviorImpl : public AAUndefinedBehavior { // Either we stopped and the appropriate action was taken, // or we got back a simplified value to continue. Optional<Value *> SimplifiedPtrOp = stopOnUndefOrAssumed(A, PtrOp, &I); - if (!SimplifiedPtrOp || !*SimplifiedPtrOp) + if (!SimplifiedPtrOp.hasValue() || !SimplifiedPtrOp.getValue()) return true; - const Value *PtrOpVal = *SimplifiedPtrOp; + const Value *PtrOpVal = SimplifiedPtrOp.getValue(); // A memory access through a pointer is considered UB // only if the pointer has constant null value. @@ -2717,14 +2717,15 @@ struct AAUndefinedBehaviorImpl : public AAUndefinedBehavior { IRPosition::value(*ArgVal), *this, UsedAssumedInformation); if (UsedAssumedInformation) continue; - if (SimplifiedVal && !*SimplifiedVal) + if (SimplifiedVal.hasValue() && !SimplifiedVal.getValue()) return true; - if (!SimplifiedVal || isa<UndefValue>(**SimplifiedVal)) { + if (!SimplifiedVal.hasValue() || + isa<UndefValue>(*SimplifiedVal.getValue())) { KnownUBInsts.insert(&I); continue; } if (!ArgVal->getType()->isPointerTy() || - !isa<ConstantPointerNull>(**SimplifiedVal)) + !isa<ConstantPointerNull>(*SimplifiedVal.getValue())) continue; auto &NonNullAA = A.getAAFor<AANonNull>(*this, CalleeArgumentIRP, DepClassTy::NONE); @@ -4061,11 +4062,11 @@ identifyAliveSuccessors(Attributor &A, const SwitchInst &SI, bool UsedAssumedInformation = false; Optional<Constant *> C = A.getAssumedConstant(*SI.getCondition(), AA, UsedAssumedInformation); - if (!C || isa_and_nonnull<UndefValue>(*C)) { + if (!C.hasValue() || isa_and_nonnull<UndefValue>(C.getValue())) { // No value yet, assume all edges are dead. - } else if (isa_and_nonnull<ConstantInt>(*C)) { + } else if (isa_and_nonnull<ConstantInt>(C.getValue())) { for (auto &CaseIt : SI.cases()) { - if (CaseIt.getCaseValue() == *C) { + if (CaseIt.getCaseValue() == C.getValue()) { AliveSuccessors.push_back(&CaseIt.getCaseSuccessor()->front()); return UsedAssumedInformation; } @@ -5480,11 +5481,11 @@ struct AAValueSimplifyImpl : AAValueSimplify { bool UsedAssumedInformation = false; Optional<Value *> SimpleV = A.getAssumedSimplified(V, QueryingAA, UsedAssumedInformation); - if (!SimpleV) + if (!SimpleV.hasValue()) return PoisonValue::get(&Ty); Value *EffectiveV = &V; - if (*SimpleV) - EffectiveV = *SimpleV; + if (SimpleV.getValue()) + EffectiveV = SimpleV.getValue(); if (auto *C = dyn_cast<Constant>(EffectiveV)) if (!C->canTrap()) return C; @@ -5500,8 +5501,8 @@ struct AAValueSimplifyImpl : AAValueSimplify { /// Return a value we can use as replacement for the associated one, or /// nullptr if we don't have one that makes sense. Value *manifestReplacementValue(Attributor &A, Instruction *CtxI) const { - Value *NewV = SimplifiedAssociatedValue - ? *SimplifiedAssociatedValue + Value *NewV = SimplifiedAssociatedValue.hasValue() + ? SimplifiedAssociatedValue.getValue() : UndefValue::get(getAssociatedType()); if (NewV && NewV != &getAssociatedValue()) { ValueToValueMapTy VMap; @@ -5630,9 +5631,9 @@ struct AAValueSimplifyArgument final : AAValueSimplifyImpl { bool UsedAssumedInformation = false; Optional<Constant *> SimpleArgOp = A.getAssumedConstant(ACSArgPos, *this, UsedAssumedInformation); - if (!SimpleArgOp) + if (!SimpleArgOp.hasValue()) return true; - if (!*SimpleArgOp) + if (!SimpleArgOp.getValue()) return false; if (!AA::isDynamicallyUnique(A, *this, **SimpleArgOp)) return false; @@ -5745,18 +5746,18 @@ struct AAValueSimplifyFloating : AAValueSimplifyImpl { const auto &SimplifiedLHS = A.getAssumedSimplified(IRPosition::value(*LHS, getCallBaseContext()), *this, UsedAssumedInformation); - if (!SimplifiedLHS) + if (!SimplifiedLHS.hasValue()) return true; - if (!*SimplifiedLHS) + if (!SimplifiedLHS.getValue()) return false; LHS = *SimplifiedLHS; const auto &SimplifiedRHS = A.getAssumedSimplified(IRPosition::value(*RHS, getCallBaseContext()), *this, UsedAssumedInformation); - if (!SimplifiedRHS) + if (!SimplifiedRHS.hasValue()) return true; - if (!*SimplifiedRHS) + if (!SimplifiedRHS.getValue()) return false; RHS = *SimplifiedRHS; @@ -5825,11 +5826,11 @@ struct AAValueSimplifyFloating : AAValueSimplifyImpl { *this, UsedAssumedInformation); // If we are not sure about any operand we are not sure about the entire // instruction, we'll wait. - if (!SimplifiedOp) + if (!SimplifiedOp.hasValue()) return true; - if (*SimplifiedOp) - NewOps[Idx] = *SimplifiedOp; + if (SimplifiedOp.getValue()) + NewOps[Idx] = SimplifiedOp.getValue(); else NewOps[Idx] = Op; @@ -6248,10 +6249,11 @@ struct AAHeapToStackFunction final : public AAHeapToStack { Alignment = std::max(Alignment, *RetAlign); if (Value *Align = getAllocAlignment(AI.CB, TLI)) { Optional<APInt> AlignmentAPI = getAPInt(A, *this, *Align); - assert(AlignmentAPI && AlignmentAPI->getZExtValue() > 0 && + assert(AlignmentAPI.hasValue() && + AlignmentAPI.getValue().getZExtValue() > 0 && "Expected an alignment during manifest!"); - Alignment = - std::max(Alignment, assumeAligned(AlignmentAPI->getZExtValue())); + Alignment = std::max( + Alignment, assumeAligned(AlignmentAPI.getValue().getZExtValue())); } // TODO: Hoist the alloca towards the function entry. @@ -6297,9 +6299,9 @@ struct AAHeapToStackFunction final : public AAHeapToStack { bool UsedAssumedInformation = false; Optional<Constant *> SimpleV = A.getAssumedConstant(V, AA, UsedAssumedInformation); - if (!SimpleV) + if (!SimpleV.hasValue()) return APInt(64, 0); - if (auto *CI = dyn_cast_or_null<ConstantInt>(*SimpleV)) + if (auto *CI = dyn_cast_or_null<ConstantInt>(SimpleV.getValue())) return CI->getValue(); return llvm::None; } @@ -6576,9 +6578,9 @@ ChangeStatus AAHeapToStackFunction::updateImpl(Attributor &A) { if (MaxHeapToStackSize != -1) { Optional<APInt> Size = getSize(A, *this, AI); - if (!Size || Size->ugt(MaxHeapToStackSize)) { + if (!Size.hasValue() || Size.getValue().ugt(MaxHeapToStackSize)) { LLVM_DEBUG({ - if (!Size) + if (!Size.hasValue()) dbgs() << "[H2S] Unknown allocation size: " << *AI.CB << "\n"; else dbgs() << "[H2S] Allocation size too large: " << *AI.CB << " vs. " @@ -6631,9 +6633,9 @@ struct AAPrivatizablePtrImpl : public AAPrivatizablePtr { /// Return a privatizable type that encloses both T0 and T1. /// TODO: This is merely a stub for now as we should manage a mapping as well. Optional<Type *> combineTypes(Optional<Type *> T0, Optional<Type *> T1) { - if (!T0) + if (!T0.hasValue()) return T1; - if (!T1) + if (!T1.hasValue()) return T0; if (T0 == T1) return T0; @@ -6693,9 +6695,9 @@ struct AAPrivatizablePtrArgument final : public AAPrivatizablePtrImpl { LLVM_DEBUG({ dbgs() << "[AAPrivatizablePtr] ACSPos: " << ACSArgPos << ", CSTy: "; - if (CSTy && *CSTy) - CSTy.value()->print(dbgs()); - else if (CSTy) + if (CSTy.hasValue() && CSTy.getValue()) + CSTy.getValue()->print(dbgs()); + else if (CSTy.hasValue()) dbgs() << "<nullptr>"; else dbgs() << "<none>"; @@ -6705,16 +6707,16 @@ struct AAPrivatizablePtrArgument final : public AAPrivatizablePtrImpl { LLVM_DEBUG({ dbgs() << " : New Type: "; - if (Ty && *Ty) - (*Ty)->print(dbgs()); - else if (Ty) + if (Ty.hasValue() && Ty.getValue()) + Ty.getValue()->print(dbgs()); + else if (Ty.hasValue()) dbgs() << "<nullptr>"; else dbgs() << "<none>"; dbgs() << "\n"; }); - return !Ty || *Ty; + return !Ty.hasValue() || Ty.getValue(); }; if (!A.checkForAllCallSites(CallSiteCheck, *this, true, @@ -6726,9 +6728,9 @@ struct AAPrivatizablePtrArgument final : public AAPrivatizablePtrImpl { /// See AbstractAttribute::updateImpl(...). ChangeStatus updateImpl(Attributor &A) override { PrivatizableType = identifyPrivatizableType(A); - if (!PrivatizableType) + if (!PrivatizableType.hasValue()) return ChangeStatus::UNCHANGED; - if (!*PrivatizableType) + if (!PrivatizableType.getValue()) return indicatePessimisticFixpoint(); // The dependence is optional so we don't give up once we give up on the @@ -6815,9 +6817,9 @@ struct AAPrivatizablePtrArgument final : public AAPrivatizablePtrImpl { *this, IRPosition::argument(CBArg), DepClassTy::REQUIRED); if (CBArgPrivAA.isValidState()) { auto CBArgPrivTy = CBArgPrivAA.getPrivatizableType(); - if (!CBArgPrivTy) + if (!CBArgPrivTy.hasValue()) continue; - if (*CBArgPrivTy == PrivatizableType) + if (CBArgPrivTy.getValue() == PrivatizableType) continue; } @@ -6862,9 +6864,9 @@ struct AAPrivatizablePtrArgument final : public AAPrivatizablePtrImpl { DepClassTy::REQUIRED); if (DCArgPrivAA.isValidState()) { auto DCArgPrivTy = DCArgPrivAA.getPrivatizableType(); - if (!DCArgPrivTy) + if (!DCArgPrivTy.hasValue()) return true; - if (*DCArgPrivTy == PrivatizableType) + if (DCArgPrivTy.getValue() == PrivatizableType) return true; } } @@ -7004,9 +7006,9 @@ struct AAPrivatizablePtrArgument final : public AAPrivatizablePtrImpl { /// See AbstractAttribute::manifest(...) ChangeStatus manifest(Attributor &A) override { - if (!PrivatizableType) + if (!PrivatizableType.hasValue()) return ChangeStatus::UNCHANGED; - assert(*PrivatizableType && "Expected privatizable type!"); + assert(PrivatizableType.getValue() && "Expected privatizable type!"); // Collect all tail calls in the function as we cannot allow new allocas to // escape into tail recursion. @@ -7039,9 +7041,9 @@ struct AAPrivatizablePtrArgument final : public AAPrivatizablePtrImpl { Instruction *IP = &*EntryBB.getFirstInsertionPt(); const DataLayout &DL = IP->getModule()->getDataLayout(); unsigned AS = DL.getAllocaAddrSpace(); - Instruction *AI = new AllocaInst(*PrivatizableType, AS, + Instruction *AI = new AllocaInst(PrivatizableType.getValue(), AS, Arg->getName() + ".priv", IP); - createInitialization(*PrivatizableType, *AI, ReplacementFn, + createInitialization(PrivatizableType.getValue(), *AI, ReplacementFn, ArgIt->getArgNo(), *IP); if (AI->getType() != Arg->getType()) @@ -7147,9 +7149,9 @@ struct AAPrivatizablePtrCallSiteArgument final /// See AbstractAttribute::updateImpl(...). ChangeStatus updateImpl(Attributor &A) override { PrivatizableType = identifyPrivatizableType(A); - if (!PrivatizableType) + if (!PrivatizableType.hasValue()) return ChangeStatus::UNCHANGED; - if (!*PrivatizableType) + if (!PrivatizableType.getValue()) return indicatePessimisticFixpoint(); const IRPosition &IRP = getIRPosition(); @@ -8608,18 +8610,18 @@ struct AAValueConstantRangeFloating : AAValueConstantRangeImpl { const auto &SimplifiedLHS = A.getAssumedSimplified(IRPosition::value(*LHS, getCallBaseContext()), *this, UsedAssumedInformation); - if (!SimplifiedLHS) + if (!SimplifiedLHS.hasValue()) return true; - if (!*SimplifiedLHS) + if (!SimplifiedLHS.getValue()) return false; LHS = *SimplifiedLHS; const auto &SimplifiedRHS = A.getAssumedSimplified(IRPosition::value(*RHS, getCallBaseContext()), *this, UsedAssumedInformation); - if (!SimplifiedRHS) + if (!SimplifiedRHS.hasValue()) return true; - if (!*SimplifiedRHS) + if (!SimplifiedRHS.getValue()) return false; RHS = *SimplifiedRHS; @@ -8661,9 +8663,9 @@ struct AAValueConstantRangeFloating : AAValueConstantRangeImpl { const auto &SimplifiedOpV = A.getAssumedSimplified(IRPosition::value(*OpV, getCallBaseContext()), *this, UsedAssumedInformation); - if (!SimplifiedOpV) + if (!SimplifiedOpV.hasValue()) return true; - if (!*SimplifiedOpV) + if (!SimplifiedOpV.getValue()) return false; OpV = *SimplifiedOpV; @@ -8691,18 +8693,18 @@ struct AAValueConstantRangeFloating : AAValueConstantRangeImpl { const auto &SimplifiedLHS = A.getAssumedSimplified(IRPosition::value(*LHS, getCallBaseContext()), *this, UsedAssumedInformation); - if (!SimplifiedLHS) + if (!SimplifiedLHS.hasValue()) return true; - if (!*SimplifiedLHS) + if (!SimplifiedLHS.getValue()) return false; LHS = *SimplifiedLHS; const auto &SimplifiedRHS = A.getAssumedSimplified(IRPosition::value(*RHS, getCallBaseContext()), *this, UsedAssumedInformation); - if (!SimplifiedRHS) + if (!SimplifiedRHS.hasValue()) return true; - if (!*SimplifiedRHS) + if (!SimplifiedRHS.getValue()) return false; RHS = *SimplifiedRHS; @@ -8765,9 +8767,9 @@ struct AAValueConstantRangeFloating : AAValueConstantRangeImpl { const auto &SimplifiedOpV = A.getAssumedSimplified(IRPosition::value(V, getCallBaseContext()), *this, UsedAssumedInformation); - if (!SimplifiedOpV) + if (!SimplifiedOpV.hasValue()) return true; - if (!*SimplifiedOpV) + if (!SimplifiedOpV.getValue()) return false; Value *VPtr = *SimplifiedOpV; @@ -9126,18 +9128,18 @@ struct AAPotentialConstantValuesFloating : AAPotentialConstantValuesImpl { const auto &SimplifiedLHS = A.getAssumedSimplified(IRPosition::value(*LHS, getCallBaseContext()), *this, UsedAssumedInformation); - if (!SimplifiedLHS) + if (!SimplifiedLHS.hasValue()) return ChangeStatus::UNCHANGED; - if (!*SimplifiedLHS) + if (!SimplifiedLHS.getValue()) return indicatePessimisticFixpoint(); LHS = *SimplifiedLHS; const auto &SimplifiedRHS = A.getAssumedSimplified(IRPosition::value(*RHS, getCallBaseContext()), *this, UsedAssumedInformation); - if (!SimplifiedRHS) + if (!SimplifiedRHS.hasValue()) return ChangeStatus::UNCHANGED; - if (!*SimplifiedRHS) + if (!SimplifiedRHS.getValue()) return indicatePessimisticFixpoint(); RHS = *SimplifiedRHS; @@ -9209,18 +9211,18 @@ struct AAPotentialConstantValuesFloating : AAPotentialConstantValuesImpl { const auto &SimplifiedLHS = A.getAssumedSimplified(IRPosition::value(*LHS, getCallBaseContext()), *this, UsedAssumedInformation); - if (!SimplifiedLHS) + if (!SimplifiedLHS.hasValue()) return ChangeStatus::UNCHANGED; - if (!*SimplifiedLHS) + if (!SimplifiedLHS.getValue()) return indicatePessimisticFixpoint(); LHS = *SimplifiedLHS; const auto &SimplifiedRHS = A.getAssumedSimplified(IRPosition::value(*RHS, getCallBaseContext()), *this, UsedAssumedInformation); - if (!SimplifiedRHS) + if (!SimplifiedRHS.hasValue()) return ChangeStatus::UNCHANGED; - if (!*SimplifiedRHS) + if (!SimplifiedRHS.getValue()) return indicatePessimisticFixpoint(); RHS = *SimplifiedRHS; @@ -9232,9 +9234,9 @@ struct AAPotentialConstantValuesFloating : AAPotentialConstantValuesImpl { // Check if we only need one operand. bool OnlyLeft = false, OnlyRight = false; - if (C && *C && (*C)->isOneValue()) + if (C.hasValue() && *C && (*C)->isOneValue()) OnlyLeft = true; - else if (C && *C && (*C)->isZeroValue()) + else if (C.hasValue() && *C && (*C)->isZeroValue()) OnlyRight = true; const AAPotentialConstantValues *LHSAA = nullptr, *RHSAA = nullptr; @@ -9284,9 +9286,9 @@ struct AAPotentialConstantValuesFloating : AAPotentialConstantValuesImpl { const auto &SimplifiedSrc = A.getAssumedSimplified(IRPosition::value(*Src, getCallBaseContext()), *this, UsedAssumedInformation); - if (!SimplifiedSrc) + if (!SimplifiedSrc.hasValue()) return ChangeStatus::UNCHANGED; - if (!*SimplifiedSrc) + if (!SimplifiedSrc.getValue()) return indicatePessimisticFixpoint(); Src = *SimplifiedSrc; @@ -9317,18 +9319,18 @@ struct AAPotentialConstantValuesFloating : AAPotentialConstantValuesImpl { const auto &SimplifiedLHS = A.getAssumedSimplified(IRPosition::value(*LHS, getCallBaseContext()), *this, UsedAssumedInformation); - if (!SimplifiedLHS) + if (!SimplifiedLHS.hasValue()) return ChangeStatus::UNCHANGED; - if (!*SimplifiedLHS) + if (!SimplifiedLHS.getValue()) return indicatePessimisticFixpoint(); LHS = *SimplifiedLHS; const auto &SimplifiedRHS = A.getAssumedSimplified(IRPosition::value(*RHS, getCallBaseContext()), *this, UsedAssumedInformation); - if (!SimplifiedRHS) + if (!SimplifiedRHS.hasValue()) return ChangeStatus::UNCHANGED; - if (!*SimplifiedRHS) + if (!SimplifiedRHS.getValue()) return indicatePessimisticFixpoint(); RHS = *SimplifiedRHS; @@ -9385,9 +9387,9 @@ struct AAPotentialConstantValuesFloating : AAPotentialConstantValuesImpl { const auto &SimplifiedIncomingValue = A.getAssumedSimplified( IRPosition::value(*IncomingValue, getCallBaseContext()), *this, UsedAssumedInformation); - if (!SimplifiedIncomingValue) + if (!SimplifiedIncomingValue.hasValue()) continue; - if (!*SimplifiedIncomingValue) + if (!SimplifiedIncomingValue.getValue()) return indicatePessimisticFixpoint(); IncomingValue = *SimplifiedIncomingValue; @@ -9874,8 +9876,9 @@ private: bool isReachable(Attributor &A, AAFunctionReachability &AA, ArrayRef<const AACallEdges *> AAEdgesList, const Function &Fn) { - if (Optional<bool> Cached = isCachedReachable(Fn)) - return *Cached; + Optional<bool> Cached = isCachedReachable(Fn); + if (Cached.hasValue()) + return Cached.getValue(); // The query was not cached, thus it is new. We need to request an update // explicitly to make sure this the information is properly run to a diff --git a/llvm/lib/Transforms/IPO/IROutliner.cpp b/llvm/lib/Transforms/IPO/IROutliner.cpp index 9ed21de..89ae575 100644 --- a/llvm/lib/Transforms/IPO/IROutliner.cpp +++ b/llvm/lib/Transforms/IPO/IROutliner.cpp @@ -554,8 +554,8 @@ collectRegionsConstants(OutlinableRegion &Region, // the the number has been found to be not the same value in each instance. for (Value *V : ID.OperVals) { Optional<unsigned> GVNOpt = C.getGVN(V); - assert(GVNOpt && "Expected a GVN for operand?"); - unsigned GVN = *GVNOpt; + assert(GVNOpt.hasValue() && "Expected a GVN for operand?"); + unsigned GVN = GVNOpt.getValue(); // Check if this global value has been found to not be the same already. if (NotSame.contains(GVN)) { @@ -569,8 +569,8 @@ collectRegionsConstants(OutlinableRegion &Region, // global value number. If the global value does not map to a Constant, // it is considered to not be the same value. Optional<bool> ConstantMatches = constantMatches(V, GVN, GVNToConstant); - if (ConstantMatches) { - if (*ConstantMatches) + if (ConstantMatches.hasValue()) { + if (ConstantMatches.getValue()) continue; else ConstantsTheSame = false; @@ -650,8 +650,8 @@ Function *IROutliner::createFunction(Module &M, OutlinableGroup &Group, "outlined_ir_func_" + std::to_string(FunctionNameSuffix), M); // Transfer the swifterr attribute to the correct function parameter. - if (Group.SwiftErrorArgument) - Group.OutlinedFunction->addParamAttr(*Group.SwiftErrorArgument, + if (Group.SwiftErrorArgument.hasValue()) + Group.OutlinedFunction->addParamAttr(Group.SwiftErrorArgument.getValue(), Attribute::SwiftError); Group.OutlinedFunction->addFnAttr(Attribute::OptimizeForSize); @@ -808,8 +808,9 @@ static void mapInputsToGVNs(IRSimilarityCandidate &C, assert(Input && "Have a nullptr as an input"); if (OutputMappings.find(Input) != OutputMappings.end()) Input = OutputMappings.find(Input)->second; - assert(C.getGVN(Input) && "Could not find a numbering for the given input"); - EndInputNumbers.push_back(*C.getGVN(Input)); + assert(C.getGVN(Input).hasValue() && + "Could not find a numbering for the given input"); + EndInputNumbers.push_back(C.getGVN(Input).getValue()); } } @@ -947,12 +948,12 @@ findExtractedInputToOverallInputMapping(OutlinableRegion &Region, // numbering overrides any discovered location for the extracted code. for (unsigned InputVal : InputGVNs) { Optional<unsigned> CanonicalNumberOpt = C.getCanonicalNum(InputVal); - assert(CanonicalNumberOpt && "Canonical number not found?"); - unsigned CanonicalNumber = *CanonicalNumberOpt; + assert(CanonicalNumberOpt.hasValue() && "Canonical number not found?"); + unsigned CanonicalNumber = CanonicalNumberOpt.getValue(); Optional<Value *> InputOpt = C.fromGVN(InputVal); - assert(InputOpt && "Global value number not found?"); - Value *Input = *InputOpt; + assert(InputOpt.hasValue() && "Global value number not found?"); + Value *Input = InputOpt.getValue(); DenseMap<unsigned, unsigned>::iterator AggArgIt = Group.CanonicalNumberToAggArg.find(CanonicalNumber); @@ -1234,15 +1235,16 @@ static Optional<unsigned> getGVNForPHINode(OutlinableRegion &Region, DenseMap<hash_code, unsigned>::iterator GVNToPHIIt; DenseMap<unsigned, PHINodeData>::iterator PHIToGVNIt; Optional<unsigned> BBGVN = Cand.getGVN(PHIBB); - assert(BBGVN && "Could not find GVN for the incoming block!"); + assert(BBGVN.hasValue() && "Could not find GVN for the incoming block!"); - BBGVN = Cand.getCanonicalNum(*BBGVN); - assert(BBGVN && "Could not find canonical number for the incoming block!"); + BBGVN = Cand.getCanonicalNum(BBGVN.getValue()); + assert(BBGVN.hasValue() && + "Could not find canonical number for the incoming block!"); // Create a pair of the exit block canonical value, and the aggregate // argument location, connected to the canonical numbers stored in the // PHINode. PHINodeData TemporaryPair = - std::make_pair(std::make_pair(*BBGVN, AggArgIdx), PHIGVNs); + std::make_pair(std::make_pair(BBGVN.getValue(), AggArgIdx), PHIGVNs); hash_code PHINodeDataHash = encodePHINodeData(TemporaryPair); // Look for and create a new entry in our connection between canonical @@ -1515,8 +1517,9 @@ CallInst *replaceCalledFunction(Module &M, OutlinableRegion &Region) { // Make sure that the argument in the new function has the SwiftError // argument. - if (Group.SwiftErrorArgument) - Call->addParamAttr(*Group.SwiftErrorArgument, Attribute::SwiftError); + if (Group.SwiftErrorArgument.hasValue()) + Call->addParamAttr(Group.SwiftErrorArgument.getValue(), + Attribute::SwiftError); return Call; } @@ -1647,9 +1650,9 @@ static void findCanonNumsForPHI( // Find and add the canonical number for the incoming value. Optional<unsigned> GVN = Region.Candidate->getGVN(IVal); - assert(GVN && "No GVN for incoming value"); + assert(GVN.hasValue() && "No GVN for incoming value"); Optional<unsigned> CanonNum = Region.Candidate->getCanonicalNum(*GVN); - assert(CanonNum && "No Canonical Number for GVN"); + assert(CanonNum.hasValue() && "No Canonical Number for GVN"); CanonNums.push_back(std::make_pair(*CanonNum, IBlock)); } } @@ -2078,11 +2081,12 @@ static void alignOutputBlockWithAggFunc( // If there is, we remove the new output blocks. If it does not, // we add it to our list of sets of output blocks. - if (MatchingBB) { + if (MatchingBB.hasValue()) { LLVM_DEBUG(dbgs() << "Set output block for region in function" - << Region.ExtractedFunction << " to " << *MatchingBB); + << Region.ExtractedFunction << " to " + << MatchingBB.getValue()); - Region.OutputBlockNum = *MatchingBB; + Region.OutputBlockNum = MatchingBB.getValue(); for (std::pair<Value *, BasicBlock *> &VtoBB : OutputBBs) VtoBB.second->eraseFromParent(); return; @@ -2500,9 +2504,9 @@ static Value *findOutputValueInRegion(OutlinableRegion &Region, OutputCanon = *It->second.second.begin(); } Optional<unsigned> OGVN = Region.Candidate->fromCanonicalNum(OutputCanon); - assert(OGVN && "Could not find GVN for Canonical Number?"); + assert(OGVN.hasValue() && "Could not find GVN for Canonical Number?"); Optional<Value *> OV = Region.Candidate->fromGVN(*OGVN); - assert(OV && "Could not find value for GVN?"); + assert(OV.hasValue() && "Could not find value for GVN?"); return *OV; } @@ -2677,14 +2681,15 @@ void IROutliner::updateOutputMapping(OutlinableRegion &Region, if (!OutputIdx) return; - if (OutputMappings.find(Outputs[*OutputIdx]) == OutputMappings.end()) { + if (OutputMappings.find(Outputs[OutputIdx.getValue()]) == + OutputMappings.end()) { LLVM_DEBUG(dbgs() << "Mapping extracted output " << *LI << " to " - << *Outputs[*OutputIdx] << "\n"); - OutputMappings.insert(std::make_pair(LI, Outputs[OutputIdx.value()])); + << *Outputs[OutputIdx.getValue()] << "\n"); + OutputMappings.insert(std::make_pair(LI, Outputs[OutputIdx.getValue()])); } else { - Value *Orig = OutputMappings.find(Outputs[OutputIdx.value()])->second; + Value *Orig = OutputMappings.find(Outputs[OutputIdx.getValue()])->second; LLVM_DEBUG(dbgs() << "Mapping extracted output " << *Orig << " to " - << *Outputs[*OutputIdx] << "\n"); + << *Outputs[OutputIdx.getValue()] << "\n"); OutputMappings.insert(std::make_pair(LI, Orig)); } } diff --git a/llvm/lib/Transforms/IPO/OpenMPOpt.cpp b/llvm/lib/Transforms/IPO/OpenMPOpt.cpp index 20555af..f458afa 100644 --- a/llvm/lib/Transforms/IPO/OpenMPOpt.cpp +++ b/llvm/lib/Transforms/IPO/OpenMPOpt.cpp @@ -2514,13 +2514,13 @@ struct AAICVTrackerFunction : public AAICVTracker { if (ValuesMap.count(CurrInst)) { Optional<Value *> NewReplVal = ValuesMap.lookup(CurrInst); // Unknown value, track new. - if (!ReplVal) { + if (!ReplVal.hasValue()) { ReplVal = NewReplVal; break; } // If we found a new value, we can't know the icv value anymore. - if (NewReplVal) + if (NewReplVal.hasValue()) if (ReplVal != NewReplVal) return nullptr; @@ -2528,11 +2528,11 @@ struct AAICVTrackerFunction : public AAICVTracker { } Optional<Value *> NewReplVal = getValueForCall(A, *CurrInst, ICV); - if (!NewReplVal) + if (!NewReplVal.hasValue()) continue; // Unknown value, track new. - if (!ReplVal) { + if (!ReplVal.hasValue()) { ReplVal = NewReplVal; break; } @@ -4422,13 +4422,13 @@ struct AAFoldRuntimeCallCallSiteReturned : AAFoldRuntimeCall { std::string Str("simplified value: "); - if (!SimplifiedValue) + if (!SimplifiedValue.hasValue()) return Str + std::string("none"); - if (!SimplifiedValue.value()) + if (!SimplifiedValue.getValue()) return Str + std::string("nullptr"); - if (ConstantInt *CI = dyn_cast<ConstantInt>(SimplifiedValue.value())) + if (ConstantInt *CI = dyn_cast<ConstantInt>(SimplifiedValue.getValue())) return Str + std::to_string(CI->getSExtValue()); return Str + std::string("unknown"); @@ -4452,8 +4452,8 @@ struct AAFoldRuntimeCallCallSiteReturned : AAFoldRuntimeCall { IRPosition::callsite_returned(CB), [&](const IRPosition &IRP, const AbstractAttribute *AA, bool &UsedAssumedInformation) -> Optional<Value *> { - assert((isValidState() || - (SimplifiedValue && *SimplifiedValue == nullptr)) && + assert((isValidState() || (SimplifiedValue.hasValue() && + SimplifiedValue.getValue() == nullptr)) && "Unexpected invalid state!"); if (!isAtFixpoint()) { diff --git a/llvm/lib/Transforms/IPO/SampleContextTracker.cpp b/llvm/lib/Transforms/IPO/SampleContextTracker.cpp index caeddae..9cb558b 100644 --- a/llvm/lib/Transforms/IPO/SampleContextTracker.cpp +++ b/llvm/lib/Transforms/IPO/SampleContextTracker.cpp @@ -132,10 +132,10 @@ void ContextTrieNode::setFunctionSamples(FunctionSamples *FSamples) { Optional<uint32_t> ContextTrieNode::getFunctionSize() const { return FuncSize; } void ContextTrieNode::addFunctionSize(uint32_t FSize) { - if (!FuncSize) + if (!FuncSize.hasValue()) FuncSize = 0; - FuncSize = *FuncSize + FSize; + FuncSize = FuncSize.getValue() + FSize; } LineLocation ContextTrieNode::getCallSiteLoc() const { return CallSiteLoc; } diff --git a/llvm/lib/Transforms/IPO/SampleProfile.cpp b/llvm/lib/Transforms/IPO/SampleProfile.cpp index e5d6e26..8e45347 100644 --- a/llvm/lib/Transforms/IPO/SampleProfile.cpp +++ b/llvm/lib/Transforms/IPO/SampleProfile.cpp @@ -1351,14 +1351,14 @@ SampleProfileLoader::getExternalInlineAdvisorCost(CallBase &CB) { bool SampleProfileLoader::getExternalInlineAdvisorShouldInline(CallBase &CB) { Optional<InlineCost> Cost = getExternalInlineAdvisorCost(CB); - return Cost ? !!*Cost : false; + return Cost ? !!Cost.getValue() : false; } InlineCost SampleProfileLoader::shouldInlineCandidate(InlineCandidate &Candidate) { if (Optional<InlineCost> ReplayCost = getExternalInlineAdvisorCost(*Candidate.CallInstr)) - return *ReplayCost; + return ReplayCost.getValue(); // Adjust threshold based on call site hotness, only do this for callsite // prioritized inliner because otherwise cost-benefit check is done earlier. int SampleThreshold = SampleColdCallSiteThreshold; diff --git a/llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp b/llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp index 120f991..449c0f1 100644 --- a/llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp +++ b/llvm/lib/Transforms/InstCombine/InstCombineCalls.cpp @@ -2677,8 +2677,9 @@ Instruction *InstCombinerImpl::visitCallInst(CallInst &CI) { } default: { // Handle target specific intrinsics - if (Optional<Instruction *> V = targetInstCombineIntrinsic(*II)) - return *V; + Optional<Instruction *> V = targetInstCombineIntrinsic(*II); + if (V.hasValue()) + return V.getValue(); break; } } diff --git a/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp b/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp index d8a2a96..d801f4d 100644 --- a/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp +++ b/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp @@ -924,8 +924,8 @@ Value *InstCombinerImpl::SimplifyDemandedUseBits(Value *V, APInt DemandedMask, // Handle target specific intrinsics Optional<Value *> V = targetSimplifyDemandedUseBitsIntrinsic( *II, DemandedMask, Known, KnownBitsComputed); - if (V) - return *V; + if (V.hasValue()) + return V.getValue(); break; } } @@ -1635,8 +1635,8 @@ Value *InstCombinerImpl::SimplifyDemandedVectorElts(Value *V, Optional<Value *> V = targetSimplifyDemandedVectorEltsIntrinsic( *II, DemandedElts, UndefElts, UndefElts2, UndefElts3, simplifyAndSetOp); - if (V) - return *V; + if (V.hasValue()) + return V.getValue(); break; } } // switch on IntrinsicID diff --git a/llvm/lib/Transforms/Instrumentation/ThreadSanitizer.cpp b/llvm/lib/Transforms/Instrumentation/ThreadSanitizer.cpp index 284a4c2..5cc5804 100644 --- a/llvm/lib/Transforms/Instrumentation/ThreadSanitizer.cpp +++ b/llvm/lib/Transforms/Instrumentation/ThreadSanitizer.cpp @@ -483,10 +483,10 @@ void ThreadSanitizer::chooseInstructionsToInstrument( static bool isTsanAtomic(const Instruction *I) { // TODO: Ask TTI whether synchronization scope is between threads. auto SSID = getAtomicSyncScopeID(I); - if (!SSID) + if (!SSID.hasValue()) return false; if (isa<LoadInst>(I) || isa<StoreInst>(I)) - return *SSID != SyncScope::SingleThread; + return SSID.getValue() != SyncScope::SingleThread; return true; } diff --git a/llvm/lib/Transforms/Scalar/ConstantHoisting.cpp b/llvm/lib/Transforms/Scalar/ConstantHoisting.cpp index b698503..8a17615 100644 --- a/llvm/lib/Transforms/Scalar/ConstantHoisting.cpp +++ b/llvm/lib/Transforms/Scalar/ConstantHoisting.cpp @@ -611,9 +611,9 @@ ConstantHoistingPass::maximizeConstantsInRange(ConstCandVecType::iterator S, ConstCand->ConstInt->getValue()); if (Diff) { const InstructionCost ImmCosts = - TTI->getIntImmCodeSizeCost(Opcode, OpndIdx, *Diff, Ty); + TTI->getIntImmCodeSizeCost(Opcode, OpndIdx, Diff.getValue(), Ty); Cost -= ImmCosts; - LLVM_DEBUG(dbgs() << "Offset " << *Diff << " " + LLVM_DEBUG(dbgs() << "Offset " << Diff.getValue() << " " << "has penalty: " << ImmCosts << "\n" << "Adjusted cost: " << Cost << "\n"); } diff --git a/llvm/lib/Transforms/Scalar/GVN.cpp b/llvm/lib/Transforms/Scalar/GVN.cpp index af2b48c..783301f 100644 --- a/llvm/lib/Transforms/Scalar/GVN.cpp +++ b/llvm/lib/Transforms/Scalar/GVN.cpp @@ -748,14 +748,14 @@ void GVNPass::printPipeline( OS << "<"; if (Options.AllowPRE != None) - OS << (*Options.AllowPRE ? "" : "no-") << "pre;"; + OS << (Options.AllowPRE.getValue() ? "" : "no-") << "pre;"; if (Options.AllowLoadPRE != None) - OS << (*Options.AllowLoadPRE ? "" : "no-") << "load-pre;"; + OS << (Options.AllowLoadPRE.getValue() ? "" : "no-") << "load-pre;"; if (Options.AllowLoadPRESplitBackedge != None) - OS << (*Options.AllowLoadPRESplitBackedge ? "" : "no-") + OS << (Options.AllowLoadPRESplitBackedge.getValue() ? "" : "no-") << "split-backedge-load-pre;"; if (Options.AllowMemDep != None) - OS << (*Options.AllowMemDep ? "" : "no-") << "memdep"; + OS << (Options.AllowMemDep.getValue() ? "" : "no-") << "memdep"; OS << ">"; } diff --git a/llvm/lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp b/llvm/lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp index 94ed288..0e27c85 100644 --- a/llvm/lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp +++ b/llvm/lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp @@ -1427,9 +1427,9 @@ bool LoopConstrainer::run() { // constructor. ClonedLoop PreLoop, PostLoop; bool NeedsPreLoop = - Increasing ? SR.LowLimit.has_value() : SR.HighLimit.has_value(); + Increasing ? SR.LowLimit.hasValue() : SR.HighLimit.hasValue(); bool NeedsPostLoop = - Increasing ? SR.HighLimit.has_value() : SR.LowLimit.has_value(); + Increasing ? SR.HighLimit.hasValue() : SR.LowLimit.hasValue(); Value *ExitPreLoopAt = nullptr; Value *ExitMainLoopAt = nullptr; @@ -1708,9 +1708,9 @@ IntersectSignedRange(ScalarEvolution &SE, const InductiveRangeCheck::Range &R2) { if (R2.isEmpty(SE, /* IsSigned */ true)) return None; - if (!R1) + if (!R1.hasValue()) return R2; - auto &R1Value = *R1; + auto &R1Value = R1.getValue(); // We never return empty ranges from this function, and R1 is supposed to be // a result of intersection. Thus, R1 is never empty. assert(!R1Value.isEmpty(SE, /* IsSigned */ true) && @@ -1737,9 +1737,9 @@ IntersectUnsignedRange(ScalarEvolution &SE, const InductiveRangeCheck::Range &R2) { if (R2.isEmpty(SE, /* IsSigned */ false)) return None; - if (!R1) + if (!R1.hasValue()) return R2; - auto &R1Value = *R1; + auto &R1Value = R1.getValue(); // We never return empty ranges from this function, and R1 is supposed to be // a result of intersection. Thus, R1 is never empty. assert(!R1Value.isEmpty(SE, /* IsSigned */ false) && @@ -1948,21 +1948,24 @@ bool InductiveRangeCheckElimination::run( for (InductiveRangeCheck &IRC : RangeChecks) { auto Result = IRC.computeSafeIterationSpace(SE, IndVar, LS.IsSignedPredicate); - if (Result) { - auto MaybeSafeIterRange = IntersectRange(SE, SafeIterRange, *Result); - if (MaybeSafeIterRange) { - assert(!MaybeSafeIterRange->isEmpty(SE, LS.IsSignedPredicate) && - "We should never return empty ranges!"); + if (Result.hasValue()) { + auto MaybeSafeIterRange = + IntersectRange(SE, SafeIterRange, Result.getValue()); + if (MaybeSafeIterRange.hasValue()) { + assert( + !MaybeSafeIterRange.getValue().isEmpty(SE, LS.IsSignedPredicate) && + "We should never return empty ranges!"); RangeChecksToEliminate.push_back(IRC); - SafeIterRange = *MaybeSafeIterRange; + SafeIterRange = MaybeSafeIterRange.getValue(); } } } - if (!SafeIterRange) + if (!SafeIterRange.hasValue()) return false; - LoopConstrainer LC(*L, LI, LPMAddNewLoop, LS, SE, DT, *SafeIterRange); + LoopConstrainer LC(*L, LI, LPMAddNewLoop, LS, SE, DT, + SafeIterRange.getValue()); bool Changed = LC.run(); if (Changed) { diff --git a/llvm/lib/Transforms/Scalar/LoopDistribute.cpp b/llvm/lib/Transforms/Scalar/LoopDistribute.cpp index f70ab0d..f606e9b 100644 --- a/llvm/lib/Transforms/Scalar/LoopDistribute.cpp +++ b/llvm/lib/Transforms/Scalar/LoopDistribute.cpp @@ -600,9 +600,9 @@ private: {LLVMLoopDistributeFollowupAll, Part->hasDepCycle() ? LLVMLoopDistributeFollowupSequential : LLVMLoopDistributeFollowupCoincident}); - if (PartitionID) { + if (PartitionID.hasValue()) { Loop *NewLoop = Part->getDistributedLoop(); - NewLoop->setLoopID(*PartitionID); + NewLoop->setLoopID(PartitionID.getValue()); } } }; @@ -821,10 +821,12 @@ public: // The unversioned loop will not be changed, so we inherit all attributes // from the original loop, but remove the loop distribution metadata to // avoid to distribute it again. - MDNode *UnversionedLoopID = *makeFollowupLoopID( - OrigLoopID, - {LLVMLoopDistributeFollowupAll, LLVMLoopDistributeFollowupFallback}, - "llvm.loop.distribute.", true); + MDNode *UnversionedLoopID = + makeFollowupLoopID(OrigLoopID, + {LLVMLoopDistributeFollowupAll, + LLVMLoopDistributeFollowupFallback}, + "llvm.loop.distribute.", true) + .getValue(); LVer.getNonVersionedLoop()->setLoopID(UnversionedLoopID); } diff --git a/llvm/lib/Transforms/Scalar/LoopIdiomRecognize.cpp b/llvm/lib/Transforms/Scalar/LoopIdiomRecognize.cpp index 4bcf102..6d4c675 100644 --- a/llvm/lib/Transforms/Scalar/LoopIdiomRecognize.cpp +++ b/llvm/lib/Transforms/Scalar/LoopIdiomRecognize.cpp @@ -1481,9 +1481,9 @@ bool LoopIdiomRecognize::processLoopStoreOfLoopLoad( return Changed; // We cannot allow unaligned ops for unordered load/store, so reject // anything where the alignment isn't at least the element size. - assert((StoreAlign && LoadAlign) && + assert((StoreAlign.hasValue() && LoadAlign.hasValue()) && "Expect unordered load/store to have align."); - if (*StoreAlign < StoreSize || *LoadAlign < StoreSize) + if (StoreAlign.getValue() < StoreSize || LoadAlign.getValue() < StoreSize) return Changed; // If the element.atomic memcpy is not lowered into explicit @@ -1497,8 +1497,9 @@ bool LoopIdiomRecognize::processLoopStoreOfLoopLoad( // Note that unordered atomic loads/stores are *required* by the spec to // have an alignment but non-atomic loads/stores may not. NewCall = Builder.CreateElementUnorderedAtomicMemCpy( - StoreBasePtr, *StoreAlign, LoadBasePtr, *LoadAlign, NumBytes, StoreSize, - AATags.TBAA, AATags.TBAAStruct, AATags.Scope, AATags.NoAlias); + StoreBasePtr, StoreAlign.getValue(), LoadBasePtr, LoadAlign.getValue(), + NumBytes, StoreSize, AATags.TBAA, AATags.TBAAStruct, AATags.Scope, + AATags.NoAlias); } NewCall->setDebugLoc(TheStore->getDebugLoc()); diff --git a/llvm/lib/Transforms/Scalar/LoopRotation.cpp b/llvm/lib/Transforms/Scalar/LoopRotation.cpp index d9c33b5f..533c853 100644 --- a/llvm/lib/Transforms/Scalar/LoopRotation.cpp +++ b/llvm/lib/Transforms/Scalar/LoopRotation.cpp @@ -60,8 +60,8 @@ PreservedAnalyses LoopRotatePass::run(Loop &L, LoopAnalysisManager &AM, MSSAU = MemorySSAUpdater(AR.MSSA); bool Changed = LoopRotation(&L, &AR.LI, &AR.TTI, &AR.AC, &AR.DT, &AR.SE, - MSSAU ? MSSAU.getPointer() : nullptr, SQ, false, Threshold, - false, PrepareForLTO || PrepareForLTOOption); + MSSAU.hasValue() ? MSSAU.getPointer() : nullptr, SQ, false, + Threshold, false, PrepareForLTO || PrepareForLTOOption); if (!Changed) return PreservedAnalyses::all(); @@ -131,8 +131,9 @@ public: : MaxHeaderSize; return LoopRotation(L, LI, TTI, AC, &DT, &SE, - MSSAU ? MSSAU.getPointer() : nullptr, SQ, false, - Threshold, false, PrepareForLTO || PrepareForLTOOption); + MSSAU.hasValue() ? MSSAU.getPointer() : nullptr, SQ, + false, Threshold, false, + PrepareForLTO || PrepareForLTOOption); } }; } // end namespace diff --git a/llvm/lib/Transforms/Scalar/LoopSimplifyCFG.cpp b/llvm/lib/Transforms/Scalar/LoopSimplifyCFG.cpp index 51007b9..c2c29d9 100644 --- a/llvm/lib/Transforms/Scalar/LoopSimplifyCFG.cpp +++ b/llvm/lib/Transforms/Scalar/LoopSimplifyCFG.cpp @@ -735,9 +735,9 @@ public: if (MSSAA && VerifyMemorySSA) MSSAU->getMemorySSA()->verifyMemorySSA(); bool DeleteCurrentLoop = false; - bool Changed = - simplifyLoopCFG(*L, DT, LI, SE, MSSAU ? MSSAU.getPointer() : nullptr, - DeleteCurrentLoop); + bool Changed = simplifyLoopCFG( + *L, DT, LI, SE, MSSAU.hasValue() ? MSSAU.getPointer() : nullptr, + DeleteCurrentLoop); if (DeleteCurrentLoop) LPM.markLoopAsDeleted(*L); return Changed; diff --git a/llvm/lib/Transforms/Scalar/LoopStrengthReduce.cpp b/llvm/lib/Transforms/Scalar/LoopStrengthReduce.cpp index 49c3083..9959e40 100644 --- a/llvm/lib/Transforms/Scalar/LoopStrengthReduce.cpp +++ b/llvm/lib/Transforms/Scalar/LoopStrengthReduce.cpp @@ -6406,8 +6406,9 @@ static bool SalvageDVI(llvm::Loop *L, ScalarEvolution &SE, // less DWARF ops than an iteration count-based expression. if (Optional<APInt> Offset = SE.computeConstantDifference(DVIRec.SCEVs[i], SCEVInductionVar)) { - if (Offset->getMinSignedBits() <= 64) - SalvageExpr->createOffsetExpr(Offset->getSExtValue(), LSRInductionVar); + if (Offset.getValue().getMinSignedBits() <= 64) + SalvageExpr->createOffsetExpr(Offset.getValue().getSExtValue(), + LSRInductionVar); } else if (!SalvageExpr->createIterCountExpr(DVIRec.SCEVs[i], IterCountExpr, SE)) return false; diff --git a/llvm/lib/Transforms/Scalar/LoopUnrollAndJamPass.cpp b/llvm/lib/Transforms/Scalar/LoopUnrollAndJamPass.cpp index 8ea8f28..a33e5cc 100644 --- a/llvm/lib/Transforms/Scalar/LoopUnrollAndJamPass.cpp +++ b/llvm/lib/Transforms/Scalar/LoopUnrollAndJamPass.cpp @@ -372,8 +372,8 @@ tryToUnrollAndJamLoop(Loop *L, DominatorTree &DT, LoopInfo *LI, Optional<MDNode *> NewInnerEpilogueLoopID = makeFollowupLoopID( OrigOuterLoopID, {LLVMLoopUnrollAndJamFollowupAll, LLVMLoopUnrollAndJamFollowupRemainderInner}); - if (NewInnerEpilogueLoopID) - SubLoop->setLoopID(*NewInnerEpilogueLoopID); + if (NewInnerEpilogueLoopID.hasValue()) + SubLoop->setLoopID(NewInnerEpilogueLoopID.getValue()); // Find trip count and trip multiple BasicBlock *Latch = L->getLoopLatch(); @@ -402,15 +402,15 @@ tryToUnrollAndJamLoop(Loop *L, DominatorTree &DT, LoopInfo *LI, Optional<MDNode *> NewOuterEpilogueLoopID = makeFollowupLoopID( OrigOuterLoopID, {LLVMLoopUnrollAndJamFollowupAll, LLVMLoopUnrollAndJamFollowupRemainderOuter}); - if (NewOuterEpilogueLoopID) - EpilogueOuterLoop->setLoopID(*NewOuterEpilogueLoopID); + if (NewOuterEpilogueLoopID.hasValue()) + EpilogueOuterLoop->setLoopID(NewOuterEpilogueLoopID.getValue()); } Optional<MDNode *> NewInnerLoopID = makeFollowupLoopID(OrigOuterLoopID, {LLVMLoopUnrollAndJamFollowupAll, LLVMLoopUnrollAndJamFollowupInner}); - if (NewInnerLoopID) - SubLoop->setLoopID(*NewInnerLoopID); + if (NewInnerLoopID.hasValue()) + SubLoop->setLoopID(NewInnerLoopID.getValue()); else SubLoop->setLoopID(OrigSubLoopID); @@ -418,8 +418,8 @@ tryToUnrollAndJamLoop(Loop *L, DominatorTree &DT, LoopInfo *LI, Optional<MDNode *> NewOuterLoopID = makeFollowupLoopID( OrigOuterLoopID, {LLVMLoopUnrollAndJamFollowupAll, LLVMLoopUnrollAndJamFollowupOuter}); - if (NewOuterLoopID) { - L->setLoopID(*NewOuterLoopID); + if (NewOuterLoopID.hasValue()) { + L->setLoopID(NewOuterLoopID.getValue()); // Do not setLoopAlreadyUnrolled if a followup was given. return UnrollResult; diff --git a/llvm/lib/Transforms/Scalar/LoopUnrollPass.cpp b/llvm/lib/Transforms/Scalar/LoopUnrollPass.cpp index 08f21be..1969513 100644 --- a/llvm/lib/Transforms/Scalar/LoopUnrollPass.cpp +++ b/llvm/lib/Transforms/Scalar/LoopUnrollPass.cpp @@ -253,19 +253,19 @@ TargetTransformInfo::UnrollingPreferences llvm::gatherUnrollingPreferences( UP.MaxIterationsCountToAnalyze = UnrollMaxIterationsCountToAnalyze; // Apply user values provided by argument - if (UserThreshold) { + if (UserThreshold.hasValue()) { UP.Threshold = *UserThreshold; UP.PartialThreshold = *UserThreshold; } - if (UserCount) + if (UserCount.hasValue()) UP.Count = *UserCount; - if (UserAllowPartial) + if (UserAllowPartial.hasValue()) UP.Partial = *UserAllowPartial; - if (UserRuntime) + if (UserRuntime.hasValue()) UP.Runtime = *UserRuntime; - if (UserUpperBound) + if (UserUpperBound.hasValue()) UP.UpperBound = *UserUpperBound; - if (UserFullUnrollMaxCount) + if (UserFullUnrollMaxCount.hasValue()) UP.FullUnrollMaxCount = *UserFullUnrollMaxCount; return UP; @@ -1323,16 +1323,16 @@ static LoopUnrollResult tryToUnrollLoop( Optional<MDNode *> RemainderLoopID = makeFollowupLoopID(OrigLoopID, {LLVMLoopUnrollFollowupAll, LLVMLoopUnrollFollowupRemainder}); - if (RemainderLoopID) - RemainderLoop->setLoopID(*RemainderLoopID); + if (RemainderLoopID.hasValue()) + RemainderLoop->setLoopID(RemainderLoopID.getValue()); } if (UnrollResult != LoopUnrollResult::FullyUnrolled) { Optional<MDNode *> NewLoopID = makeFollowupLoopID(OrigLoopID, {LLVMLoopUnrollFollowupAll, LLVMLoopUnrollFollowupUnrolled}); - if (NewLoopID) { - L->setLoopID(*NewLoopID); + if (NewLoopID.hasValue()) { + L->setLoopID(NewLoopID.getValue()); // Do not setLoopAlreadyUnrolled if loop attributes have been specified // explicitly. @@ -1645,15 +1645,15 @@ void LoopUnrollPass::printPipeline( OS, MapClassName2PassName); OS << "<"; if (UnrollOpts.AllowPartial != None) - OS << (*UnrollOpts.AllowPartial ? "" : "no-") << "partial;"; + OS << (UnrollOpts.AllowPartial.getValue() ? "" : "no-") << "partial;"; if (UnrollOpts.AllowPeeling != None) - OS << (*UnrollOpts.AllowPeeling ? "" : "no-") << "peeling;"; + OS << (UnrollOpts.AllowPeeling.getValue() ? "" : "no-") << "peeling;"; if (UnrollOpts.AllowRuntime != None) - OS << (*UnrollOpts.AllowRuntime ? "" : "no-") << "runtime;"; + OS << (UnrollOpts.AllowRuntime.getValue() ? "" : "no-") << "runtime;"; if (UnrollOpts.AllowUpperBound != None) - OS << (*UnrollOpts.AllowUpperBound ? "" : "no-") << "upperbound;"; + OS << (UnrollOpts.AllowUpperBound.getValue() ? "" : "no-") << "upperbound;"; if (UnrollOpts.AllowProfileBasedPeeling != None) - OS << (*UnrollOpts.AllowProfileBasedPeeling ? "" : "no-") + OS << (UnrollOpts.AllowProfileBasedPeeling.getValue() ? "" : "no-") << "profile-peeling;"; if (UnrollOpts.FullUnrollMaxCount != None) OS << "full-unroll-max=" << UnrollOpts.FullUnrollMaxCount << ";"; diff --git a/llvm/lib/Transforms/Scalar/LowerConstantIntrinsics.cpp b/llvm/lib/Transforms/Scalar/LowerConstantIntrinsics.cpp index 47493b5..a886563 100644 --- a/llvm/lib/Transforms/Scalar/LowerConstantIntrinsics.cpp +++ b/llvm/lib/Transforms/Scalar/LowerConstantIntrinsics.cpp @@ -143,10 +143,10 @@ static bool lowerConstantIntrinsics(Function &F, const TargetLibraryInfo &TLI, break; } HasDeadBlocks |= replaceConditionalBranchesOnConstant( - II, NewValue, DTU ? DTU.getPointer() : nullptr); + II, NewValue, DTU.hasValue() ? DTU.getPointer() : nullptr); } if (HasDeadBlocks) - removeUnreachableBlocks(F, DTU ? DTU.getPointer() : nullptr); + removeUnreachableBlocks(F, DTU.hasValue() ? DTU.getPointer() : nullptr); return !Worklist.empty(); } diff --git a/llvm/lib/Transforms/Utils/CodeExtractor.cpp b/llvm/lib/Transforms/Utils/CodeExtractor.cpp index 8240386..c4ef979 100644 --- a/llvm/lib/Transforms/Utils/CodeExtractor.cpp +++ b/llvm/lib/Transforms/Utils/CodeExtractor.cpp @@ -1775,9 +1775,9 @@ CodeExtractor::extractCodeRegion(const CodeExtractorAnalysisCache &CEAC, // Update the entry count of the function. if (BFI) { auto Count = BFI->getProfileCountFromFreq(EntryFreq.getFrequency()); - if (Count) + if (Count.hasValue()) newFunction->setEntryCount( - ProfileCount(*Count, Function::PCT_Real)); // FIXME + ProfileCount(Count.getValue(), Function::PCT_Real)); // FIXME BFI->setBlockFreq(codeReplacer, EntryFreq.getFrequency()); } diff --git a/llvm/lib/Transforms/Utils/LoopPeel.cpp b/llvm/lib/Transforms/Utils/LoopPeel.cpp index f093fea..7f0852c 100644 --- a/llvm/lib/Transforms/Utils/LoopPeel.cpp +++ b/llvm/lib/Transforms/Utils/LoopPeel.cpp @@ -719,9 +719,9 @@ TargetTransformInfo::PeelingPreferences llvm::gatherPeelingPreferences( } // User specifed values provided by argument. - if (UserAllowPeeling) + if (UserAllowPeeling.hasValue()) PP.AllowPeeling = *UserAllowPeeling; - if (UserAllowProfileBasedPeeling) + if (UserAllowProfileBasedPeeling.hasValue()) PP.PeelProfiledIterations = *UserAllowProfileBasedPeeling; return PP; diff --git a/llvm/lib/Transforms/Utils/LoopUnrollRuntime.cpp b/llvm/lib/Transforms/Utils/LoopUnrollRuntime.cpp index 295ae03..df24af5 100644 --- a/llvm/lib/Transforms/Utils/LoopUnrollRuntime.cpp +++ b/llvm/lib/Transforms/Utils/LoopUnrollRuntime.cpp @@ -397,8 +397,8 @@ CloneLoopBlocks(Loop *L, Value *NewIter, const bool UseEpilogRemainder, Optional<MDNode *> NewLoopID = makeFollowupLoopID( LoopID, {LLVMLoopUnrollFollowupAll, LLVMLoopUnrollFollowupRemainder}); - if (NewLoopID) { - NewLoop->setLoopID(*NewLoopID); + if (NewLoopID.hasValue()) { + NewLoop->setLoopID(NewLoopID.getValue()); // Do not setLoopAlreadyUnrolled if loop attributes have been defined // explicitly. diff --git a/llvm/lib/Transforms/Utils/LoopUtils.cpp b/llvm/lib/Transforms/Utils/LoopUtils.cpp index 7dc94d8..b7656f4 100644 --- a/llvm/lib/Transforms/Utils/LoopUtils.cpp +++ b/llvm/lib/Transforms/Utils/LoopUtils.cpp @@ -358,8 +358,8 @@ TransformationMode llvm::hasUnrollTransformation(const Loop *L) { Optional<int> Count = getOptionalIntLoopAttribute(L, "llvm.loop.unroll.count"); - if (Count) - return *Count == 1 ? TM_SuppressedByUser : TM_ForcedByUser; + if (Count.hasValue()) + return Count.getValue() == 1 ? TM_SuppressedByUser : TM_ForcedByUser; if (getBooleanLoopAttribute(L, "llvm.loop.unroll.enable")) return TM_ForcedByUser; @@ -379,8 +379,8 @@ TransformationMode llvm::hasUnrollAndJamTransformation(const Loop *L) { Optional<int> Count = getOptionalIntLoopAttribute(L, "llvm.loop.unroll_and_jam.count"); - if (Count) - return *Count == 1 ? TM_SuppressedByUser : TM_ForcedByUser; + if (Count.hasValue()) + return Count.getValue() == 1 ? TM_SuppressedByUser : TM_ForcedByUser; if (getBooleanLoopAttribute(L, "llvm.loop.unroll_and_jam.enable")) return TM_ForcedByUser; diff --git a/llvm/lib/Transforms/Utils/MisExpect.cpp b/llvm/lib/Transforms/Utils/MisExpect.cpp index a7acd8d..5ace0c6 100644 --- a/llvm/lib/Transforms/Utils/MisExpect.cpp +++ b/llvm/lib/Transforms/Utils/MisExpect.cpp @@ -219,18 +219,18 @@ void verifyMisExpect(Instruction &I, ArrayRef<uint32_t> RealWeights, void checkBackendInstrumentation(Instruction &I, const ArrayRef<uint32_t> RealWeights) { auto ExpectedWeightsOpt = extractWeights(&I, I.getContext()); - if (!ExpectedWeightsOpt) + if (!ExpectedWeightsOpt.hasValue()) return; - auto ExpectedWeights = *ExpectedWeightsOpt; + auto ExpectedWeights = ExpectedWeightsOpt.getValue(); verifyMisExpect(I, RealWeights, ExpectedWeights); } void checkFrontendInstrumentation(Instruction &I, const ArrayRef<uint32_t> ExpectedWeights) { auto RealWeightsOpt = extractWeights(&I, I.getContext()); - if (!RealWeightsOpt) + if (!RealWeightsOpt.hasValue()) return; - auto RealWeights = *RealWeightsOpt; + auto RealWeights = RealWeightsOpt.getValue(); verifyMisExpect(I, RealWeights, ExpectedWeights); } diff --git a/llvm/lib/Transforms/Utils/ModuleUtils.cpp b/llvm/lib/Transforms/Utils/ModuleUtils.cpp index 694837a..7388a4b 100644 --- a/llvm/lib/Transforms/Utils/ModuleUtils.cpp +++ b/llvm/lib/Transforms/Utils/ModuleUtils.cpp @@ -254,8 +254,8 @@ void VFABI::setVectorVariantNames(CallInst *CI, for (const std::string &VariantMapping : VariantMappings) { LLVM_DEBUG(dbgs() << "VFABI: adding mapping '" << VariantMapping << "'\n"); Optional<VFInfo> VI = VFABI::tryDemangleForVFABI(VariantMapping, *M); - assert(VI && "Cannot add an invalid VFABI name."); - assert(M->getNamedValue(VI->VectorName) && + assert(VI.hasValue() && "Cannot add an invalid VFABI name."); + assert(M->getNamedValue(VI.getValue().VectorName) && "Cannot add variant to attribute: " "vector function declaration is missing."); } diff --git a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp index 8ab7fc0..5e7a762 100644 --- a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp +++ b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp @@ -4877,8 +4877,8 @@ LoopVectorizationCostModel::getMaxLegalScalableVF(unsigned MaxSafeElements) { if (!MaxVScale && TheFunction->hasFnAttribute(Attribute::VScaleRange)) MaxVScale = TheFunction->getFnAttribute(Attribute::VScaleRange).getVScaleRangeMax(); - MaxScalableVF = - ElementCount::getScalable(MaxVScale ? (MaxSafeElements / *MaxVScale) : 0); + MaxScalableVF = ElementCount::getScalable( + MaxVScale ? (MaxSafeElements / MaxVScale.getValue()) : 0); if (!MaxScalableVF) reportVectorizationInfo( "Max legal vector width too small, scalable vectorization " @@ -5273,9 +5273,9 @@ bool LoopVectorizationCostModel::isMoreProfitable( unsigned EstimatedWidthB = B.Width.getKnownMinValue(); if (Optional<unsigned> VScale = getVScaleForTuning()) { if (A.Width.isScalable()) - EstimatedWidthA *= *VScale; + EstimatedWidthA *= VScale.getValue(); if (B.Width.isScalable()) - EstimatedWidthB *= *VScale; + EstimatedWidthB *= VScale.getValue(); } // Assume vscale may be larger than 1 (or the value being tuned for), @@ -7612,8 +7612,8 @@ void LoopVectorizationPlanner::executePlan(ElementCount BestVF, unsigned BestUF, VPBasicBlock *HeaderVPBB = BestVPlan.getVectorLoopRegion()->getEntryBasicBlock(); Loop *L = LI->getLoopFor(State.CFG.VPBB2IRBB[HeaderVPBB]); - if (VectorizedLoopID) - L->setLoopID(*VectorizedLoopID); + if (VectorizedLoopID.hasValue()) + L->setLoopID(VectorizedLoopID.getValue()); else { // Keep all loop hints from the original loop on the vector loop (we'll // replace the vectorizer-specific hints below). @@ -10622,8 +10622,8 @@ bool LoopVectorizePass::processLoop(Loop *L) { Optional<MDNode *> RemainderLoopID = makeFollowupLoopID(OrigLoopID, {LLVMLoopVectorizeFollowupAll, LLVMLoopVectorizeFollowupEpilogue}); - if (RemainderLoopID) { - L->setLoopID(*RemainderLoopID); + if (RemainderLoopID.hasValue()) { + L->setLoopID(RemainderLoopID.getValue()); } else { if (DisableRuntimeUnroll) AddRuntimeUnrollDisableMetaData(L); diff --git a/llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp b/llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp index a9bccbc..d7769ef 100644 --- a/llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp +++ b/llvm/lib/Transforms/Vectorize/SLPVectorizer.cpp @@ -2636,8 +2636,8 @@ private: // First check if the result is already in the cache. AliasCacheKey key = std::make_pair(Inst1, Inst2); Optional<bool> &result = AliasCache[key]; - if (result) { - return *result; + if (result.hasValue()) { + return result.getValue(); } bool aliased = true; if (Loc1.Ptr && isSimple(Inst1)) diff --git a/llvm/lib/WindowsDriver/MSVCPaths.cpp b/llvm/lib/WindowsDriver/MSVCPaths.cpp index 0661ed7..46a4426b 100644 --- a/llvm/lib/WindowsDriver/MSVCPaths.cpp +++ b/llvm/lib/WindowsDriver/MSVCPaths.cpp @@ -98,14 +98,14 @@ static bool getWindowsSDKDirViaCommandLine( llvm::Optional<llvm::StringRef> WinSdkVersion, llvm::Optional<llvm::StringRef> WinSysRoot, std::string &Path, int &Major, std::string &Version) { - if (WinSdkDir || WinSysRoot) { + if (WinSdkDir.hasValue() || WinSysRoot.hasValue()) { // Don't validate the input; trust the value supplied by the user. // The motivation is to prevent unnecessary file and registry access. llvm::VersionTuple SDKVersion; - if (WinSdkVersion) + if (WinSdkVersion.hasValue()) SDKVersion.tryParse(*WinSdkVersion); - if (WinSysRoot) { + if (WinSysRoot.hasValue()) { llvm::SmallString<128> SDKPath(*WinSysRoot); llvm::sys::path::append(SDKPath, "Windows Kits"); if (!SDKVersion.empty()) @@ -479,12 +479,12 @@ bool findVCToolChainViaCommandLine(vfs::FileSystem &VFS, std::string &Path, ToolsetLayout &VSLayout) { // Don't validate the input; trust the value supplied by the user. // The primary motivation is to prevent unnecessary file and registry access. - if (VCToolsDir || WinSysRoot) { - if (WinSysRoot) { + if (VCToolsDir.hasValue() || WinSysRoot.hasValue()) { + if (WinSysRoot.hasValue()) { SmallString<128> ToolsPath(*WinSysRoot); sys::path::append(ToolsPath, "VC", "Tools", "MSVC"); std::string ToolsVersion; - if (VCToolsVersion) + if (VCToolsVersion.hasValue()) ToolsVersion = VCToolsVersion->str(); else ToolsVersion = getHighestNumericTupleInDirectory(VFS, ToolsPath); diff --git a/llvm/tools/lli/lli.cpp b/llvm/tools/lli/lli.cpp index 2bc7391..f2e3886 100644 --- a/llvm/tools/lli/lli.cpp +++ b/llvm/tools/lli/lli.cpp @@ -536,9 +536,9 @@ int main(int argc, char **argv, char * const *envp) { builder.setMCPU(codegen::getCPUStr()); builder.setMAttrs(codegen::getFeatureList()); if (auto RM = codegen::getExplicitRelocModel()) - builder.setRelocationModel(RM.value()); + builder.setRelocationModel(RM.getValue()); if (auto CM = codegen::getExplicitCodeModel()) - builder.setCodeModel(CM.value()); + builder.setCodeModel(CM.getValue()); builder.setErrorStr(&ErrorMsg); builder.setEngineKind(ForceInterpreter ? EngineKind::Interpreter diff --git a/llvm/tools/llvm-cov/CoverageExporterJson.cpp b/llvm/tools/llvm-cov/CoverageExporterJson.cpp index 2e161f5..d341abe 100644 --- a/llvm/tools/llvm-cov/CoverageExporterJson.cpp +++ b/llvm/tools/llvm-cov/CoverageExporterJson.cpp @@ -291,8 +291,8 @@ void CoverageExporterJson::renderRoot(ArrayRef<std::string> SourceFiles) { const json::Object *ObjB = B.getAsObject(); assert(ObjA != nullptr && "Value A was not an Object"); assert(ObjB != nullptr && "Value B was not an Object"); - const StringRef FilenameA = ObjA->getString("filename").value(); - const StringRef FilenameB = ObjB->getString("filename").value(); + const StringRef FilenameA = ObjA->getString("filename").getValue(); + const StringRef FilenameB = ObjB->getString("filename").getValue(); return FilenameA.compare(FilenameB) < 0; }); auto Export = json::Object( diff --git a/llvm/tools/llvm-cov/SourceCoverageViewHTML.cpp b/llvm/tools/llvm-cov/SourceCoverageViewHTML.cpp index 46782c9..f38eb00 100644 --- a/llvm/tools/llvm-cov/SourceCoverageViewHTML.cpp +++ b/llvm/tools/llvm-cov/SourceCoverageViewHTML.cpp @@ -561,12 +561,12 @@ void SourceCoverageViewHTML::renderLine(raw_ostream &OS, LineRef L, else Color = None; - if (Color) + if (Color.hasValue()) Snippets[I + 1] = Highlight(Snippets[I + 1], CurSeg->Col, CurSeg->Col + Snippets[I + 1].size()); } - if (Color && Segments.empty()) + if (Color.hasValue() && Segments.empty()) Snippets.back() = Highlight(Snippets.back(), 1, 1 + Snippets.back().size()); if (getOptions().Debug) { diff --git a/llvm/tools/llvm-exegesis/lib/MCInstrDescView.cpp b/llvm/tools/llvm-exegesis/lib/MCInstrDescView.cpp index 0ad6645..049cc68 100644 --- a/llvm/tools/llvm-exegesis/lib/MCInstrDescView.cpp +++ b/llvm/tools/llvm-exegesis/lib/MCInstrDescView.cpp @@ -47,9 +47,9 @@ bool Operand::isUse() const { return !IsDef; } bool Operand::isReg() const { return Tracker; } -bool Operand::isTied() const { return TiedToIndex.has_value(); } +bool Operand::isTied() const { return TiedToIndex.hasValue(); } -bool Operand::isVariable() const { return VariableIndex.has_value(); } +bool Operand::isVariable() const { return VariableIndex.hasValue(); } bool Operand::isMemory() const { return isExplicit() && diff --git a/llvm/tools/llvm-ifs/llvm-ifs.cpp b/llvm/tools/llvm-ifs/llvm-ifs.cpp index 6909bd1..f9b6a8c 100644 --- a/llvm/tools/llvm-ifs/llvm-ifs.cpp +++ b/llvm/tools/llvm-ifs/llvm-ifs.cpp @@ -533,33 +533,34 @@ int main(int argc, char *argv[]) { << "Triple should be defined when output format is TBD"; return -1; } - return writeTbdStub(llvm::Triple(Stub.Target.Triple.value()), + return writeTbdStub(llvm::Triple(Stub.Target.Triple.getValue()), Stub.Symbols, "TBD", Out); } case FileFormat::IFS: { Stub.IfsVersion = IfsVersionCurrent; - if (Config.InputFormat.value() == FileFormat::ELF && + if (Config.InputFormat.getValue() == FileFormat::ELF && Config.HintIfsTarget) { std::error_code HintEC(1, std::generic_category()); IFSTarget HintTarget = parseTriple(*Config.HintIfsTarget); - if (Stub.Target.Arch.value() != HintTarget.Arch.value()) + if (Stub.Target.Arch.getValue() != HintTarget.Arch.getValue()) fatalError(make_error<StringError>( "Triple hint does not match the actual architecture", HintEC)); - if (Stub.Target.Endianness.value() != HintTarget.Endianness.value()) + if (Stub.Target.Endianness.getValue() != + HintTarget.Endianness.getValue()) fatalError(make_error<StringError>( "Triple hint does not match the actual endianness", HintEC)); - if (Stub.Target.BitWidth.value() != HintTarget.BitWidth.value()) + if (Stub.Target.BitWidth.getValue() != HintTarget.BitWidth.getValue()) fatalError(make_error<StringError>( "Triple hint does not match the actual bit width", HintEC)); stripIFSTarget(Stub, true, false, false, false); - Stub.Target.Triple = Config.HintIfsTarget.value(); + Stub.Target.Triple = Config.HintIfsTarget.getValue(); } else { stripIFSTarget(Stub, Config.StripIfsTarget, Config.StripIfsArch, Config.StripIfsEndianness, Config.StripIfsBitwidth); } Error IFSWriteError = - writeIFS(Config.Output.value(), Stub, Config.WriteIfChanged); + writeIFS(Config.Output.getValue(), Stub, Config.WriteIfChanged); if (IFSWriteError) fatalError(std::move(IFSWriteError)); break; @@ -588,28 +589,29 @@ int main(int argc, char *argv[]) { } if (Config.OutputIfs) { Stub.IfsVersion = IfsVersionCurrent; - if (Config.InputFormat.value() == FileFormat::ELF && + if (Config.InputFormat.getValue() == FileFormat::ELF && Config.HintIfsTarget) { std::error_code HintEC(1, std::generic_category()); IFSTarget HintTarget = parseTriple(*Config.HintIfsTarget); - if (Stub.Target.Arch.value() != HintTarget.Arch.value()) + if (Stub.Target.Arch.getValue() != HintTarget.Arch.getValue()) fatalError(make_error<StringError>( "Triple hint does not match the actual architecture", HintEC)); - if (Stub.Target.Endianness.value() != HintTarget.Endianness.value()) + if (Stub.Target.Endianness.getValue() != + HintTarget.Endianness.getValue()) fatalError(make_error<StringError>( "Triple hint does not match the actual endianness", HintEC)); - if (Stub.Target.BitWidth.value() != HintTarget.BitWidth.value()) + if (Stub.Target.BitWidth.getValue() != HintTarget.BitWidth.getValue()) fatalError(make_error<StringError>( "Triple hint does not match the actual bit width", HintEC)); stripIFSTarget(Stub, true, false, false, false); - Stub.Target.Triple = Config.HintIfsTarget.value(); + Stub.Target.Triple = Config.HintIfsTarget.getValue(); } else { stripIFSTarget(Stub, Config.StripIfsTarget, Config.StripIfsArch, Config.StripIfsEndianness, Config.StripIfsBitwidth); } Error IFSWriteError = - writeIFS(Config.OutputIfs.value(), Stub, Config.WriteIfChanged); + writeIFS(Config.OutputIfs.getValue(), Stub, Config.WriteIfChanged); if (IFSWriteError) fatalError(std::move(IFSWriteError)); } @@ -626,8 +628,8 @@ int main(int argc, char *argv[]) { << "Triple should be defined when output format is TBD"; return -1; } - return writeTbdStub(llvm::Triple(*Stub.Target.Triple), Stub.Symbols, - "TBD", Out); + return writeTbdStub(llvm::Triple(Stub.Target.Triple.getValue()), + Stub.Symbols, "TBD", Out); } } return 0; diff --git a/llvm/tools/llvm-mca/Views/InstructionInfoView.cpp b/llvm/tools/llvm-mca/Views/InstructionInfoView.cpp index d3f9738..28915e5 100644 --- a/llvm/tools/llvm-mca/Views/InstructionInfoView.cpp +++ b/llvm/tools/llvm-mca/Views/InstructionInfoView.cpp @@ -70,8 +70,8 @@ void InstructionInfoView::printView(raw_ostream &OS) const { else if (IIVDEntry.Latency < 100) TempStream << ' '; - if (IIVDEntry.RThroughput) { - double RT = IIVDEntry.RThroughput.value(); + if (IIVDEntry.RThroughput.hasValue()) { + double RT = IIVDEntry.RThroughput.getValue(); TempStream << format("%.2f", RT) << ' '; if (RT < 10.0) TempStream << " "; diff --git a/llvm/tools/llvm-objdump/XCOFFDump.cpp b/llvm/tools/llvm-objdump/XCOFFDump.cpp index befc9c0..159741b 100644 --- a/llvm/tools/llvm-objdump/XCOFFDump.cpp +++ b/llvm/tools/llvm-objdump/XCOFFDump.cpp @@ -97,8 +97,8 @@ std::string objdump::getXCOFFSymbolDescription(const SymbolInfoTy &SymbolInfo, std::string Result; // Dummy symbols have no symbol index. if (SymbolInfo.XCOFFSymInfo.Index) - Result = ("(idx: " + Twine(SymbolInfo.XCOFFSymInfo.Index.value()) + ") " + - SymbolName) + Result = ("(idx: " + Twine(SymbolInfo.XCOFFSymInfo.Index.getValue()) + + ") " + SymbolName) .str(); else Result.append(SymbolName.begin(), SymbolName.end()); diff --git a/llvm/tools/llvm-objdump/llvm-objdump.cpp b/llvm/tools/llvm-objdump/llvm-objdump.cpp index e95e745..42c3820 100644 --- a/llvm/tools/llvm-objdump/llvm-objdump.cpp +++ b/llvm/tools/llvm-objdump/llvm-objdump.cpp @@ -1408,8 +1408,8 @@ static void disassembleObject(const Target *TheTarget, const ObjectFile *Obj, // Right now, most targets return None i.e ignore to treat a symbol // separately. But WebAssembly decodes preludes for some symbols. // - if (Status) { - if (*Status == MCDisassembler::Fail) { + if (Status.hasValue()) { + if (Status.getValue() == MCDisassembler::Fail) { outs() << "// Error in decoding " << SymbolName << " : Decoding failed region as bytes.\n"; for (uint64_t I = 0; I < Size; ++I) { @@ -2139,8 +2139,8 @@ void objdump::printSymbol(const ObjectFile *O, const SymbolRef &Symbol, SymName = demangle(SymName); if (SymbolDescription) - SymName = getXCOFFSymbolDescription(createSymbolInfo(O, *SymRef), - SymName); + SymName = getXCOFFSymbolDescription( + createSymbolInfo(O, SymRef.getValue()), SymName); outs() << ' ' << SymName; outs() << ") "; @@ -2247,8 +2247,8 @@ static void printRawClangAST(const ObjectFile *Obj) { if (!ClangASTSection) return; - StringRef ClangASTContents = - unwrapOrError(ClangASTSection->getContents(), Obj->getFileName()); + StringRef ClangASTContents = unwrapOrError( + ClangASTSection.getValue().getContents(), Obj->getFileName()); outs().write(ClangASTContents.data(), ClangASTContents.size()); } diff --git a/llvm/tools/llvm-profdata/llvm-profdata.cpp b/llvm/tools/llvm-profdata/llvm-profdata.cpp index 9c65864..11387ac 100644 --- a/llvm/tools/llvm-profdata/llvm-profdata.cpp +++ b/llvm/tools/llvm-profdata/llvm-profdata.cpp @@ -777,12 +777,12 @@ mergeSampleProfile(const WeightedFileVector &Inputs, SymbolRemapper *Remapper, } SampleProfileMap &Profiles = Reader->getProfiles(); - if (ProfileIsProbeBased && + if (ProfileIsProbeBased.hasValue() && ProfileIsProbeBased != FunctionSamples::ProfileIsProbeBased) exitWithError( "cannot merge probe-based profile with non-probe-based profile"); ProfileIsProbeBased = FunctionSamples::ProfileIsProbeBased; - if (ProfileIsCS && ProfileIsCS != FunctionSamples::ProfileIsCS) + if (ProfileIsCS.hasValue() && ProfileIsCS != FunctionSamples::ProfileIsCS) exitWithError("cannot merge CS profile with non-CS profile"); ProfileIsCS = FunctionSamples::ProfileIsCS; for (SampleProfileMap::iterator I = Profiles.begin(), E = Profiles.end(); diff --git a/llvm/tools/llvm-profgen/ProfiledBinary.cpp b/llvm/tools/llvm-profgen/ProfiledBinary.cpp index aaf7a00..adf7770 100644 --- a/llvm/tools/llvm-profgen/ProfiledBinary.cpp +++ b/llvm/tools/llvm-profgen/ProfiledBinary.cpp @@ -100,25 +100,26 @@ BinarySizeContextTracker::getFuncSizeForContext(const SampleContext &Context) { PrevNode = CurrNode; CurrNode = CurrNode->getChildContext(ChildFrame.Location, ChildFrame.FuncName); - if (CurrNode && CurrNode->getFunctionSize()) - Size = CurrNode->getFunctionSize().value(); + if (CurrNode && CurrNode->getFunctionSize().hasValue()) + Size = CurrNode->getFunctionSize().getValue(); } // If we traversed all nodes along the path of the context and haven't // found a size yet, pivot to look for size from sibling nodes, i.e size // of inlinee under different context. - if (!Size) { + if (!Size.hasValue()) { if (!CurrNode) CurrNode = PrevNode; - while (!Size && CurrNode && !CurrNode->getAllChildContext().empty()) { + while (!Size.hasValue() && CurrNode && + !CurrNode->getAllChildContext().empty()) { CurrNode = &CurrNode->getAllChildContext().begin()->second; - if (CurrNode->getFunctionSize()) - Size = CurrNode->getFunctionSize().value(); + if (CurrNode->getFunctionSize().hasValue()) + Size = CurrNode->getFunctionSize().getValue(); } } - assert(Size && "We should at least find one context size."); - return Size.value(); + assert(Size.hasValue() && "We should at least find one context size."); + return Size.getValue(); } void BinarySizeContextTracker::trackInlineesOptimizedAway( diff --git a/llvm/tools/llvm-sim/llvm-sim.cpp b/llvm/tools/llvm-sim/llvm-sim.cpp index 2b717d7..26e370f 100644 --- a/llvm/tools/llvm-sim/llvm-sim.cpp +++ b/llvm/tools/llvm-sim/llvm-sim.cpp @@ -85,13 +85,14 @@ exportToFile(const StringRef FilePath, Optional<unsigned> End = getPositionInModule((*C.back()).Inst, LLVMInstNum); - assert(Start && + assert(Start.hasValue() && "Could not find instruction number for first instruction"); - assert(End && "Could not find instruction number for last instruction"); + assert(End.hasValue() && + "Could not find instruction number for last instruction"); J.object([&] { - J.attribute("start", Start.value()); - J.attribute("end", End.value()); + J.attribute("start", Start.getValue()); + J.attribute("end", End.getValue()); }); } J.arrayEnd(); diff --git a/llvm/tools/obj2yaml/dwarf2yaml.cpp b/llvm/tools/obj2yaml/dwarf2yaml.cpp index 4436cef..c0c23ea 100644 --- a/llvm/tools/obj2yaml/dwarf2yaml.cpp +++ b/llvm/tools/obj2yaml/dwarf2yaml.cpp @@ -247,15 +247,15 @@ void dumpDebugInfo(DWARFContext &DCtx, DWARFYAML::Data &Y) { auto FormValue = DIEWrapper.find(AttrSpec.Attr); if (!FormValue) return; - auto Form = FormValue->getForm(); + auto Form = FormValue.getValue().getForm(); bool indirect = false; do { indirect = false; switch (Form) { case dwarf::DW_FORM_addr: case dwarf::DW_FORM_GNU_addr_index: - if (auto Val = FormValue->getAsAddress()) - NewValue.Value = Val.value(); + if (auto Val = FormValue.getValue().getAsAddress()) + NewValue.Value = Val.getValue(); break; case dwarf::DW_FORM_ref_addr: case dwarf::DW_FORM_ref1: @@ -264,16 +264,16 @@ void dumpDebugInfo(DWARFContext &DCtx, DWARFYAML::Data &Y) { case dwarf::DW_FORM_ref8: case dwarf::DW_FORM_ref_udata: case dwarf::DW_FORM_ref_sig8: - if (auto Val = FormValue->getAsReferenceUVal()) - NewValue.Value = Val.value(); + if (auto Val = FormValue.getValue().getAsReferenceUVal()) + NewValue.Value = Val.getValue(); break; case dwarf::DW_FORM_exprloc: case dwarf::DW_FORM_block: case dwarf::DW_FORM_block1: case dwarf::DW_FORM_block2: case dwarf::DW_FORM_block4: - if (auto Val = FormValue->getAsBlock()) { - auto BlockData = Val.value(); + if (auto Val = FormValue.getValue().getAsBlock()) { + auto BlockData = Val.getValue(); std::copy(BlockData.begin(), BlockData.end(), std::back_inserter(NewValue.BlockData)); } @@ -288,8 +288,8 @@ void dumpDebugInfo(DWARFContext &DCtx, DWARFYAML::Data &Y) { case dwarf::DW_FORM_udata: case dwarf::DW_FORM_ref_sup4: case dwarf::DW_FORM_ref_sup8: - if (auto Val = FormValue->getAsUnsignedConstant()) - NewValue.Value = Val.value(); + if (auto Val = FormValue.getValue().getAsUnsignedConstant()) + NewValue.Value = Val.getValue(); break; case dwarf::DW_FORM_string: if (auto Val = dwarf::toString(FormValue)) @@ -297,10 +297,10 @@ void dumpDebugInfo(DWARFContext &DCtx, DWARFYAML::Data &Y) { break; case dwarf::DW_FORM_indirect: indirect = true; - if (auto Val = FormValue->getAsUnsignedConstant()) { - NewValue.Value = Val.value(); + if (auto Val = FormValue.getValue().getAsUnsignedConstant()) { + NewValue.Value = Val.getValue(); NewEntry.Values.push_back(NewValue); - Form = static_cast<dwarf::Form>(Val.value()); + Form = static_cast<dwarf::Form>(Val.getValue()); } break; case dwarf::DW_FORM_strp: @@ -311,8 +311,8 @@ void dumpDebugInfo(DWARFContext &DCtx, DWARFYAML::Data &Y) { case dwarf::DW_FORM_strp_sup: case dwarf::DW_FORM_GNU_str_index: case dwarf::DW_FORM_strx: - if (auto Val = FormValue->getAsCStringOffset()) - NewValue.Value = Val.value(); + if (auto Val = FormValue.getValue().getAsCStringOffset()) + NewValue.Value = Val.getValue(); break; case dwarf::DW_FORM_flag_present: NewValue.Value = 1; diff --git a/llvm/tools/obj2yaml/dxcontainer2yaml.cpp b/llvm/tools/obj2yaml/dxcontainer2yaml.cpp index 122ae7d..a57b8cf 100644 --- a/llvm/tools/obj2yaml/dxcontainer2yaml.cpp +++ b/llvm/tools/obj2yaml/dxcontainer2yaml.cpp @@ -40,8 +40,8 @@ dumpDXContainer(MemoryBufferRef Source) { Obj->Header.PartOffsets->push_back(P.Offset); if (P.Part.getName() == "DXIL") { Optional<DXContainer::DXILData> DXIL = Container.getDXIL(); - assert(DXIL && "Since we are iterating and found a DXIL part, " - "this should never not have a value"); + assert(DXIL.hasValue() && "Since we are iterating and found a DXIL part, " + "this should never not have a value"); Obj->Parts.push_back(DXContainerYAML::Part{ P.Part.getName().str(), P.Part.Size, DXContainerYAML::DXILProgram{ diff --git a/llvm/unittests/ADT/OptionalTest.cpp b/llvm/unittests/ADT/OptionalTest.cpp index 94032c6..f88437f 100644 --- a/llvm/unittests/ADT/OptionalTest.cpp +++ b/llvm/unittests/ADT/OptionalTest.cpp @@ -29,13 +29,13 @@ void OptionalWorksInConstexpr() { constexpr Optional<int> x2{}; static_assert(!x1.has_value() && !x2.has_value(), "Default construction and hasValue() are contexpr"); - static_assert(!x1.has_value() && !x2.has_value(), + static_assert(!x1.hasValue() && !x2.hasValue(), "Default construction and hasValue() are contexpr"); constexpr auto y1 = Optional<int>(3); constexpr Optional<int> y2{3}; static_assert(y1.value() == y2.value() && y1.value() == 3, "Construction with value and getValue() are constexpr"); - static_assert(y1.value() == *y2 && *y1 == 3, + static_assert(y1.getValue() == y2.getValue() && y1.getValue() == 3, "Construction with value and getValue() are constexpr"); static_assert(Optional<int>{3} >= 2 && Optional<int>{1} < Optional<int>{2}, "Comparisons work in constexpr"); @@ -252,14 +252,14 @@ TEST(OptionalTest, Emplace) { A.emplace(1, 2); EXPECT_TRUE(A.has_value()); - EXPECT_TRUE(A.has_value()); + EXPECT_TRUE(A.hasValue()); 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.has_value()); + EXPECT_TRUE(A.hasValue()); 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.has_value()); + EXPECT_TRUE(A.hasValue()); 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.has_value()); + EXPECT_TRUE(B.hasValue()); EXPECT_EQ(5, B->x); EXPECT_EQ(-5, B->y); EXPECT_EQ(0u, MultiArgConstructor::Destructions); diff --git a/llvm/unittests/ADT/StatisticTest.cpp b/llvm/unittests/ADT/StatisticTest.cpp index 523f510..17d9911 100644 --- a/llvm/unittests/ADT/StatisticTest.cpp +++ b/llvm/unittests/ADT/StatisticTest.cpp @@ -92,8 +92,8 @@ TEST(StatisticTest, API) { OptionalStatistic S2; extractCounters(Range1, S1, S2); - EXPECT_EQ(S1.has_value(), true); - EXPECT_EQ(S2.has_value(), false); + EXPECT_EQ(S1.hasValue(), true); + EXPECT_EQ(S2.hasValue(), 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.has_value(), true); - EXPECT_EQ(S2.has_value(), true); + EXPECT_EQ(S1.hasValue(), true); + EXPECT_EQ(S2.hasValue(), 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.has_value(), false); - EXPECT_EQ(S2.has_value(), false); + EXPECT_EQ(S1.hasValue(), false); + EXPECT_EQ(S2.hasValue(), 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.has_value(), true); - EXPECT_EQ(S2.has_value(), true); + EXPECT_EQ(S1.hasValue(), true); + EXPECT_EQ(S2.hasValue(), true); EXPECT_EQ(S1->first, "Counter"); EXPECT_EQ(S1->second, 1u); diff --git a/llvm/unittests/Analysis/BlockFrequencyInfoTest.cpp b/llvm/unittests/Analysis/BlockFrequencyInfoTest.cpp index 91009ab..5dd3995 100644 --- a/llvm/unittests/Analysis/BlockFrequencyInfoTest.cpp +++ b/llvm/unittests/Analysis/BlockFrequencyInfoTest.cpp @@ -75,11 +75,11 @@ TEST_F(BlockFrequencyInfoTest, Basic) { EXPECT_EQ(BB0Freq, BB1Freq + BB2Freq); EXPECT_EQ(BB0Freq, BB3Freq); - EXPECT_EQ(BFI.getBlockProfileCount(&BB0).value(), UINT64_C(100)); - EXPECT_EQ(BFI.getBlockProfileCount(BB3).value(), UINT64_C(100)); - EXPECT_EQ(BFI.getBlockProfileCount(BB1).value(), + EXPECT_EQ(BFI.getBlockProfileCount(&BB0).getValue(), UINT64_C(100)); + EXPECT_EQ(BFI.getBlockProfileCount(BB3).getValue(), UINT64_C(100)); + EXPECT_EQ(BFI.getBlockProfileCount(BB1).getValue(), (100 * BB1Freq + BB0Freq / 2) / BB0Freq); - EXPECT_EQ(BFI.getBlockProfileCount(BB2).value(), + EXPECT_EQ(BFI.getBlockProfileCount(BB2).getValue(), (100 * BB2Freq + BB0Freq / 2) / BB0Freq); // Scale the frequencies of BB0, BB1 and BB2 by a factor of two. diff --git a/llvm/unittests/Analysis/IRSimilarityIdentifierTest.cpp b/llvm/unittests/Analysis/IRSimilarityIdentifierTest.cpp index f6a0537..cfe2c25 100644 --- a/llvm/unittests/Analysis/IRSimilarityIdentifierTest.cpp +++ b/llvm/unittests/Analysis/IRSimilarityIdentifierTest.cpp @@ -2188,9 +2188,9 @@ TEST(IRSimilarityCandidate, CanonicalNumbering) { for (std::pair<unsigned, DenseSet<unsigned>> &P : Mapping2) { unsigned Source = P.first; - ASSERT_TRUE(Cand2.getCanonicalNum(Source).has_value()); + ASSERT_TRUE(Cand2.getCanonicalNum(Source).hasValue()); unsigned Canon = *Cand2.getCanonicalNum(Source); - ASSERT_TRUE(Cand1.fromCanonicalNum(Canon).has_value()); + ASSERT_TRUE(Cand1.fromCanonicalNum(Canon).hasValue()); unsigned Dest = *Cand1.fromCanonicalNum(Canon); DenseSet<unsigned>::iterator It = P.second.find(Dest); diff --git a/llvm/unittests/Analysis/MemorySSATest.cpp b/llvm/unittests/Analysis/MemorySSATest.cpp index 4c8942f..298a8bc 100644 --- a/llvm/unittests/Analysis/MemorySSATest.cpp +++ b/llvm/unittests/Analysis/MemorySSATest.cpp @@ -1191,13 +1191,14 @@ TEST_F(MemorySSATest, TestStoreMayAlias) { EXPECT_EQ(MemDef->isOptimized(), true) << "Store " << I << " was not optimized"; if (I == 1 || I == 3 || I == 4) - EXPECT_EQ(MemDef->getOptimizedAccessType().value(), AliasResult::MayAlias) + EXPECT_EQ(MemDef->getOptimizedAccessType().getValue(), + AliasResult::MayAlias) << "Store " << I << " doesn't have the correct alias information"; else if (I == 0 || I == 2) EXPECT_EQ(MemDef->getOptimizedAccessType(), None) << "Store " << I << " doesn't have the correct alias information"; else - EXPECT_EQ(MemDef->getOptimizedAccessType().value(), + EXPECT_EQ(MemDef->getOptimizedAccessType().getValue(), AliasResult::MustAlias) << "Store " << I << " doesn't have the correct alias information"; // EXPECT_EQ expands such that if we increment I above, it won't get diff --git a/llvm/unittests/Analysis/VectorFunctionABITest.cpp b/llvm/unittests/Analysis/VectorFunctionABITest.cpp index 026732c..7ac1b03 100644 --- a/llvm/unittests/Analysis/VectorFunctionABITest.cpp +++ b/llvm/unittests/Analysis/VectorFunctionABITest.cpp @@ -75,8 +75,8 @@ protected: reset(Name, IRType); const auto OptInfo = VFABI::tryDemangleForVFABI(MangledName, *(M.get())); - if (OptInfo) { - Info = OptInfo.value(); + if (OptInfo.hasValue()) { + Info = OptInfo.getValue(); return true; } diff --git a/llvm/unittests/BinaryFormat/DwarfTest.cpp b/llvm/unittests/BinaryFormat/DwarfTest.cpp index ddafbb4..5e49a5c 100644 --- a/llvm/unittests/BinaryFormat/DwarfTest.cpp +++ b/llvm/unittests/BinaryFormat/DwarfTest.cpp @@ -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.has_value()); - EXPECT_TRUE(AddrSize.has_value()); + EXPECT_TRUE(RefSize.hasValue()); + EXPECT_TRUE(AddrSize.hasValue()); 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.has_value()); - EXPECT_TRUE(AddrSize.has_value()); + EXPECT_TRUE(RefSize.hasValue()); + EXPECT_TRUE(AddrSize.hasValue()); 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.has_value()); + EXPECT_TRUE(RefSize.hasValue()); 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.has_value()); + EXPECT_TRUE(RefSize.hasValue()); 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.has_value()); + EXPECT_TRUE(RefSize.hasValue()); 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.has_value()); + EXPECT_TRUE(RefSize.hasValue()); 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.has_value()); + EXPECT_TRUE(RefSize.hasValue()); 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.has_value()); + EXPECT_TRUE(RefSize.hasValue()); EXPECT_EQ(*RefSize, 8); } diff --git a/llvm/unittests/CodeGen/GlobalISel/ConstantFoldingTest.cpp b/llvm/unittests/CodeGen/GlobalISel/ConstantFoldingTest.cpp index 33c1f0f..5053d54 100644 --- a/llvm/unittests/CodeGen/GlobalISel/ConstantFoldingTest.cpp +++ b/llvm/unittests/CodeGen/GlobalISel/ConstantFoldingTest.cpp @@ -83,157 +83,157 @@ TEST_F(AArch64GISelMITest, FoldBinOp) { Optional<APInt> FoldGAddInt = ConstantFoldBinOp(TargetOpcode::G_ADD, MIBCst1.getReg(0), MIBCst2.getReg(0), *MRI); - EXPECT_TRUE(FoldGAddInt.has_value()); - EXPECT_EQ(25ULL, FoldGAddInt->getLimitedValue()); + EXPECT_TRUE(FoldGAddInt.hasValue()); + EXPECT_EQ(25ULL, FoldGAddInt.getValue().getLimitedValue()); Optional<APInt> FoldGAddMix = ConstantFoldBinOp(TargetOpcode::G_ADD, MIBCst1.getReg(0), MIBFCst2.getReg(0), *MRI); - EXPECT_TRUE(FoldGAddMix.has_value()); - EXPECT_EQ(1073741840ULL, FoldGAddMix->getLimitedValue()); + EXPECT_TRUE(FoldGAddMix.hasValue()); + 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.has_value()); - EXPECT_EQ(0ULL, FoldGAndInt->getLimitedValue()); + EXPECT_TRUE(FoldGAndInt.hasValue()); + EXPECT_EQ(0ULL, FoldGAndInt.getValue().getLimitedValue()); Optional<APInt> FoldGAndMix = ConstantFoldBinOp(TargetOpcode::G_AND, MIBCst2.getReg(0), MIBFCst1.getReg(0), *MRI); - EXPECT_TRUE(FoldGAndMix.has_value()); - EXPECT_EQ(1ULL, FoldGAndMix->getLimitedValue()); + EXPECT_TRUE(FoldGAndMix.hasValue()); + 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.has_value()); - EXPECT_EQ(0ULL, FoldGAShrInt->getLimitedValue()); + EXPECT_TRUE(FoldGAShrInt.hasValue()); + EXPECT_EQ(0ULL, FoldGAShrInt.getValue().getLimitedValue()); Optional<APInt> FoldGAShrMix = ConstantFoldBinOp(TargetOpcode::G_ASHR, MIBFCst2.getReg(0), MIBCst2.getReg(0), *MRI); - EXPECT_TRUE(FoldGAShrMix.has_value()); - EXPECT_EQ(2097152ULL, FoldGAShrMix->getLimitedValue()); + EXPECT_TRUE(FoldGAShrMix.hasValue()); + 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.has_value()); - EXPECT_EQ(0ULL, FoldGLShrInt->getLimitedValue()); + EXPECT_TRUE(FoldGLShrInt.hasValue()); + EXPECT_EQ(0ULL, FoldGLShrInt.getValue().getLimitedValue()); Optional<APInt> FoldGLShrMix = ConstantFoldBinOp(TargetOpcode::G_LSHR, MIBFCst1.getReg(0), MIBCst2.getReg(0), *MRI); - EXPECT_TRUE(FoldGLShrMix.has_value()); - EXPECT_EQ(2080768ULL, FoldGLShrMix->getLimitedValue()); + EXPECT_TRUE(FoldGLShrMix.hasValue()); + 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.has_value()); - EXPECT_EQ(144ULL, FoldGMulInt->getLimitedValue()); + EXPECT_TRUE(FoldGMulInt.hasValue()); + EXPECT_EQ(144ULL, FoldGMulInt.getValue().getLimitedValue()); Optional<APInt> FoldGMulMix = ConstantFoldBinOp(TargetOpcode::G_MUL, MIBCst1.getReg(0), MIBFCst2.getReg(0), *MRI); - EXPECT_TRUE(FoldGMulMix.has_value()); - EXPECT_EQ(0ULL, FoldGMulMix->getLimitedValue()); + EXPECT_TRUE(FoldGMulMix.hasValue()); + 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.has_value()); - EXPECT_EQ(25ULL, FoldGOrInt->getLimitedValue()); + EXPECT_TRUE(FoldGOrInt.hasValue()); + EXPECT_EQ(25ULL, FoldGOrInt.getValue().getLimitedValue()); Optional<APInt> FoldGOrMix = ConstantFoldBinOp(TargetOpcode::G_OR, MIBCst1.getReg(0), MIBFCst2.getReg(0), *MRI); - EXPECT_TRUE(FoldGOrMix.has_value()); - EXPECT_EQ(1073741840ULL, FoldGOrMix->getLimitedValue()); + EXPECT_TRUE(FoldGOrMix.hasValue()); + 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.has_value()); - EXPECT_EQ(8192ULL, FoldGShlInt->getLimitedValue()); + EXPECT_TRUE(FoldGShlInt.hasValue()); + EXPECT_EQ(8192ULL, FoldGShlInt.getValue().getLimitedValue()); Optional<APInt> FoldGShlMix = ConstantFoldBinOp(TargetOpcode::G_SHL, MIBCst1.getReg(0), MIBFCst2.getReg(0), *MRI); - EXPECT_TRUE(FoldGShlMix.has_value()); - EXPECT_EQ(0ULL, FoldGShlMix->getLimitedValue()); + EXPECT_TRUE(FoldGShlMix.hasValue()); + 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.has_value()); - EXPECT_EQ(7ULL, FoldGSubInt->getLimitedValue()); + EXPECT_TRUE(FoldGSubInt.hasValue()); + EXPECT_EQ(7ULL, FoldGSubInt.getValue().getLimitedValue()); Optional<APInt> FoldGSubMix = ConstantFoldBinOp(TargetOpcode::G_SUB, MIBCst1.getReg(0), MIBFCst2.getReg(0), *MRI); - EXPECT_TRUE(FoldGSubMix.has_value()); - EXPECT_EQ(3221225488ULL, FoldGSubMix->getLimitedValue()); + EXPECT_TRUE(FoldGSubMix.hasValue()); + 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.has_value()); - EXPECT_EQ(25ULL, FoldGXorInt->getLimitedValue()); + EXPECT_TRUE(FoldGXorInt.hasValue()); + EXPECT_EQ(25ULL, FoldGXorInt.getValue().getLimitedValue()); Optional<APInt> FoldGXorMix = ConstantFoldBinOp(TargetOpcode::G_XOR, MIBCst1.getReg(0), MIBFCst2.getReg(0), *MRI); - EXPECT_TRUE(FoldGXorMix.has_value()); - EXPECT_EQ(1073741840ULL, FoldGXorMix->getLimitedValue()); + EXPECT_TRUE(FoldGXorMix.hasValue()); + 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.has_value()); - EXPECT_EQ(1ULL, FoldGUdivInt->getLimitedValue()); + EXPECT_TRUE(FoldGUdivInt.hasValue()); + EXPECT_EQ(1ULL, FoldGUdivInt.getValue().getLimitedValue()); Optional<APInt> FoldGUdivMix = ConstantFoldBinOp(TargetOpcode::G_UDIV, MIBCst1.getReg(0), MIBFCst2.getReg(0), *MRI); - EXPECT_TRUE(FoldGUdivMix.has_value()); - EXPECT_EQ(0ULL, FoldGUdivMix->getLimitedValue()); + EXPECT_TRUE(FoldGUdivMix.hasValue()); + 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.has_value()); - EXPECT_EQ(1ULL, FoldGSdivInt->getLimitedValue()); + EXPECT_TRUE(FoldGSdivInt.hasValue()); + EXPECT_EQ(1ULL, FoldGSdivInt.getValue().getLimitedValue()); Optional<APInt> FoldGSdivMix = ConstantFoldBinOp(TargetOpcode::G_SDIV, MIBCst1.getReg(0), MIBFCst2.getReg(0), *MRI); - EXPECT_TRUE(FoldGSdivMix.has_value()); - EXPECT_EQ(0ULL, FoldGSdivMix->getLimitedValue()); + EXPECT_TRUE(FoldGSdivMix.hasValue()); + 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.has_value()); - EXPECT_EQ(1ULL, FoldGUremInt->getLimitedValue()); + EXPECT_TRUE(FoldGUremInt.hasValue()); + EXPECT_EQ(1ULL, FoldGUremInt.getValue().getLimitedValue()); Optional<APInt> FoldGUremMix = ConstantFoldBinOp(TargetOpcode::G_UDIV, MIBCst1.getReg(0), MIBFCst2.getReg(0), *MRI); - EXPECT_TRUE(FoldGUremMix.has_value()); - EXPECT_EQ(0ULL, FoldGUremMix->getLimitedValue()); + EXPECT_TRUE(FoldGUremMix.hasValue()); + 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.has_value()); - EXPECT_EQ(7ULL, FoldGSremInt->getLimitedValue()); + EXPECT_TRUE(FoldGSremInt.hasValue()); + EXPECT_EQ(7ULL, FoldGSremInt.getValue().getLimitedValue()); Optional<APInt> FoldGSremMix = ConstantFoldBinOp(TargetOpcode::G_SREM, MIBCst1.getReg(0), MIBFCst2.getReg(0), *MRI); - EXPECT_TRUE(FoldGSremMix.has_value()); - EXPECT_EQ(16ULL, FoldGSremMix->getLimitedValue()); + EXPECT_TRUE(FoldGSremMix.hasValue()); + EXPECT_EQ(16ULL, FoldGSremMix.getValue().getLimitedValue()); } } // namespace diff --git a/llvm/unittests/DebugInfo/DWARF/DWARFDebugFrameTest.cpp b/llvm/unittests/DebugInfo/DWARF/DWARFDebugFrameTest.cpp index dbc54e7..6a8f23c 100644 --- a/llvm/unittests/DebugInfo/DWARF/DWARFDebugFrameTest.cpp +++ b/llvm/unittests/DebugInfo/DWARF/DWARFDebugFrameTest.cpp @@ -424,31 +424,31 @@ TEST(DWARFDebugFrame, RegisterLocations) { // Verify RegisterLocations::getRegisterLocation() works as expected. Optional<dwarf::UnwindLocation> OptionalLoc; OptionalLoc = Locs.getRegisterLocation(0); - EXPECT_FALSE(OptionalLoc.has_value()); + EXPECT_FALSE(OptionalLoc.hasValue()); OptionalLoc = Locs.getRegisterLocation(12); - EXPECT_TRUE(OptionalLoc.has_value()); + EXPECT_TRUE(OptionalLoc.hasValue()); EXPECT_EQ(*OptionalLoc, Reg12Loc); OptionalLoc = Locs.getRegisterLocation(13); - EXPECT_TRUE(OptionalLoc.has_value()); + EXPECT_TRUE(OptionalLoc.hasValue()); EXPECT_EQ(*OptionalLoc, Reg13Loc); OptionalLoc = Locs.getRegisterLocation(14); - EXPECT_TRUE(OptionalLoc.has_value()); + EXPECT_TRUE(OptionalLoc.hasValue()); EXPECT_EQ(*OptionalLoc, Reg14Loc); // Verify registers are correctly removed when multiple exist in the list. Locs.removeRegisterLocation(13); - EXPECT_FALSE(Locs.getRegisterLocation(13).has_value()); + EXPECT_FALSE(Locs.getRegisterLocation(13).hasValue()); EXPECT_TRUE(Locs.hasLocations()); expectDumpResult(Locs, "reg12=[CFA+4], reg14=same"); Locs.removeRegisterLocation(14); - EXPECT_FALSE(Locs.getRegisterLocation(14).has_value()); + EXPECT_FALSE(Locs.getRegisterLocation(14).hasValue()); EXPECT_TRUE(Locs.hasLocations()); expectDumpResult(Locs, "reg12=[CFA+4]"); Locs.removeRegisterLocation(12); - EXPECT_FALSE(Locs.getRegisterLocation(12).has_value()); + EXPECT_FALSE(Locs.getRegisterLocation(12).hasValue()); EXPECT_FALSE(Locs.hasLocations()); expectDumpResult(Locs, ""); } diff --git a/llvm/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp b/llvm/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp index e4c65c0..367e89e4 100644 --- a/llvm/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp +++ b/llvm/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp @@ -252,32 +252,32 @@ void TestAllForms() { FormValue = DieDG.find(Attr_DW_FORM_block); EXPECT_TRUE((bool)FormValue); BlockDataOpt = FormValue->getAsBlock(); - EXPECT_TRUE(BlockDataOpt.has_value()); - ExtractedBlockData = *BlockDataOpt; + EXPECT_TRUE(BlockDataOpt.hasValue()); + ExtractedBlockData = BlockDataOpt.getValue(); EXPECT_EQ(ExtractedBlockData.size(), BlockSize); EXPECT_TRUE(memcmp(ExtractedBlockData.data(), BlockData, BlockSize) == 0); FormValue = DieDG.find(Attr_DW_FORM_block1); EXPECT_TRUE((bool)FormValue); BlockDataOpt = FormValue->getAsBlock(); - EXPECT_TRUE(BlockDataOpt.has_value()); - ExtractedBlockData = *BlockDataOpt; + EXPECT_TRUE(BlockDataOpt.hasValue()); + ExtractedBlockData = BlockDataOpt.getValue(); EXPECT_EQ(ExtractedBlockData.size(), BlockSize); EXPECT_TRUE(memcmp(ExtractedBlockData.data(), BlockData, BlockSize) == 0); FormValue = DieDG.find(Attr_DW_FORM_block2); EXPECT_TRUE((bool)FormValue); BlockDataOpt = FormValue->getAsBlock(); - EXPECT_TRUE(BlockDataOpt.has_value()); - ExtractedBlockData = *BlockDataOpt; + EXPECT_TRUE(BlockDataOpt.hasValue()); + ExtractedBlockData = BlockDataOpt.getValue(); EXPECT_EQ(ExtractedBlockData.size(), BlockSize); EXPECT_TRUE(memcmp(ExtractedBlockData.data(), BlockData, BlockSize) == 0); FormValue = DieDG.find(Attr_DW_FORM_block4); EXPECT_TRUE((bool)FormValue); BlockDataOpt = FormValue->getAsBlock(); - EXPECT_TRUE(BlockDataOpt.has_value()); - ExtractedBlockData = *BlockDataOpt; + EXPECT_TRUE(BlockDataOpt.hasValue()); + ExtractedBlockData = BlockDataOpt.getValue(); EXPECT_EQ(ExtractedBlockData.size(), BlockSize); EXPECT_TRUE(memcmp(ExtractedBlockData.data(), BlockData, BlockSize) == 0); @@ -286,8 +286,8 @@ void TestAllForms() { FormValue = DieDG.find(Attr_DW_FORM_data16); EXPECT_TRUE((bool)FormValue); BlockDataOpt = FormValue->getAsBlock(); - EXPECT_TRUE(BlockDataOpt.has_value()); - ExtractedBlockData = *BlockDataOpt; + EXPECT_TRUE(BlockDataOpt.hasValue()); + ExtractedBlockData = BlockDataOpt.getValue(); EXPECT_EQ(ExtractedBlockData.size(), 16u); EXPECT_TRUE(memcmp(ExtractedBlockData.data(), Data16, 16) == 0); } @@ -989,21 +989,21 @@ template <uint16_t Version, class AddrType> void TestAddresses() { EXPECT_FALSE((bool)OptU64); } else { EXPECT_TRUE((bool)OptU64); - EXPECT_EQ(*OptU64, ActualHighPC); + EXPECT_EQ(OptU64.getValue(), ActualHighPC); } // Get the high PC as an unsigned constant. This should succeed if the high PC // was encoded as an offset and fail if the high PC was encoded as an address. OptU64 = toUnsigned(SubprogramDieLowHighPC.find(DW_AT_high_pc)); if (SupportsHighPCAsOffset) { EXPECT_TRUE((bool)OptU64); - EXPECT_EQ(*OptU64, ActualHighPCOffset); + EXPECT_EQ(OptU64.getValue(), ActualHighPCOffset); } else { EXPECT_FALSE((bool)OptU64); } OptU64 = SubprogramDieLowHighPC.getHighPC(ActualLowPC); EXPECT_TRUE((bool)OptU64); - EXPECT_EQ(*OptU64, ActualHighPC); + EXPECT_EQ(OptU64.getValue(), ActualHighPC); EXPECT_TRUE(SubprogramDieLowHighPC.getLowAndHighPC(LowPC, HighPC, SectionIndex)); EXPECT_EQ(LowPC, ActualLowPC); @@ -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).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_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_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).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_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_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).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_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_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).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_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_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).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_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_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).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()); + 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()); auto BlockOpt = toBlock(FormValOpt6); - EXPECT_TRUE(BlockOpt.has_value()); + EXPECT_TRUE(BlockOpt.hasValue()); 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>()).has_value()); + EXPECT_FALSE(FuncDie.find(ArrayRef<dwarf::Attribute>()).hasValue()); // 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}).has_value()); + EXPECT_FALSE(FuncDie.find({DW_AT_low_pc, DW_AT_entry_pc}).hasValue()); 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).has_value()); + EXPECT_FALSE(FuncDie.find(Attrs).hasValue()); // 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.has_value()); + EXPECT_TRUE(NameOpt.hasValue()); EXPECT_EQ(DieMangled, toString(NameOpt, "")); } diff --git a/llvm/unittests/DebugInfo/DWARF/DWARFFormValueTest.cpp b/llvm/unittests/DebugInfo/DWARF/DWARFFormValueTest.cpp index c81059c..9976777 100644 --- a/llvm/unittests/DebugInfo/DWARF/DWARFFormValueTest.cpp +++ b/llvm/unittests/DebugInfo/DWARF/DWARFFormValueTest.cpp @@ -79,17 +79,17 @@ TEST(DWARFFormValue, SignedConstantForms) { auto Sign2 = createDataXFormValue<uint16_t>(DW_FORM_data2, -12345); auto Sign4 = createDataXFormValue<uint32_t>(DW_FORM_data4, -123456789); auto Sign8 = createDataXFormValue<uint64_t>(DW_FORM_data8, -1); - EXPECT_EQ(Sign1.getAsSignedConstant().value(), -123); - EXPECT_EQ(Sign2.getAsSignedConstant().value(), -12345); - EXPECT_EQ(Sign4.getAsSignedConstant().value(), -123456789); - EXPECT_EQ(Sign8.getAsSignedConstant().value(), -1); + EXPECT_EQ(Sign1.getAsSignedConstant().getValue(), -123); + EXPECT_EQ(Sign2.getAsSignedConstant().getValue(), -12345); + EXPECT_EQ(Sign4.getAsSignedConstant().getValue(), -123456789); + EXPECT_EQ(Sign8.getAsSignedConstant().getValue(), -1); // Check that we can handle big positive values, but that we return // an error just over the limit. auto UMax = createULEBFormValue(LLONG_MAX); auto TooBig = createULEBFormValue(uint64_t(LLONG_MAX) + 1); - EXPECT_EQ(UMax.getAsSignedConstant().value(), LLONG_MAX); - EXPECT_EQ(TooBig.getAsSignedConstant().has_value(), false); + EXPECT_EQ(UMax.getAsSignedConstant().getValue(), LLONG_MAX); + EXPECT_EQ(TooBig.getAsSignedConstant().hasValue(), false); // Sanity check some other forms. auto Data1 = createDataXFormValue<uint8_t>(DW_FORM_data1, 120); @@ -100,14 +100,14 @@ TEST(DWARFFormValue, SignedConstantForms) { auto LEBMax = createSLEBFormValue(LLONG_MAX); auto LEB1 = createSLEBFormValue(-42); auto LEB2 = createSLEBFormValue(42); - EXPECT_EQ(Data1.getAsSignedConstant().value(), 120); - EXPECT_EQ(Data2.getAsSignedConstant().value(), 32000); - EXPECT_EQ(Data4.getAsSignedConstant().value(), 2000000000); - EXPECT_EQ(Data8.getAsSignedConstant().value(), 0x1234567812345678LL); - EXPECT_EQ(LEBMin.getAsSignedConstant().value(), LLONG_MIN); - EXPECT_EQ(LEBMax.getAsSignedConstant().value(), LLONG_MAX); - EXPECT_EQ(LEB1.getAsSignedConstant().value(), -42); - EXPECT_EQ(LEB2.getAsSignedConstant().value(), 42); + EXPECT_EQ(Data1.getAsSignedConstant().getValue(), 120); + EXPECT_EQ(Data2.getAsSignedConstant().getValue(), 32000); + EXPECT_EQ(Data4.getAsSignedConstant().getValue(), 2000000000); + EXPECT_EQ(Data8.getAsSignedConstant().getValue(), 0x1234567812345678LL); + EXPECT_EQ(LEBMin.getAsSignedConstant().getValue(), LLONG_MIN); + EXPECT_EQ(LEBMax.getAsSignedConstant().getValue(), LLONG_MAX); + EXPECT_EQ(LEB1.getAsSignedConstant().getValue(), -42); + EXPECT_EQ(LEB2.getAsSignedConstant().getValue(), 42); // Data16 is a little tricky. char Cksum[16] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15}; diff --git a/llvm/unittests/DebugInfo/GSYM/GSYMTest.cpp b/llvm/unittests/DebugInfo/GSYM/GSYMTest.cpp index bfe66f0..977231d 100644 --- a/llvm/unittests/DebugInfo/GSYM/GSYMTest.cpp +++ b/llvm/unittests/DebugInfo/GSYM/GSYMTest.cpp @@ -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.has_value()); - EXPECT_FALSE(ExpFI->Inline.has_value()); + EXPECT_FALSE(ExpFI->OptLineTable.hasValue()); + EXPECT_FALSE(ExpFI->Inline.hasValue()); } 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.has_value()); - EXPECT_FALSE(ExpFI->Inline.has_value()); + EXPECT_FALSE(ExpFI->OptLineTable.hasValue()); + EXPECT_FALSE(ExpFI->Inline.hasValue()); } 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.has_value()); - EXPECT_FALSE(ExpFI->Inline.has_value()); + EXPECT_FALSE(ExpFI->OptLineTable.hasValue()); + EXPECT_FALSE(ExpFI->Inline.hasValue()); 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.has_value()); - EXPECT_FALSE(ExpFI->Inline.has_value()); + EXPECT_FALSE(ExpFI->OptLineTable.hasValue()); + EXPECT_FALSE(ExpFI->Inline.hasValue()); 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.has_value()); - EXPECT_FALSE(ExpFI->Inline.has_value()); + EXPECT_FALSE(ExpFI->OptLineTable.hasValue()); + EXPECT_FALSE(ExpFI->Inline.hasValue()); 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.has_value()); - EXPECT_TRUE(ExpFI->Inline.has_value()); + EXPECT_TRUE(ExpFI->OptLineTable.hasValue()); + EXPECT_TRUE(ExpFI->Inline.hasValue()); 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.has_value()); + EXPECT_FALSE(ExpFI->OptLineTable.hasValue()); 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.has_value()); + EXPECT_TRUE(ExpFI->OptLineTable.hasValue()); 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 diff --git a/llvm/unittests/FileCheck/FileCheckTest.cpp b/llvm/unittests/FileCheck/FileCheckTest.cpp index 39230c4..f3b5d3d 100644 --- a/llvm/unittests/FileCheck/FileCheckTest.cpp +++ b/llvm/unittests/FileCheck/FileCheckTest.cpp @@ -766,8 +766,8 @@ TEST_F(FileCheckTest, NumericVariable) { ASSERT_TRUE(Value); EXPECT_EQ(925, cantFail(Value->getSignedValue())); // getStringValue should return the same memory not just the same characters. - EXPECT_EQ(StringValue.begin(), FooVar.getStringValue()->begin()); - EXPECT_EQ(StringValue.end(), FooVar.getStringValue()->end()); + EXPECT_EQ(StringValue.begin(), FooVar.getStringValue().getValue().begin()); + EXPECT_EQ(StringValue.end(), FooVar.getStringValue().getValue().end()); EvalResult = FooVarUse.eval(); ASSERT_THAT_EXPECTED(EvalResult, Succeeded()); EXPECT_EQ(925, cantFail(EvalResult->getSignedValue())); diff --git a/llvm/unittests/IR/MetadataTest.cpp b/llvm/unittests/IR/MetadataTest.cpp index a755dfa..0c73aaa 100644 --- a/llvm/unittests/IR/MetadataTest.cpp +++ b/llvm/unittests/IR/MetadataTest.cpp @@ -1045,51 +1045,52 @@ TEST_F(DILocationTest, cloneTemporary) { } TEST_F(DILocationTest, discriminatorEncoding) { - EXPECT_EQ(0U, DILocation::encodeDiscriminator(0, 0, 0).value()); + EXPECT_EQ(0U, DILocation::encodeDiscriminator(0, 0, 0).getValue()); // Encode base discriminator as a component: lsb is 0, then the value. // The other components are all absent, so we leave all the other bits 0. - EXPECT_EQ(2U, DILocation::encodeDiscriminator(1, 0, 0).value()); + EXPECT_EQ(2U, DILocation::encodeDiscriminator(1, 0, 0).getValue()); // Base discriminator component is empty, so lsb is 1. Next component is not // empty, so its lsb is 0, then its value (1). Next component is empty. // So the bit pattern is 101. - EXPECT_EQ(5U, DILocation::encodeDiscriminator(0, 1, 0).value()); + EXPECT_EQ(5U, DILocation::encodeDiscriminator(0, 1, 0).getValue()); // First 2 components are empty, so the bit pattern is 11. Then the // next component - ending up with 1011. - EXPECT_EQ(0xbU, DILocation::encodeDiscriminator(0, 0, 1).value()); + EXPECT_EQ(0xbU, DILocation::encodeDiscriminator(0, 0, 1).getValue()); // The bit pattern for the first 2 components is 11. The next bit is 0, // because the last component is not empty. We have 29 bits usable for // encoding, but we cap it at 12 bits uniformously for all components. We // encode the last component over 14 bits. - EXPECT_EQ(0xfffbU, DILocation::encodeDiscriminator(0, 0, 0xfff).value()); + EXPECT_EQ(0xfffbU, DILocation::encodeDiscriminator(0, 0, 0xfff).getValue()); - EXPECT_EQ(0x102U, DILocation::encodeDiscriminator(1, 1, 0).value()); + EXPECT_EQ(0x102U, DILocation::encodeDiscriminator(1, 1, 0).getValue()); - EXPECT_EQ(0x13eU, DILocation::encodeDiscriminator(0x1f, 1, 0).value()); + EXPECT_EQ(0x13eU, DILocation::encodeDiscriminator(0x1f, 1, 0).getValue()); - EXPECT_EQ(0x87feU, DILocation::encodeDiscriminator(0x1ff, 1, 0).value()); + EXPECT_EQ(0x87feU, DILocation::encodeDiscriminator(0x1ff, 1, 0).getValue()); - EXPECT_EQ(0x1f3eU, DILocation::encodeDiscriminator(0x1f, 0x1f, 0).value()); + EXPECT_EQ(0x1f3eU, DILocation::encodeDiscriminator(0x1f, 0x1f, 0).getValue()); - EXPECT_EQ(0x3ff3eU, DILocation::encodeDiscriminator(0x1f, 0x1ff, 0).value()); + EXPECT_EQ(0x3ff3eU, + DILocation::encodeDiscriminator(0x1f, 0x1ff, 0).getValue()); EXPECT_EQ(0x1ff87feU, - DILocation::encodeDiscriminator(0x1ff, 0x1ff, 0).value()); + DILocation::encodeDiscriminator(0x1ff, 0x1ff, 0).getValue()); EXPECT_EQ(0xfff9f3eU, - DILocation::encodeDiscriminator(0x1f, 0x1f, 0xfff).value()); + DILocation::encodeDiscriminator(0x1f, 0x1f, 0xfff).getValue()); EXPECT_EQ(0xffc3ff3eU, - DILocation::encodeDiscriminator(0x1f, 0x1ff, 0x1ff).value()); + DILocation::encodeDiscriminator(0x1f, 0x1ff, 0x1ff).getValue()); EXPECT_EQ(0xffcf87feU, - DILocation::encodeDiscriminator(0x1ff, 0x1f, 0x1ff).value()); + DILocation::encodeDiscriminator(0x1ff, 0x1f, 0x1ff).getValue()); EXPECT_EQ(0xe1ff87feU, - DILocation::encodeDiscriminator(0x1ff, 0x1ff, 7).value()); + DILocation::encodeDiscriminator(0x1ff, 0x1ff, 7).getValue()); } TEST_F(DILocationTest, discriminatorEncodingNegativeTests) { @@ -1112,36 +1113,36 @@ TEST_F(DILocationTest, discriminatorSpecialCases) { EXPECT_EQ(0U, L1->getBaseDiscriminator()); EXPECT_EQ(1U, L1->getDuplicationFactor()); - EXPECT_EQ(L1, L1->cloneWithBaseDiscriminator(0).value()); - EXPECT_EQ(L1, L1->cloneByMultiplyingDuplicationFactor(0).value()); - EXPECT_EQ(L1, L1->cloneByMultiplyingDuplicationFactor(1).value()); + EXPECT_EQ(L1, L1->cloneWithBaseDiscriminator(0).getValue()); + EXPECT_EQ(L1, L1->cloneByMultiplyingDuplicationFactor(0).getValue()); + EXPECT_EQ(L1, L1->cloneByMultiplyingDuplicationFactor(1).getValue()); - auto L2 = L1->cloneWithBaseDiscriminator(1).value(); + auto L2 = L1->cloneWithBaseDiscriminator(1).getValue(); EXPECT_EQ(0U, L1->getBaseDiscriminator()); EXPECT_EQ(1U, L1->getDuplicationFactor()); EXPECT_EQ(1U, L2->getBaseDiscriminator()); EXPECT_EQ(1U, L2->getDuplicationFactor()); - auto L3 = L2->cloneByMultiplyingDuplicationFactor(2).value(); + auto L3 = L2->cloneByMultiplyingDuplicationFactor(2).getValue(); EXPECT_EQ(1U, L3->getBaseDiscriminator()); EXPECT_EQ(2U, L3->getDuplicationFactor()); - EXPECT_EQ(L2, L2->cloneByMultiplyingDuplicationFactor(1).value()); + EXPECT_EQ(L2, L2->cloneByMultiplyingDuplicationFactor(1).getValue()); - auto L4 = L3->cloneByMultiplyingDuplicationFactor(4).value(); + auto L4 = L3->cloneByMultiplyingDuplicationFactor(4).getValue(); EXPECT_EQ(1U, L4->getBaseDiscriminator()); EXPECT_EQ(8U, L4->getDuplicationFactor()); - auto L5 = L4->cloneWithBaseDiscriminator(2).value(); + auto L5 = L4->cloneWithBaseDiscriminator(2).getValue(); EXPECT_EQ(2U, L5->getBaseDiscriminator()); EXPECT_EQ(8U, L5->getDuplicationFactor()); // Check extreme cases - auto L6 = L1->cloneWithBaseDiscriminator(0xfff).value(); + auto L6 = L1->cloneWithBaseDiscriminator(0xfff).getValue(); EXPECT_EQ(0xfffU, L6->getBaseDiscriminator()); EXPECT_EQ(0xfffU, L6->cloneByMultiplyingDuplicationFactor(0xfff) - .value() + .getValue() ->getDuplicationFactor()); // Check we return None for unencodable cases. @@ -2932,24 +2933,22 @@ 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) \ - .has_value()); \ + DIExpression* Expression = DIExpression::get(Context, Elements); \ + EXPECT_TRUE(DIExpression::createFragmentExpression( \ + Expression, Offset, Size).hasValue()); \ } 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) \ - .has_value()); \ + DIExpression* Expression = DIExpression::get(Context, Elements); \ + EXPECT_FALSE(DIExpression::createFragmentExpression( \ + Expression, Offset, Size).hasValue()); \ } while (false) // createFragmentExpression adds correct ops. Optional<DIExpression*> R = DIExpression::createFragmentExpression( DIExpression::get(Context, {}), 0, 32); - EXPECT_EQ(R.has_value(), true); + EXPECT_EQ(R.hasValue(), true); EXPECT_EQ(3u, (*R)->getNumElements()); EXPECT_EQ(dwarf::DW_OP_LLVM_fragment, (*R)->getElement(0)); EXPECT_EQ(0u, (*R)->getElement(1)); @@ -3456,20 +3455,20 @@ TEST_F(FunctionAttachmentTest, Verifier) { TEST_F(FunctionAttachmentTest, RealEntryCount) { Function *F = getFunction("foo"); - EXPECT_FALSE(F->getEntryCount().has_value()); + EXPECT_FALSE(F->getEntryCount().hasValue()); F->setEntryCount(12304, Function::PCT_Real); auto Count = F->getEntryCount(); - EXPECT_TRUE(Count.has_value()); + EXPECT_TRUE(Count.hasValue()); EXPECT_EQ(12304u, Count->getCount()); EXPECT_EQ(Function::PCT_Real, Count->getType()); } TEST_F(FunctionAttachmentTest, SyntheticEntryCount) { Function *F = getFunction("bar"); - EXPECT_FALSE(F->getEntryCount().has_value()); + EXPECT_FALSE(F->getEntryCount().hasValue()); F->setEntryCount(123, Function::PCT_Synthetic); auto Count = F->getEntryCount(true /*allow synthetic*/); - EXPECT_TRUE(Count.has_value()); + EXPECT_TRUE(Count.hasValue()); EXPECT_EQ(123u, Count->getCount()); EXPECT_EQ(Function::PCT_Synthetic, Count->getType()); } diff --git a/llvm/unittests/IR/VPIntrinsicTest.cpp b/llvm/unittests/IR/VPIntrinsicTest.cpp index 34123ef..62e16df 100644 --- a/llvm/unittests/IR/VPIntrinsicTest.cpp +++ b/llvm/unittests/IR/VPIntrinsicTest.cpp @@ -128,25 +128,25 @@ protected: TEST_F(VPIntrinsicTest, VPIntrinsicsDefScopes) { Optional<Intrinsic::ID> ScopeVPID; #define BEGIN_REGISTER_VP_INTRINSIC(VPID, ...) \ - ASSERT_FALSE(ScopeVPID.has_value()); \ + ASSERT_FALSE(ScopeVPID.hasValue()); \ ScopeVPID = Intrinsic::VPID; #define END_REGISTER_VP_INTRINSIC(VPID) \ - ASSERT_TRUE(ScopeVPID.has_value()); \ - ASSERT_EQ(*ScopeVPID, Intrinsic::VPID); \ + ASSERT_TRUE(ScopeVPID.hasValue()); \ + ASSERT_EQ(ScopeVPID.getValue(), Intrinsic::VPID); \ ScopeVPID = None; Optional<ISD::NodeType> ScopeOPC; #define BEGIN_REGISTER_VP_SDNODE(SDOPC, ...) \ - ASSERT_FALSE(ScopeOPC.has_value()); \ + ASSERT_FALSE(ScopeOPC.hasValue()); \ ScopeOPC = ISD::SDOPC; #define END_REGISTER_VP_SDNODE(SDOPC) \ - ASSERT_TRUE(ScopeOPC.has_value()); \ - ASSERT_EQ(*ScopeOPC, ISD::SDOPC); \ + ASSERT_TRUE(ScopeOPC.hasValue()); \ + ASSERT_EQ(ScopeOPC.getValue(), ISD::SDOPC); \ ScopeOPC = None; #include "llvm/IR/VPIntrinsics.def" - ASSERT_FALSE(ScopeVPID.has_value()); - ASSERT_FALSE(ScopeOPC.has_value()); + ASSERT_FALSE(ScopeVPID.hasValue()); + ASSERT_FALSE(ScopeOPC.hasValue()); } /// Check that every VP intrinsic in the test module is recognized as a VP @@ -233,8 +233,8 @@ TEST_F(VPIntrinsicTest, GetParamPos) { ASSERT_TRUE(F.isIntrinsic()); Optional<unsigned> MaskParamPos = VPIntrinsic::getMaskParamPos(F.getIntrinsicID()); - if (MaskParamPos) { - Type *MaskParamType = F.getArg(*MaskParamPos)->getType(); + if (MaskParamPos.hasValue()) { + Type *MaskParamType = F.getArg(MaskParamPos.getValue())->getType(); ASSERT_TRUE(MaskParamType->isVectorTy()); ASSERT_TRUE( cast<VectorType>(MaskParamType)->getElementType()->isIntegerTy(1)); @@ -242,8 +242,8 @@ TEST_F(VPIntrinsicTest, GetParamPos) { Optional<unsigned> VecLenParamPos = VPIntrinsic::getVectorLengthParamPos(F.getIntrinsicID()); - if (VecLenParamPos) { - Type *VecLenParamType = F.getArg(*VecLenParamPos)->getType(); + if (VecLenParamPos.hasValue()) { + Type *VecLenParamType = F.getArg(VecLenParamPos.getValue())->getType(); ASSERT_TRUE(VecLenParamType->isIntegerTy(32)); } } @@ -406,13 +406,13 @@ TEST_F(VPIntrinsicTest, VPReductions) { if (!VPReductionIntrinsic::isVPReduction(ID)) { EXPECT_EQ(VPRedI, nullptr); - EXPECT_EQ(VPReductionIntrinsic::getStartParamPos(ID).has_value(), false); - EXPECT_EQ(VPReductionIntrinsic::getVectorParamPos(ID).has_value(), false); + EXPECT_EQ(VPReductionIntrinsic::getStartParamPos(ID).hasValue(), false); + EXPECT_EQ(VPReductionIntrinsic::getVectorParamPos(ID).hasValue(), false); continue; } - EXPECT_EQ(VPReductionIntrinsic::getStartParamPos(ID).has_value(), true); - EXPECT_EQ(VPReductionIntrinsic::getVectorParamPos(ID).has_value(), true); + EXPECT_EQ(VPReductionIntrinsic::getStartParamPos(ID).hasValue(), true); + EXPECT_EQ(VPReductionIntrinsic::getVectorParamPos(ID).hasValue(), true); ASSERT_NE(VPRedI, nullptr); EXPECT_EQ(VPReductionIntrinsic::getStartParamPos(ID), VPRedI->getStartParamPos()); diff --git a/llvm/unittests/InterfaceStub/ELFYAMLTest.cpp b/llvm/unittests/InterfaceStub/ELFYAMLTest.cpp index d347e17..404dfd3 100644 --- a/llvm/unittests/InterfaceStub/ELFYAMLTest.cpp +++ b/llvm/unittests/InterfaceStub/ELFYAMLTest.cpp @@ -47,9 +47,9 @@ 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.has_value()); - EXPECT_TRUE(Stub->Target.Arch.has_value()); - EXPECT_EQ(Stub->Target.Arch.value(), (uint16_t)llvm::ELF::EM_X86_64); + EXPECT_FALSE(Stub->SoName.hasValue()); + EXPECT_TRUE(Stub->Target.Arch.hasValue()); + 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"); EXPECT_STREQ(Stub->NeededLibs[1].c_str(), "libfoo.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.has_value()); + EXPECT_FALSE(SymBaz.Warning.hasValue()); IFSSymbol const &SymFoo = *Iterator++; EXPECT_STREQ(SymFoo.Name.c_str(), "foo"); - EXPECT_FALSE(SymFoo.Size.has_value()); + EXPECT_FALSE(SymFoo.Size.hasValue()); EXPECT_EQ(SymFoo.Type, IFSSymbolType::Func); EXPECT_FALSE(SymFoo.Undefined); EXPECT_FALSE(SymFoo.Weak); - EXPECT_TRUE(SymFoo.Warning.has_value()); + EXPECT_TRUE(SymFoo.Warning.hasValue()); EXPECT_STREQ(SymFoo.Warning->c_str(), "Deprecated!"); IFSSymbol const &SymNor = *Iterator++; EXPECT_STREQ(SymNor.Name.c_str(), "nor"); - EXPECT_FALSE(SymNor.Size.has_value()); + EXPECT_FALSE(SymNor.Size.hasValue()); EXPECT_EQ(SymNor.Type, IFSSymbolType::NoType); EXPECT_TRUE(SymNor.Undefined); EXPECT_FALSE(SymNor.Weak); - EXPECT_FALSE(SymNor.Warning.has_value()); + EXPECT_FALSE(SymNor.Warning.hasValue()); IFSSymbol const &SymNot = *Iterator++; EXPECT_STREQ(SymNot.Name.c_str(), "not"); diff --git a/llvm/unittests/Object/XCOFFObjectFileTest.cpp b/llvm/unittests/Object/XCOFFObjectFileTest.cpp index cf2be43..41662be 100644 --- a/llvm/unittests/Object/XCOFFObjectFileTest.cpp +++ b/llvm/unittests/Object/XCOFFObjectFileTest.cpp @@ -83,16 +83,16 @@ TEST(XCOFFObjectFileTest, XCOFFTracebackTableAPIGeneral) { EXPECT_TRUE(TT.hasParmsOnStack()); ASSERT_TRUE(TT.getParmsType()); - EXPECT_EQ(TT.getParmsType().value(), "i, f, d"); + EXPECT_EQ(TT.getParmsType().getValue(), "i, f, d"); ASSERT_TRUE(TT.getTraceBackTableOffset()); - EXPECT_EQ(TT.getTraceBackTableOffset().value(), 64u); + EXPECT_EQ(TT.getTraceBackTableOffset().getValue(), 64u); EXPECT_FALSE(TT.getHandlerMask()); ASSERT_TRUE(TT.getFunctionName()); - EXPECT_EQ(TT.getFunctionName().value(), "add_all"); - EXPECT_EQ(TT.getFunctionName()->size(), 7u); + EXPECT_EQ(TT.getFunctionName().getValue(), "add_all"); + EXPECT_EQ(TT.getFunctionName().getValue().size(), 7u); EXPECT_FALSE(TT.getAllocaRegister()); EXPECT_EQ(Size, 25u); @@ -171,11 +171,11 @@ TEST(XCOFFObjectFileTest, XCOFFTracebackTableAPIControlledStorageInfoDisp) { XCOFFTracebackTable TT = *TTOrErr; EXPECT_TRUE(TT.hasControlledStorage()); ASSERT_TRUE(TT.getNumOfCtlAnchors()); - EXPECT_EQ(TT.getNumOfCtlAnchors().value(), 2u); + EXPECT_EQ(TT.getNumOfCtlAnchors().getValue(), 2u); ASSERT_TRUE(TT.getControlledStorageInfoDisp()); - SmallVector<uint32_t, 8> Disp = TT.getControlledStorageInfoDisp().value(); + SmallVector<uint32_t, 8> Disp = TT.getControlledStorageInfoDisp().getValue(); ASSERT_EQ(Disp.size(), 2UL); EXPECT_EQ(Disp[0], 0x05050000u); @@ -207,10 +207,10 @@ TEST(XCOFFObjectFileTest, XCOFFTracebackTableAPIHasVectorInfo) { EXPECT_TRUE(TT.hasExtensionTable()); ASSERT_TRUE(TT.getParmsType()); - EXPECT_EQ(TT.getParmsType().value(), "v, i, f, i, d, i, v"); + EXPECT_EQ(TT.getParmsType().getValue(), "v, i, f, i, d, i, v"); ASSERT_TRUE(TT.getVectorExt()); - TBVectorExt VecExt = TT.getVectorExt().value(); + TBVectorExt VecExt = TT.getVectorExt().getValue(); EXPECT_EQ(VecExt.getNumberOfVRSaved(), 0); EXPECT_TRUE(VecExt.isVRSavedOnStack()); @@ -240,10 +240,10 @@ TEST(XCOFFObjectFileTest, XCOFFTracebackTableAPIHasVectorInfo1) { XCOFFTracebackTable TT = *TTOrErr; ASSERT_TRUE(TT.getParmsType()); - EXPECT_EQ(TT.getParmsType().value(), "v, i, f, i, d, i, v, v"); + EXPECT_EQ(TT.getParmsType().getValue(), "v, i, f, i, d, i, v, v"); ASSERT_TRUE(TT.getVectorExt()); - TBVectorExt VecExt = TT.getVectorExt().value(); + TBVectorExt VecExt = TT.getVectorExt().getValue(); EXPECT_EQ(VecExt.getNumberOfVRSaved(), 4); EXPECT_FALSE(VecExt.isVRSavedOnStack()); diff --git a/llvm/unittests/ObjectYAML/DWARFYAMLTest.cpp b/llvm/unittests/ObjectYAML/DWARFYAMLTest.cpp index 09c9e35..91febff 100644 --- a/llvm/unittests/ObjectYAML/DWARFYAMLTest.cpp +++ b/llvm/unittests/ObjectYAML/DWARFYAMLTest.cpp @@ -91,8 +91,8 @@ debug_pubtypes: DWARFYAML::Data Data; ASSERT_THAT_ERROR(parseDWARFYAML(Yaml, Data), Succeeded()); - ASSERT_TRUE(Data.PubNames.has_value()); - DWARFYAML::PubSection PubNames = Data.PubNames.value(); + ASSERT_TRUE(Data.PubNames.hasValue()); + DWARFYAML::PubSection PubNames = Data.PubNames.getValue(); ASSERT_EQ(PubNames.Entries.size(), 2u); EXPECT_EQ((uint32_t)PubNames.Entries[0].DieOffset, 0x1234u); @@ -100,8 +100,8 @@ debug_pubtypes: EXPECT_EQ((uint32_t)PubNames.Entries[1].DieOffset, 0x4321u); EXPECT_EQ(PubNames.Entries[1].Name, "def"); - ASSERT_TRUE(Data.PubTypes.has_value()); - DWARFYAML::PubSection PubTypes = Data.PubTypes.value(); + ASSERT_TRUE(Data.PubTypes.hasValue()); + DWARFYAML::PubSection PubTypes = Data.PubTypes.getValue(); ASSERT_EQ(PubTypes.Entries.size(), 2u); EXPECT_EQ((uint32_t)PubTypes.Entries[0].DieOffset, 0x1234u); @@ -157,8 +157,8 @@ debug_gnu_pubtypes: DWARFYAML::Data Data; ASSERT_THAT_ERROR(parseDWARFYAML(Yaml, Data), Succeeded()); - ASSERT_TRUE(Data.GNUPubNames.has_value()); - DWARFYAML::PubSection GNUPubNames = Data.GNUPubNames.value(); + ASSERT_TRUE(Data.GNUPubNames.hasValue()); + DWARFYAML::PubSection GNUPubNames = Data.GNUPubNames.getValue(); ASSERT_EQ(GNUPubNames.Entries.size(), 2u); EXPECT_EQ((uint32_t)GNUPubNames.Entries[0].DieOffset, 0x1234u); @@ -168,8 +168,8 @@ debug_gnu_pubtypes: EXPECT_EQ((uint8_t)GNUPubNames.Entries[1].Descriptor, 0x34); EXPECT_EQ(GNUPubNames.Entries[1].Name, "def"); - ASSERT_TRUE(Data.GNUPubTypes.has_value()); - DWARFYAML::PubSection GNUPubTypes = Data.GNUPubTypes.value(); + ASSERT_TRUE(Data.GNUPubTypes.hasValue()); + DWARFYAML::PubSection GNUPubTypes = Data.GNUPubTypes.getValue(); ASSERT_EQ(GNUPubTypes.Entries.size(), 2u); EXPECT_EQ((uint32_t)GNUPubTypes.Entries[0].DieOffset, 0x1234u); diff --git a/llvm/unittests/ProfileData/MemProfTest.cpp b/llvm/unittests/ProfileData/MemProfTest.cpp index 290d331..4808481 100644 --- a/llvm/unittests/ProfileData/MemProfTest.cpp +++ b/llvm/unittests/ProfileData/MemProfTest.cpp @@ -104,9 +104,9 @@ MATCHER_P4(FrameContains, FunctionName, LineOffset, Column, Inline, "") { *result_listener << "Hash mismatch"; return false; } - if (F.SymbolName && F.SymbolName.value() != FunctionName) { + if (F.SymbolName.hasValue() && F.SymbolName.getValue() != FunctionName) { *result_listener << "SymbolName mismatch\nWant: " << FunctionName - << "\nGot: " << F.SymbolName.value(); + << "\nGot: " << F.SymbolName.getValue(); return false; } if (F.LineOffset == LineOffset && F.Column == Column && diff --git a/llvm/unittests/Support/AlignmentTest.cpp b/llvm/unittests/Support/AlignmentTest.cpp index fa26b60..fa91997 100644 --- a/llvm/unittests/Support/AlignmentTest.cpp +++ b/llvm/unittests/Support/AlignmentTest.cpp @@ -63,11 +63,11 @@ TEST(AlignmentTest, ValidCTors) { TEST(AlignmentTest, CheckMaybeAlignHasValue) { EXPECT_TRUE(MaybeAlign(1)); - EXPECT_TRUE(MaybeAlign(1).has_value()); + EXPECT_TRUE(MaybeAlign(1).hasValue()); EXPECT_FALSE(MaybeAlign(0)); - EXPECT_FALSE(MaybeAlign(0).has_value()); + EXPECT_FALSE(MaybeAlign(0).hasValue()); EXPECT_FALSE(MaybeAlign()); - EXPECT_FALSE(MaybeAlign().has_value()); + EXPECT_FALSE(MaybeAlign().hasValue()); } TEST(AlignmentTest, Division) { @@ -165,8 +165,8 @@ TEST(AlignmentTest, isAligned_isAddrAligned) { MaybeAlign A(T.alignment); // Test Align if (A) { - EXPECT_EQ(isAligned(*A, T.offset), T.isAligned); - EXPECT_EQ(isAddrAligned(*A, T.forgedAddr()), T.isAligned); + EXPECT_EQ(isAligned(A.getValue(), T.offset), T.isAligned); + EXPECT_EQ(isAddrAligned(A.getValue(), T.forgedAddr()), T.isAligned); } } } diff --git a/llvm/unittests/Support/Casting.cpp b/llvm/unittests/Support/Casting.cpp index bebb36f..311fefd 100644 --- a/llvm/unittests/Support/Casting.cpp +++ b/llvm/unittests/Support/Casting.cpp @@ -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.has_value()); + EXPECT_FALSE(F1.hasValue()); T1 t1; Optional<T2> F2 = dyn_cast_if_present<T2>(t1); - EXPECT_TRUE(F2.has_value()); + EXPECT_TRUE(F2.hasValue()); T1 *t1Null = nullptr; diff --git a/llvm/unittests/Support/KnownBitsTest.cpp b/llvm/unittests/Support/KnownBitsTest.cpp index 1411c2e..9ef62bb 100644 --- a/llvm/unittests/Support/KnownBitsTest.cpp +++ b/llvm/unittests/Support/KnownBitsTest.cpp @@ -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.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 && *KnownEQ); - EXPECT_EQ(AllNE, KnownNE && *KnownNE); - EXPECT_EQ(AllUGT, KnownUGT && *KnownUGT); - EXPECT_EQ(AllUGE, KnownUGE && *KnownUGE); - EXPECT_EQ(AllULT, KnownULT && *KnownULT); - EXPECT_EQ(AllULE, KnownULE && *KnownULE); - EXPECT_EQ(AllSGT, KnownSGT && *KnownSGT); - EXPECT_EQ(AllSGE, KnownSGE && *KnownSGE); - EXPECT_EQ(AllSLT, KnownSLT && *KnownSLT); - EXPECT_EQ(AllSLE, KnownSLE && *KnownSLE); - - EXPECT_EQ(NoneEQ, KnownEQ && !*KnownEQ); - EXPECT_EQ(NoneNE, KnownNE && !*KnownNE); - EXPECT_EQ(NoneUGT, KnownUGT && !*KnownUGT); - EXPECT_EQ(NoneUGE, KnownUGE && !*KnownUGE); - EXPECT_EQ(NoneULT, KnownULT && !*KnownULT); - EXPECT_EQ(NoneULE, KnownULE && !*KnownULE); - EXPECT_EQ(NoneSGT, KnownSGT && !*KnownSGT); - EXPECT_EQ(NoneSGE, KnownSGE && !*KnownSGE); - EXPECT_EQ(NoneSLT, KnownSLT && !*KnownSLT); - EXPECT_EQ(NoneSLE, KnownSLE && !*KnownSLE); + 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, 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(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()); }); }); } diff --git a/llvm/unittests/Support/YAMLParserTest.cpp b/llvm/unittests/Support/YAMLParserTest.cpp index 14def9c..692d963 100644 --- a/llvm/unittests/Support/YAMLParserTest.cpp +++ b/llvm/unittests/Support/YAMLParserTest.cpp @@ -344,12 +344,12 @@ TEST(YAMLParser, FlowSequenceTokensOutsideFlowSequence) { static void expectCanParseBool(StringRef S, bool Expected) { llvm::Optional<bool> Parsed = yaml::parseBool(S); - EXPECT_TRUE(Parsed.has_value()); + EXPECT_TRUE(Parsed.hasValue()); EXPECT_EQ(*Parsed, Expected); } static void expectCannotParseBool(StringRef S) { - EXPECT_FALSE(yaml::parseBool(S).has_value()); + EXPECT_FALSE(yaml::parseBool(S).hasValue()); } TEST(YAMLParser, ParsesBools) { diff --git a/llvm/unittests/TableGen/ParserEntryPointTest.cpp b/llvm/unittests/TableGen/ParserEntryPointTest.cpp index a227f3d..23642b6 100644 --- a/llvm/unittests/TableGen/ParserEntryPointTest.cpp +++ b/llvm/unittests/TableGen/ParserEntryPointTest.cpp @@ -35,6 +35,6 @@ TEST(Parser, SanityTest) { Record *Foo = Records.getDef("Foo"); Optional<StringRef> Field = Foo->getValueAsOptionalString("strField"); - EXPECT_TRUE(Field.has_value()); - EXPECT_EQ(*Field, "value"); + EXPECT_TRUE(Field.hasValue()); + EXPECT_EQ(Field.getValue(), "value"); } diff --git a/llvm/utils/TableGen/GlobalISel/GIMatchTree.h b/llvm/utils/TableGen/GlobalISel/GIMatchTree.h index 55a8625..56df377 100644 --- a/llvm/utils/TableGen/GlobalISel/GIMatchTree.h +++ b/llvm/utils/TableGen/GlobalISel/GIMatchTree.h @@ -32,11 +32,11 @@ public: Optional<unsigned> OpIdx = None) : Name(Name), InstrID(InstrID), OpIdx(OpIdx) {} - bool isInstr() const { return !OpIdx; } + bool isInstr() const { return !OpIdx.hasValue(); } StringRef getName() const { return Name; } unsigned getInstrID() const { return InstrID; } unsigned getOpIdx() const { - assert(OpIdx && "Is not an operand binding"); + assert(OpIdx.hasValue() && "Is not an operand binding"); return *OpIdx; } }; diff --git a/llvm/utils/TableGen/GlobalISelEmitter.cpp b/llvm/utils/TableGen/GlobalISelEmitter.cpp index e5e216b..e4ea6da 100644 --- a/llvm/utils/TableGen/GlobalISelEmitter.cpp +++ b/llvm/utils/TableGen/GlobalISelEmitter.cpp @@ -2936,14 +2936,14 @@ public: } void emitRenderOpcodes(MatchTable &Table, RuleMatcher &Rule) const override { - Table << MatchTable::Opcode(SubOperand ? "GIR_ComplexSubOperandRenderer" - : "GIR_ComplexRenderer") + Table << MatchTable::Opcode(SubOperand.hasValue() ? "GIR_ComplexSubOperandRenderer" + : "GIR_ComplexRenderer") << MatchTable::Comment("InsnID") << MatchTable::IntValue(InsnID) << MatchTable::Comment("RendererID") << MatchTable::IntValue(RendererID); - if (SubOperand) + if (SubOperand.hasValue()) Table << MatchTable::Comment("SubOperand") - << MatchTable::IntValue(*SubOperand); + << MatchTable::IntValue(SubOperand.getValue()); Table << MatchTable::Comment(SymbolicName) << MatchTable::LineBreak; } }; @@ -4946,8 +4946,8 @@ Error GlobalISelEmitter::importDefaultOperandRenderers( auto Def = DefaultDefOp->getDef(); if (Def->getName() == "undef_tied_input") { unsigned TempRegID = M.allocateTempRegID(); - M.insertAction<MakeTempRegisterAction>(InsertPt, *OpTyOrNone, - TempRegID); + M.insertAction<MakeTempRegisterAction>( + InsertPt, OpTyOrNone.getValue(), TempRegID); InsertPt = M.insertAction<BuildMIAction>( InsertPt, M.allocateOutputInsnID(), &Target.getInstruction(RK.getDef("IMPLICIT_DEF"))); diff --git a/mlir/include/mlir/Dialect/Affine/Analysis/AffineStructures.h b/mlir/include/mlir/Dialect/Affine/Analysis/AffineStructures.h index d4f9414..b307f0d 100644 --- a/mlir/include/mlir/Dialect/Affine/Analysis/AffineStructures.h +++ b/mlir/include/mlir/Dialect/Affine/Analysis/AffineStructures.h @@ -400,13 +400,13 @@ public: inline Value getValue(unsigned pos) const { assert(pos < getNumDimAndSymbolIds() && "Invalid position"); assert(hasValue(pos) && "identifier's Value not set"); - return values[pos].value(); + return values[pos].getValue(); } /// Returns true if the pos^th identifier has an associated Value. inline bool hasValue(unsigned pos) const { assert(pos < getNumDimAndSymbolIds() && "Invalid position"); - return values[pos].has_value(); + return values[pos].hasValue(); } /// Returns true if at least one identifier has an associated Value. diff --git a/mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td b/mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td index 52a7ef3..1b547bb 100644 --- a/mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td +++ b/mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td @@ -347,8 +347,8 @@ def LLVM_FNegOp : LLVM_UnaryFloatArithmeticOp< // of LLVM ops that accept such an attribute. class MemoryOpWithAlignmentBase { code setAlignmentCode = [{ - if ($alignment) { - auto align = *$alignment; + if ($alignment.hasValue()) { + auto align = $alignment.getValue(); if (align != 0) inst->setAlignment(llvm::Align(align)); } diff --git a/mlir/include/mlir/Dialect/LLVMIR/NVVMOps.td b/mlir/include/mlir/Dialect/LLVMIR/NVVMOps.td index e51460e..24287f1 100644 --- a/mlir/include/mlir/Dialect/LLVMIR/NVVMOps.td +++ b/mlir/include/mlir/Dialect/LLVMIR/NVVMOps.td @@ -568,8 +568,8 @@ class MMA_SYNC_INTR { # op[1].ptx_elt_type # "\" == eltypeB && " # " \"" # op[2].ptx_elt_type # "\" == eltypeC && " # " \"" # op[3].ptx_elt_type # "\" == eltypeD " - # " && (sat ? " # sat # " == static_cast<int>(*sat) : true)" - # !if(!ne(b1op, ""), " && (b1Op ? MMAB1Op::" # b1op # " == *b1Op : true)", "") # ")\n" + # " && (sat.hasValue() ? " # sat # " == static_cast<int>(*sat) : true)" + # !if(!ne(b1op, ""), " && (b1Op.hasValue() ? MMAB1Op::" # b1op # " == b1Op.getValue() : true)", "") # ")\n" # " return " # MMA_SYNC_NAME<layoutA, layoutB, b1op, sat, op[0], op[1], op[2], op[3]>.id # ";", "") // if supported @@ -995,8 +995,8 @@ def NVVM_MmaOp : NVVM_Op<"mma.sync", [AttrSizedOperandSegments]> { $shape.getM(), $shape.getN(), $shape.getK(), $b1Op, $intOverflowBehavior, $layoutA, $layoutB, - *$multiplicandAPtxType, - *$multiplicandBPtxType, + $multiplicandAPtxType.getValue(), + $multiplicandBPtxType.getValue(), op.accumPtxType(), op.resultPtxType()); diff --git a/mlir/include/mlir/Dialect/Transform/IR/TransformInterfaces.h b/mlir/include/mlir/Dialect/Transform/IR/TransformInterfaces.h index 2aea098..ef891dd 100644 --- a/mlir/include/mlir/Dialect/Transform/IR/TransformInterfaces.h +++ b/mlir/include/mlir/Dialect/Transform/IR/TransformInterfaces.h @@ -75,11 +75,11 @@ public: } /// Returns `true` if this is a silencable failure. - bool isSilenceableFailure() const { return diagnostic.has_value(); } + bool isSilenceableFailure() const { return diagnostic.hasValue(); } /// Returns `true` if this is a success. bool succeeded() const { - return !diagnostic.has_value() && ::mlir::succeeded(result); + return !diagnostic.hasValue() && ::mlir::succeeded(result); } /// Returns the diagnostic message without emitting it. Expects this object diff --git a/mlir/include/mlir/IR/OpDefinition.h b/mlir/include/mlir/IR/OpDefinition.h index 6023172..42eccde 100644 --- a/mlir/include/mlir/IR/OpDefinition.h +++ b/mlir/include/mlir/IR/OpDefinition.h @@ -44,11 +44,11 @@ public: OptionalParseResult(llvm::NoneType) : impl(llvm::None) {} /// Returns true if we contain a valid ParseResult value. - bool has_value() const { return impl.has_value(); } + bool hasValue() const { return impl.hasValue(); } /// Access the internal ParseResult value. - ParseResult value() const { return impl.value(); } - ParseResult operator*() const { return value(); } + ParseResult getValue() const { return impl.getValue(); } + ParseResult operator*() const { return getValue(); } private: Optional<ParseResult> impl; diff --git a/mlir/include/mlir/IR/OpImplementation.h b/mlir/include/mlir/IR/OpImplementation.h index af75fed..2acb2c7 100644 --- a/mlir/include/mlir/IR/OpImplementation.h +++ b/mlir/include/mlir/IR/OpImplementation.h @@ -555,7 +555,7 @@ public: ParseResult parseInteger(IntT &result) { auto loc = getCurrentLocation(); OptionalParseResult parseResult = parseOptionalInteger(result); - if (!parseResult.has_value()) + if (!parseResult.hasValue()) return emitError(loc, "expected integer value"); return *parseResult; } @@ -570,7 +570,7 @@ public: // Parse the unsigned variant. APInt uintResult; OptionalParseResult parseResult = parseOptionalInteger(uintResult); - if (!parseResult.has_value() || failed(*parseResult)) + if (!parseResult.hasValue() || failed(*parseResult)) return parseResult; // Try to convert to the provided integer type. sextOrTrunc is correct even @@ -817,7 +817,7 @@ public: StringRef attrName, NamedAttrList &attrs) { OptionalParseResult parseResult = parseOptionalAttribute(result, type); - if (parseResult.has_value() && succeeded(*parseResult)) + if (parseResult.hasValue() && succeeded(*parseResult)) attrs.append(attrName, result); return parseResult; } @@ -1299,9 +1299,9 @@ public: ParseResult parseAssignmentList(SmallVectorImpl<Argument> &lhs, SmallVectorImpl<UnresolvedOperand> &rhs) { OptionalParseResult result = parseOptionalAssignmentList(lhs, rhs); - if (!result.has_value()) + if (!result.hasValue()) return emitError(getCurrentLocation(), "expected '('"); - return result.value(); + return result.getValue(); } virtual OptionalParseResult diff --git a/mlir/include/mlir/Support/LogicalResult.h b/mlir/include/mlir/Support/LogicalResult.h index b2cf736..2940828 100644 --- a/mlir/include/mlir/Support/LogicalResult.h +++ b/mlir/include/mlir/Support/LogicalResult.h @@ -90,12 +90,12 @@ public: FailureOr(const FailureOr<U> &other) : Optional<T>(failed(other) ? Optional<T>() : Optional<T>(*other)) {} - operator LogicalResult() const { return success(this->has_value()); } + operator LogicalResult() const { return success(this->hasValue()); } private: /// Hide the bool conversion as it easily creates confusion. using Optional<T>::operator bool; - using Optional<T>::has_value; + using Optional<T>::hasValue; }; /// This class represents success/failure for parsing-like operations that find diff --git a/mlir/include/mlir/TableGen/Operator.h b/mlir/include/mlir/TableGen/Operator.h index ab03a1a..6bac850 100644 --- a/mlir/include/mlir/TableGen/Operator.h +++ b/mlir/include/mlir/TableGen/Operator.h @@ -263,12 +263,12 @@ public: explicit ArgOrType(TypeConstraint constraint) : index(None), constraint(constraint) {} bool isArg() const { - assert(constraint.has_value() ^ index.has_value()); - return index.has_value(); + assert(constraint.hasValue() ^ index.hasValue()); + return index.hasValue(); } bool isType() const { - assert(constraint.has_value() ^ index.has_value()); - return constraint.has_value(); + assert(constraint.hasValue() ^ index.hasValue()); + return constraint.hasValue(); } int getArg() const { return *index; } diff --git a/mlir/include/mlir/Transforms/DialectConversion.h b/mlir/include/mlir/Transforms/DialectConversion.h index 678bf02..feac434 100644 --- a/mlir/include/mlir/Transforms/DialectConversion.h +++ b/mlir/include/mlir/Transforms/DialectConversion.h @@ -251,9 +251,9 @@ private: [callback = std::forward<FnT>(callback)]( T type, SmallVectorImpl<Type> &results, ArrayRef<Type>) { if (Optional<Type> resultOpt = callback(type)) { - bool wasSuccess = static_cast<bool>(resultOpt.value()); + bool wasSuccess = static_cast<bool>(resultOpt.getValue()); if (wasSuccess) - results.push_back(resultOpt.value()); + results.push_back(resultOpt.getValue()); return Optional<LogicalResult>(success(wasSuccess)); } return Optional<LogicalResult>(); diff --git a/mlir/lib/Analysis/Presburger/IntegerRelation.cpp b/mlir/lib/Analysis/Presburger/IntegerRelation.cpp index baeb467..7376747 100644 --- a/mlir/lib/Analysis/Presburger/IntegerRelation.cpp +++ b/mlir/lib/Analysis/Presburger/IntegerRelation.cpp @@ -2015,14 +2015,14 @@ IntegerRelation::unionBoundingBox(const IntegerRelation &otherCst) { int64_t lbFloorDivisor, otherLbFloorDivisor; for (unsigned d = 0, e = getNumDimIds(); d < e; ++d) { auto extent = getConstantBoundOnDimSize(d, &lb, &lbFloorDivisor, &ub); - if (!extent.has_value()) + if (!extent.hasValue()) // TODO: symbolic extents when necessary. // TODO: handle union if a dimension is unbounded. return failure(); auto otherExtent = otherCst.getConstantBoundOnDimSize( d, &otherLb, &otherLbFloorDivisor, &otherUb); - if (!otherExtent.has_value() || lbFloorDivisor != otherLbFloorDivisor) + if (!otherExtent.hasValue() || lbFloorDivisor != otherLbFloorDivisor) // TODO: symbolic extents when necessary. return failure(); @@ -2043,10 +2043,10 @@ IntegerRelation::unionBoundingBox(const IntegerRelation &otherCst) { // Uncomparable - check for constant lower/upper bounds. auto constLb = getConstantBound(BoundType::LB, d); auto constOtherLb = otherCst.getConstantBound(BoundType::LB, d); - if (!constLb.has_value() || !constOtherLb.has_value()) + if (!constLb.hasValue() || !constOtherLb.hasValue()) return failure(); std::fill(minLb.begin(), minLb.end(), 0); - minLb.back() = std::min(*constLb, constOtherLb.value()); + minLb.back() = std::min(constLb.getValue(), constOtherLb.getValue()); } // Do the same for ub's but max of upper bounds. Identify max. @@ -2059,10 +2059,10 @@ IntegerRelation::unionBoundingBox(const IntegerRelation &otherCst) { // Uncomparable - check for constant lower/upper bounds. auto constUb = getConstantBound(BoundType::UB, d); auto constOtherUb = otherCst.getConstantBound(BoundType::UB, d); - if (!constUb.has_value() || !constOtherUb.has_value()) + if (!constUb.hasValue() || !constOtherUb.hasValue()) return failure(); std::fill(maxUb.begin(), maxUb.end(), 0); - maxUb.back() = std::max(*constUb, constOtherUb.value()); + maxUb.back() = std::max(constUb.getValue(), constOtherUb.getValue()); } std::fill(newLb.begin(), newLb.end(), 0); diff --git a/mlir/lib/Conversion/SPIRVToLLVM/SPIRVToLLVM.cpp b/mlir/lib/Conversion/SPIRVToLLVM/SPIRVToLLVM.cpp index 3d2dae5..6e0f007 100644 --- a/mlir/lib/Conversion/SPIRVToLLVM/SPIRVToLLVM.cpp +++ b/mlir/lib/Conversion/SPIRVToLLVM/SPIRVToLLVM.cpp @@ -645,8 +645,8 @@ public: ModuleOp module = op->getParentOfType<ModuleOp>(); IntegerAttr executionModeAttr = op.execution_modeAttr(); std::string moduleName; - if (module.getName().has_value()) - moduleName = "_" + module.getName()->str(); + if (module.getName().hasValue()) + moduleName = "_" + module.getName().getValue().str(); else moduleName = ""; std::string executionModeInfoName = @@ -1585,10 +1585,10 @@ void mlir::encodeBindAttribute(ModuleOp module) { if (descriptorSet && binding) { // Encode these numbers into the variable's symbolic name. If the // SPIR-V module has a name, add it at the beginning. - auto moduleAndName = - spvModule.getName().has_value() - ? spvModule.getName()->str() + "_" + op.sym_name().str() - : op.sym_name().str(); + auto moduleAndName = spvModule.getName().hasValue() + ? spvModule.getName().getValue().str() + "_" + + op.sym_name().str() + : op.sym_name().str(); std::string name = llvm::formatv("{0}_descriptor_set{1}_binding{2}", moduleAndName, std::to_string(descriptorSet.getInt()), diff --git a/mlir/lib/Conversion/TosaToLinalg/TosaToLinalg.cpp b/mlir/lib/Conversion/TosaToLinalg/TosaToLinalg.cpp index c7917a4..133a363 100644 --- a/mlir/lib/Conversion/TosaToLinalg/TosaToLinalg.cpp +++ b/mlir/lib/Conversion/TosaToLinalg/TosaToLinalg.cpp @@ -147,8 +147,8 @@ createLinalgBodyCalculationForElementwiseOp(Operation *op, ValueRange args, cast<tosa::NegateOp>(op).quantization_info()) { auto quantizationInfo = cast<tosa::NegateOp>(op).quantization_info(); int32_t inputBitWidth = elementTy.getIntOrFloatBitWidth(); - int64_t inZp = quantizationInfo->getInputZp(); - int64_t outZp = quantizationInfo->getOutputZp(); + int64_t inZp = quantizationInfo.getValue().getInputZp(); + int64_t outZp = quantizationInfo.getValue().getOutputZp(); // Compute the maximum value that can occur in the intermediate buffer. int64_t zpAdd = inZp + outZp; @@ -1153,9 +1153,9 @@ public: auto dynamicDimsOr = checkHasDynamicBatchDims(rewriter, op, {input, op.output()}); - if (!dynamicDimsOr.has_value()) + if (!dynamicDimsOr.hasValue()) return failure(); - SmallVector<Value> dynamicDims = dynamicDimsOr.value(); + SmallVector<Value> dynamicDims = dynamicDimsOr.getValue(); // The shift and multiplier values. SmallVector<int32_t> multiplierValues; @@ -1345,9 +1345,9 @@ public: auto dynamicDimsOr = checkHasDynamicBatchDims(rewriter, op, {input, op.output()}); - if (!dynamicDimsOr.has_value()) + if (!dynamicDimsOr.hasValue()) return failure(); - SmallVector<Value> dynamicDims = dynamicDimsOr.value(); + SmallVector<Value> dynamicDims = dynamicDimsOr.getValue(); if (op.mode() != "NEAREST_NEIGHBOR" && op.mode() != "BILINEAR") return failure(); @@ -2040,9 +2040,9 @@ public: auto dynamicDimsOr = checkHasDynamicBatchDims(rewriter, op, {input, indices, op.output()}); - if (!dynamicDimsOr.has_value()) + if (!dynamicDimsOr.hasValue()) return failure(); - SmallVector<Value> dynamicDims = dynamicDimsOr.value(); + SmallVector<Value> dynamicDims = dynamicDimsOr.getValue(); auto resultElementTy = resultTy.getElementType(); diff --git a/mlir/lib/Conversion/TosaToLinalg/TosaToLinalgNamed.cpp b/mlir/lib/Conversion/TosaToLinalg/TosaToLinalgNamed.cpp index 531824c..866fea8 100644 --- a/mlir/lib/Conversion/TosaToLinalg/TosaToLinalgNamed.cpp +++ b/mlir/lib/Conversion/TosaToLinalg/TosaToLinalgNamed.cpp @@ -694,9 +694,9 @@ public: auto dynamicDimsOr = checkHasDynamicBatchDims(rewriter, op, {input, op.output()}); - if (!dynamicDimsOr.has_value()) + if (!dynamicDimsOr.hasValue()) return failure(); - SmallVector<Value> dynamicDims = dynamicDimsOr.value(); + SmallVector<Value> dynamicDims = dynamicDimsOr.getValue(); // Determine what the initial value needs to be for the max pool op. Attribute initialAttr; @@ -771,9 +771,9 @@ public: auto dynamicDimsOr = checkHasDynamicBatchDims(rewriter, op, {input, op.output()}); - if (!dynamicDimsOr.has_value()) + if (!dynamicDimsOr.hasValue()) return failure(); - SmallVector<Value> dynamicDims = dynamicDimsOr.value(); + SmallVector<Value> dynamicDims = dynamicDimsOr.getValue(); // Apply padding as necessary. llvm::SmallVector<int64_t> pad; diff --git a/mlir/lib/Conversion/VectorToSCF/VectorToSCF.cpp b/mlir/lib/Conversion/VectorToSCF/VectorToSCF.cpp index 2356136..9ead9e2 100644 --- a/mlir/lib/Conversion/VectorToSCF/VectorToSCF.cpp +++ b/mlir/lib/Conversion/VectorToSCF/VectorToSCF.cpp @@ -90,12 +90,12 @@ static void getXferIndices(OpBuilder &b, OpTy xferOp, Value iv, indices.append(prevIndices.begin(), prevIndices.end()); Location loc = xferOp.getLoc(); - bool isBroadcast = !dim.has_value(); + bool isBroadcast = !dim.hasValue(); if (!isBroadcast) { AffineExpr d0, d1; bindDims(xferOp.getContext(), d0, d1); - Value offset = adaptor.getIndices()[dim.value()]; - indices[dim.value()] = + Value offset = adaptor.getIndices()[dim.getValue()]; + indices[dim.getValue()] = makeComposedAffineApply(b, loc, d0 + d1, {offset, iv}); } } diff --git a/mlir/lib/Dialect/Affine/Analysis/AffineStructures.cpp b/mlir/lib/Dialect/Affine/Analysis/AffineStructures.cpp index 1ce9c3c..e1e6621 100644 --- a/mlir/lib/Dialect/Affine/Analysis/AffineStructures.cpp +++ b/mlir/lib/Dialect/Affine/Analysis/AffineStructures.cpp @@ -322,7 +322,7 @@ unsigned FlatAffineValueConstraints::insertId(IdKind kind, unsigned pos, bool FlatAffineValueConstraints::hasValues() const { return llvm::find_if(values, [](Optional<Value> id) { - return id.has_value(); + return id.hasValue(); }) != values.end(); } @@ -401,11 +401,11 @@ static void mergeAndAlignIds(unsigned offset, FlatAffineValueConstraints *a, assert(std::all_of(a->getMaybeValues().begin() + offset, a->getMaybeValues().end(), - [](Optional<Value> id) { return id.has_value(); })); + [](Optional<Value> id) { return id.hasValue(); })); assert(std::all_of(b->getMaybeValues().begin() + offset, b->getMaybeValues().end(), - [](Optional<Value> id) { return id.has_value(); })); + [](Optional<Value> id) { return id.hasValue(); })); SmallVector<Value, 4> aDimValues; a->getValues(offset, a->getNumDimIds(), &aDimValues); @@ -1008,18 +1008,18 @@ void FlatAffineValueConstraints::getSliceBounds( auto lbConst = getConstantBound(BoundType::LB, pos); auto ubConst = getConstantBound(BoundType::UB, pos); - if (lbConst.has_value() && ubConst.has_value()) { + if (lbConst.hasValue() && ubConst.hasValue()) { // Detect equality to a constant. - if (lbConst.value() == ubConst.value()) { - memo[pos] = getAffineConstantExpr(*lbConst, context); + if (lbConst.getValue() == ubConst.getValue()) { + memo[pos] = getAffineConstantExpr(lbConst.getValue(), context); changed = true; continue; } // Detect an identifier as modulo of another identifier w.r.t a // constant. - if (detectAsMod(*this, pos, lbConst.value(), ubConst.value(), memo, - context)) { + if (detectAsMod(*this, pos, lbConst.getValue(), ubConst.getValue(), + memo, context)) { changed = true; continue; } @@ -1119,19 +1119,21 @@ void FlatAffineValueConstraints::getSliceBounds( LLVM_DEBUG(llvm::dbgs() << "WARNING: Potentially over-approximating slice lb\n"); auto lbConst = getConstantBound(BoundType::LB, pos + offset); - if (lbConst) { - lbMap = AffineMap::get(numMapDims, numMapSymbols, - getAffineConstantExpr(*lbConst, context)); + if (lbConst.hasValue()) { + lbMap = AffineMap::get( + numMapDims, numMapSymbols, + getAffineConstantExpr(lbConst.getValue(), context)); } } if (!ubMap || ubMap.getNumResults() > 1) { LLVM_DEBUG(llvm::dbgs() << "WARNING: Potentially over-approximating slice ub\n"); auto ubConst = getConstantBound(BoundType::UB, pos + offset); - if (ubConst) { - ubMap = AffineMap::get( - numMapDims, numMapSymbols, - getAffineConstantExpr(ubConst.value() + ubAdjustment, context)); + if (ubConst.hasValue()) { + ubMap = + AffineMap::get(numMapDims, numMapSymbols, + getAffineConstantExpr( + ubConst.getValue() + ubAdjustment, context)); } } } @@ -1669,13 +1671,13 @@ void FlatAffineRelation::compose(const FlatAffineRelation &other) { // Add and match domain of `rel` to domain of `this`. for (unsigned i = 0, e = rel.getNumDomainDims(); i < e; ++i) - if (relMaybeValues[i].has_value()) - setValue(i, relMaybeValues[i].value()); + if (relMaybeValues[i].hasValue()) + setValue(i, relMaybeValues[i].getValue()); // Add and match range of `this` to range of `rel`. for (unsigned i = 0, e = getNumRangeDims(); i < e; ++i) { unsigned rangeIdx = rel.getNumDomainDims() + i; - if (thisMaybeValues[rangeIdx].has_value()) - rel.setValue(rangeIdx, thisMaybeValues[rangeIdx].value()); + if (thisMaybeValues[rangeIdx].hasValue()) + rel.setValue(rangeIdx, thisMaybeValues[rangeIdx].getValue()); } // Append `this` to `rel` and simplify constraints. diff --git a/mlir/lib/Dialect/Affine/Analysis/LoopAnalysis.cpp b/mlir/lib/Dialect/Affine/Analysis/LoopAnalysis.cpp index f8c43e7..0620a59 100644 --- a/mlir/lib/Dialect/Affine/Analysis/LoopAnalysis.cpp +++ b/mlir/lib/Dialect/Affine/Analysis/LoopAnalysis.cpp @@ -92,9 +92,9 @@ Optional<uint64_t> mlir::getConstantTripCount(AffineForOp forOp) { Optional<uint64_t> tripCount; for (auto resultExpr : map.getResults()) { if (auto constExpr = resultExpr.dyn_cast<AffineConstantExpr>()) { - if (tripCount) - tripCount = - std::min(*tripCount, static_cast<uint64_t>(constExpr.getValue())); + if (tripCount.hasValue()) + tripCount = std::min(tripCount.getValue(), + static_cast<uint64_t>(constExpr.getValue())); else tripCount = constExpr.getValue(); } else @@ -132,13 +132,13 @@ uint64_t mlir::getLargestDivisorOfTripCount(AffineForOp forOp) { // Trip count is not a known constant; return its largest known divisor. thisGcd = resultExpr.getLargestKnownDivisor(); } - if (gcd) - gcd = llvm::GreatestCommonDivisor64(*gcd, thisGcd); + if (gcd.hasValue()) + gcd = llvm::GreatestCommonDivisor64(gcd.getValue(), thisGcd); else gcd = thisGcd; } - assert(gcd.has_value() && "value expected per above logic"); - return gcd.value(); + assert(gcd.hasValue() && "value expected per above logic"); + return gcd.getValue(); } /// Given an induction variable `iv` of type AffineForOp and an access `index` diff --git a/mlir/lib/Dialect/Affine/Analysis/Utils.cpp b/mlir/lib/Dialect/Affine/Analysis/Utils.cpp index 5015706..6a9a0388 100644 --- a/mlir/lib/Dialect/Affine/Analysis/Utils.cpp +++ b/mlir/lib/Dialect/Affine/Analysis/Utils.cpp @@ -375,8 +375,8 @@ Optional<int64_t> MemRefRegion::getConstantBoundingSizeAndShape( SmallVector<int64_t, 4> lb; Optional<int64_t> diff = cstWithShapeBounds.getConstantBoundOnDimSize(d, &lb, &lbDivisor); - if (diff) { - diffConstant = diff.value(); + if (diff.hasValue()) { + diffConstant = diff.getValue(); assert(diffConstant >= 0 && "Dim size bound can't be negative"); assert(lbDivisor > 0); } else { @@ -1012,17 +1012,17 @@ bool mlir::buildSliceTripCountMap( continue; } Optional<uint64_t> maybeConstTripCount = getConstantTripCount(forOp); - if (maybeConstTripCount) { - (*tripCountMap)[op] = maybeConstTripCount.value(); + if (maybeConstTripCount.hasValue()) { + (*tripCountMap)[op] = maybeConstTripCount.getValue(); continue; } return false; } Optional<uint64_t> tripCount = getConstDifference(lbMap, ubMap); // Slice bounds are created with a constant ub - lb difference. - if (!tripCount.has_value()) + if (!tripCount.hasValue()) return false; - (*tripCountMap)[op] = tripCount.value(); + (*tripCountMap)[op] = tripCount.getValue(); } return true; } @@ -1320,9 +1320,9 @@ static Optional<int64_t> getMemoryFootprintBytes(Block &block, int64_t totalSizeInBytes = 0; for (const auto ®ion : regions) { Optional<int64_t> size = region.second->getRegionSize(); - if (!size.has_value()) + if (!size.hasValue()) return None; - totalSizeInBytes += size.value(); + totalSizeInBytes += size.getValue(); } return totalSizeInBytes; } diff --git a/mlir/lib/Dialect/Affine/IR/AffineOps.cpp b/mlir/lib/Dialect/Affine/IR/AffineOps.cpp index 6a6827c..01f651d 100644 --- a/mlir/lib/Dialect/Affine/IR/AffineOps.cpp +++ b/mlir/lib/Dialect/Affine/IR/AffineOps.cpp @@ -336,8 +336,9 @@ static bool isDimOpValidSymbol(OpTy dimOp, Region *region) { // The dim op is also okay if its operand memref is a view/subview whose // corresponding size is a valid symbol. Optional<int64_t> index = dimOp.getConstantIndex(); - assert(index && "expect only `dim` operations with a constant index"); - int64_t i = *index; + assert(index.hasValue() && + "expect only `dim` operations with a constant index"); + int64_t i = index.getValue(); return TypeSwitch<Operation *, bool>(dimOp.source().getDefiningOp()) .Case<memref::ViewOp, memref::SubViewOp, memref::AllocOp>( [&](auto op) { return isMemRefSizeValidSymbol(op, i, region); }) @@ -1712,12 +1713,12 @@ struct AffineForEmptyLoopFolder : public OpRewritePattern<AffineForOp> { } // Bail out when the trip count is unknown and the loop returns any value // defined outside of the loop or any iterArg out of order. - if (!tripCount.has_value() && + if (!tripCount.hasValue() && (hasValDefinedOutsideLoop || iterArgsNotInOrder)) return failure(); // Bail out when the loop iterates more than once and it returns any iterArg // out of order. - if (tripCount.has_value() && *tripCount >= 2 && iterArgsNotInOrder) + if (tripCount.hasValue() && tripCount.getValue() >= 2 && iterArgsNotInOrder) return failure(); rewriter.replaceOp(forOp, replacements); return success(); @@ -1750,18 +1751,19 @@ OperandRange AffineForOp::getSuccessorEntryOperands(Optional<unsigned> index) { void AffineForOp::getSuccessorRegions( Optional<unsigned> index, ArrayRef<Attribute> operands, SmallVectorImpl<RegionSuccessor> ®ions) { - assert((!index || *index == 0) && "expected loop region"); + assert((!index.hasValue() || index.getValue() == 0) && + "expected loop region"); // The loop may typically branch back to its body or to the parent operation. // If the predecessor is the parent op and the trip count is known to be at // least one, branch into the body using the iterator arguments. And in cases // we know the trip count is zero, it can only branch back to its parent. Optional<uint64_t> tripCount = getTrivialConstantTripCount(*this); - if (!index && tripCount) { - if (tripCount.value() > 0) { + if (!index.hasValue() && tripCount.hasValue()) { + if (tripCount.getValue() > 0) { regions.push_back(RegionSuccessor(&getLoopBody(), getRegionIterArgs())); return; } - if (tripCount.value() == 0) { + if (tripCount.getValue() == 0) { regions.push_back(RegionSuccessor(getResults())); return; } @@ -3588,8 +3590,8 @@ ParseResult AffineParallelOp::parse(OpAsmParser &parser, arith::symbolizeAtomicRMWKind(attrVal.getValue()); if (!reduction) return parser.emitError(loc, "invalid reduction value: ") << attrVal; - reductions.push_back( - builder.getI64IntegerAttr(static_cast<int64_t>(reduction.value()))); + reductions.push_back(builder.getI64IntegerAttr( + static_cast<int64_t>(reduction.getValue()))); // While we keep getting commas, keep parsing. return success(); }; diff --git a/mlir/lib/Dialect/Affine/Transforms/AffineDataCopyGeneration.cpp b/mlir/lib/Dialect/Affine/Transforms/AffineDataCopyGeneration.cpp index 18a10c4..864f109 100644 --- a/mlir/lib/Dialect/Affine/Transforms/AffineDataCopyGeneration.cpp +++ b/mlir/lib/Dialect/Affine/Transforms/AffineDataCopyGeneration.cpp @@ -142,8 +142,9 @@ void AffineDataCopyGeneration::runOnBlock(Block *block, Optional<int64_t> footprint = getMemoryFootprintBytes(forOp, /*memorySpace=*/0); - return (footprint && - static_cast<uint64_t>(*footprint) > fastMemCapacityBytes); + return (footprint.hasValue() && + static_cast<uint64_t>(footprint.getValue()) > + fastMemCapacityBytes); }; // If the memory footprint of the 'affine.for' loop is higher than fast diff --git a/mlir/lib/Dialect/Affine/Transforms/LoopFusion.cpp b/mlir/lib/Dialect/Affine/Transforms/LoopFusion.cpp index f686620..b77ef90 100644 --- a/mlir/lib/Dialect/Affine/Transforms/LoopFusion.cpp +++ b/mlir/lib/Dialect/Affine/Transforms/LoopFusion.cpp @@ -441,15 +441,15 @@ public: ++pos; } - if (firstSrcDepPos) { - if (lastDstDepPos) { - if (firstSrcDepPos.value() <= lastDstDepPos.value()) { + if (firstSrcDepPos.hasValue()) { + if (lastDstDepPos.hasValue()) { + if (firstSrcDepPos.getValue() <= lastDstDepPos.getValue()) { // No valid insertion point exists which preserves dependences. return nullptr; } } // Return the insertion point at 'firstSrcDepPos'. - return depInsts[firstSrcDepPos.value()]; + return depInsts[firstSrcDepPos.getValue()]; } // No dependence targets in range (or only dst deps in range), return // 'dstNodInst' insertion point. @@ -942,10 +942,10 @@ static Value createPrivateMemRef(AffineForOp forOp, Operation *srcStoreOpInst, // Create 'newMemRefType' using 'newShape' from MemRefRegion accessed // by 'srcStoreOpInst'. uint64_t bufSize = - getMemRefEltSizeInBytes(oldMemRefType) * numElements.value(); + getMemRefEltSizeInBytes(oldMemRefType) * numElements.getValue(); unsigned newMemSpace; - if (bufSize <= localBufSizeThreshold && fastMemorySpace.has_value()) { - newMemSpace = fastMemorySpace.value(); + if (bufSize <= localBufSizeThreshold && fastMemorySpace.hasValue()) { + newMemSpace = fastMemorySpace.getValue(); } else { newMemSpace = oldMemRefType.getMemorySpaceAsInt(); } @@ -1141,9 +1141,9 @@ static bool isFusionProfitable(Operation *srcOpInst, Operation *srcStoreOpInst, Optional<int64_t> maybeSrcWriteRegionSizeBytes = srcWriteRegion.getRegionSize(); - if (!maybeSrcWriteRegionSizeBytes.has_value()) + if (!maybeSrcWriteRegionSizeBytes.hasValue()) return false; - int64_t srcWriteRegionSizeBytes = maybeSrcWriteRegionSizeBytes.value(); + int64_t srcWriteRegionSizeBytes = maybeSrcWriteRegionSizeBytes.getValue(); // Compute op instance count for the src loop nest. uint64_t dstLoopNestCost = getComputeCost(dstForOp, dstLoopNestStats); @@ -1183,14 +1183,15 @@ static bool isFusionProfitable(Operation *srcOpInst, Operation *srcStoreOpInst, Optional<int64_t> maybeSliceWriteRegionSizeBytes = sliceWriteRegion.getRegionSize(); - if (!maybeSliceWriteRegionSizeBytes.has_value() || - *maybeSliceWriteRegionSizeBytes == 0) { + if (!maybeSliceWriteRegionSizeBytes.hasValue() || + maybeSliceWriteRegionSizeBytes.getValue() == 0) { LLVM_DEBUG(llvm::dbgs() << "Failed to get slice write region size at loopDepth: " << i << "\n"); continue; } - int64_t sliceWriteRegionSizeBytes = maybeSliceWriteRegionSizeBytes.value(); + int64_t sliceWriteRegionSizeBytes = + maybeSliceWriteRegionSizeBytes.getValue(); // If we are fusing for reuse, check that write regions remain the same. // TODO: Write region check should check sizes and offsets in @@ -1267,11 +1268,11 @@ static bool isFusionProfitable(Operation *srcOpInst, Operation *srcStoreOpInst, return false; } - auto srcMemSizeVal = srcMemSize.value(); - auto dstMemSizeVal = dstMemSize.value(); + auto srcMemSizeVal = srcMemSize.getValue(); + auto dstMemSizeVal = dstMemSize.getValue(); assert(sliceMemEstimate && "expected value"); - auto fusedMem = dstMemSizeVal + sliceMemEstimate.value(); + auto fusedMem = dstMemSizeVal + sliceMemEstimate.getValue(); LLVM_DEBUG(llvm::dbgs() << " src mem: " << srcMemSizeVal << "\n" << " dst mem: " << dstMemSizeVal << "\n" diff --git a/mlir/lib/Dialect/Affine/Utils/LoopUtils.cpp b/mlir/lib/Dialect/Affine/Utils/LoopUtils.cpp index 04586c9..09f11eb 100644 --- a/mlir/lib/Dialect/Affine/Utils/LoopUtils.cpp +++ b/mlir/lib/Dialect/Affine/Utils/LoopUtils.cpp @@ -405,13 +405,13 @@ checkTilingLegalityImpl(MutableArrayRef<mlir::AffineForOp> origLoops) { LLVM_DEBUG(dstAccess.opInst->dump();); for (unsigned k = 0, e = depComps.size(); k < e; k++) { DependenceComponent depComp = depComps[k]; - if (depComp.lb.has_value() && depComp.ub.has_value() && - depComp.lb.value() < depComp.ub.value() && - depComp.ub.value() < 0) { + if (depComp.lb.hasValue() && depComp.ub.hasValue() && + depComp.lb.getValue() < depComp.ub.getValue() && + depComp.ub.getValue() < 0) { LLVM_DEBUG(llvm::dbgs() << "Dependence component lb = " - << Twine(depComp.lb.value()) - << " ub = " << Twine(depComp.ub.value()) + << Twine(depComp.lb.getValue()) + << " ub = " << Twine(depComp.ub.getValue()) << " is negative at depth: " << Twine(d) << " and thus violates the legality rule.\n"); return false; @@ -802,11 +802,11 @@ constructTiledIndexSetHyperRect(MutableArrayRef<AffineForOp> origLoops, newLoops[width + i].setStep(origLoops[i].getStep()); // Set the upper bound. - if (mayBeConstantCount && *mayBeConstantCount < tileSizes[i]) { + if (mayBeConstantCount && mayBeConstantCount.getValue() < tileSizes[i]) { // Trip count is less than the tile size: upper bound is lower bound + // trip count * stepSize. - AffineMap ubMap = b.getSingleDimShiftAffineMap(*mayBeConstantCount * - origLoops[i].getStep()); + AffineMap ubMap = b.getSingleDimShiftAffineMap( + mayBeConstantCount.getValue() * origLoops[i].getStep()); newLoops[width + i].setUpperBound( /*operands=*/newLoops[i].getInductionVar(), ubMap); } else if (largestDiv % tileSizes[i] != 0) { @@ -974,8 +974,8 @@ void mlir::getTileableBands(func::FuncOp f, /// Unrolls this loop completely. LogicalResult mlir::loopUnrollFull(AffineForOp forOp) { Optional<uint64_t> mayBeConstantTripCount = getConstantTripCount(forOp); - if (mayBeConstantTripCount) { - uint64_t tripCount = mayBeConstantTripCount.value(); + if (mayBeConstantTripCount.hasValue()) { + uint64_t tripCount = mayBeConstantTripCount.getValue(); if (tripCount == 0) return success(); if (tripCount == 1) @@ -990,8 +990,9 @@ LogicalResult mlir::loopUnrollFull(AffineForOp forOp) { LogicalResult mlir::loopUnrollUpToFactor(AffineForOp forOp, uint64_t unrollFactor) { Optional<uint64_t> mayBeConstantTripCount = getConstantTripCount(forOp); - if (mayBeConstantTripCount && *mayBeConstantTripCount < unrollFactor) - return loopUnrollByFactor(forOp, mayBeConstantTripCount.value()); + if (mayBeConstantTripCount.hasValue() && + mayBeConstantTripCount.getValue() < unrollFactor) + return loopUnrollByFactor(forOp, mayBeConstantTripCount.getValue()); return loopUnrollByFactor(forOp, unrollFactor); } @@ -1149,8 +1150,9 @@ LogicalResult mlir::loopUnrollByFactor( LogicalResult mlir::loopUnrollJamUpToFactor(AffineForOp forOp, uint64_t unrollJamFactor) { Optional<uint64_t> mayBeConstantTripCount = getConstantTripCount(forOp); - if (mayBeConstantTripCount && *mayBeConstantTripCount < unrollJamFactor) - return loopUnrollJamByFactor(forOp, mayBeConstantTripCount.value()); + if (mayBeConstantTripCount.hasValue() && + mayBeConstantTripCount.getValue() < unrollJamFactor) + return loopUnrollJamByFactor(forOp, mayBeConstantTripCount.getValue()); return loopUnrollJamByFactor(forOp, unrollJamFactor); } @@ -1571,8 +1573,8 @@ AffineForOp mlir::sinkSequentialLoops(AffineForOp forOp) { assert(depComps.size() >= maxLoopDepth); for (unsigned j = 0; j < maxLoopDepth; ++j) { DependenceComponent &depComp = depComps[j]; - assert(depComp.lb.has_value() && depComp.ub.has_value()); - if (depComp.lb.value() != 0 || depComp.ub.value() != 0) + assert(depComp.lb.hasValue() && depComp.ub.hasValue()); + if (depComp.lb.getValue() != 0 || depComp.ub.getValue() != 0) isParallelLoop[j] = false; } } @@ -2404,12 +2406,12 @@ LogicalResult mlir::affineDataCopyGenerate(Block::iterator begin, block->walk(begin, end, [&](Operation *opInst) { // Gather regions to allocate to buffers in faster memory space. if (auto loadOp = dyn_cast<AffineLoadOp>(opInst)) { - if ((filterMemRef.has_value() && filterMemRef != loadOp.getMemRef()) || + if ((filterMemRef.hasValue() && filterMemRef != loadOp.getMemRef()) || (loadOp.getMemRefType().getMemorySpaceAsInt() != copyOptions.slowMemorySpace)) return; } else if (auto storeOp = dyn_cast<AffineStoreOp>(opInst)) { - if ((filterMemRef.has_value() && filterMemRef != storeOp.getMemRef()) || + if ((filterMemRef.hasValue() && filterMemRef != storeOp.getMemRef()) || storeOp.getMemRefType().getMemorySpaceAsInt() != copyOptions.slowMemorySpace) return; diff --git a/mlir/lib/Dialect/Affine/Utils/Utils.cpp b/mlir/lib/Dialect/Affine/Utils/Utils.cpp index 5cfebeb..5f9eee5 100644 --- a/mlir/lib/Dialect/Affine/Utils/Utils.cpp +++ b/mlir/lib/Dialect/Affine/Utils/Utils.cpp @@ -1792,11 +1792,11 @@ MemRefType mlir::normalizeMemRefType(MemRefType memrefType, OpBuilder b, // For a static memref and an affine map with no symbols, this is // always bounded. assert(ubConst && "should always have an upper bound"); - if (ubConst.value() < 0) + if (ubConst.getValue() < 0) // This is due to an invalid map that maps to a negative space. return memrefType; // If dimension of new memrefType is dynamic, the value is -1. - newShape[d] = *ubConst + 1; + newShape[d] = ubConst.getValue() + 1; } } diff --git a/mlir/lib/Dialect/Arithmetic/Transforms/UnsignedWhenEquivalent.cpp b/mlir/lib/Dialect/Arithmetic/Transforms/UnsignedWhenEquivalent.cpp index f4e0415..f84990d 100644 --- a/mlir/lib/Dialect/Arithmetic/Transforms/UnsignedWhenEquivalent.cpp +++ b/mlir/lib/Dialect/Arithmetic/Transforms/UnsignedWhenEquivalent.cpp @@ -23,9 +23,9 @@ using namespace mlir::arith; static LogicalResult staticallyNonNegative(IntRangeAnalysis &analysis, Value v) { Optional<ConstantIntRanges> result = analysis.getResult(v); - if (!result.has_value()) + if (!result.hasValue()) return failure(); - const ConstantIntRanges &range = result.value(); + const ConstantIntRanges &range = result.getValue(); return success(range.smin().isNonNegative()); } diff --git a/mlir/lib/Dialect/Bufferization/IR/BufferizationOps.cpp b/mlir/lib/Dialect/Bufferization/IR/BufferizationOps.cpp index 20273c6..37ff8e9 100644 --- a/mlir/lib/Dialect/Bufferization/IR/BufferizationOps.cpp +++ b/mlir/lib/Dialect/Bufferization/IR/BufferizationOps.cpp @@ -444,11 +444,11 @@ struct SimplifyClones : public OpRewritePattern<CloneOp> { llvm::Optional<Operation *> maybeCloneDeallocOp = memref::findDealloc(cloneOp.getOutput()); // Skip if either of them has > 1 deallocate operations. - if (!maybeCloneDeallocOp.has_value()) + if (!maybeCloneDeallocOp.hasValue()) return failure(); llvm::Optional<Operation *> maybeSourceDeallocOp = memref::findDealloc(source); - if (!maybeSourceDeallocOp.has_value()) + if (!maybeSourceDeallocOp.hasValue()) return failure(); Operation *cloneDeallocOp = *maybeCloneDeallocOp; Operation *sourceDeallocOp = *maybeSourceDeallocOp; diff --git a/mlir/lib/Dialect/Bufferization/Transforms/BufferUtils.cpp b/mlir/lib/Dialect/Bufferization/Transforms/BufferUtils.cpp index 7240e5b..d631dc3 100644 --- a/mlir/lib/Dialect/Bufferization/Transforms/BufferUtils.cpp +++ b/mlir/lib/Dialect/Bufferization/Transforms/BufferUtils.cpp @@ -158,11 +158,11 @@ bufferization::getGlobalFor(arith::ConstantOp constantOp, uint64_t alignment) { auto globalOp = dyn_cast<memref::GlobalOp>(&op); if (!globalOp) continue; - if (!globalOp.initial_value().has_value()) + if (!globalOp.initial_value().hasValue()) continue; uint64_t opAlignment = - globalOp.alignment().has_value() ? globalOp.alignment().value() : 0; - Attribute initialValue = globalOp.initial_value().value(); + globalOp.alignment().hasValue() ? globalOp.alignment().getValue() : 0; + Attribute initialValue = globalOp.initial_value().getValue(); if (opAlignment == alignment && initialValue == constantOp.getValue()) return globalOp; } diff --git a/mlir/lib/Dialect/Bufferization/Transforms/FuncBufferizableOpInterfaceImpl.cpp b/mlir/lib/Dialect/Bufferization/Transforms/FuncBufferizableOpInterfaceImpl.cpp index 1cff6f9..3689522 100644 --- a/mlir/lib/Dialect/Bufferization/Transforms/FuncBufferizableOpInterfaceImpl.cpp +++ b/mlir/lib/Dialect/Bufferization/Transforms/FuncBufferizableOpInterfaceImpl.cpp @@ -114,9 +114,9 @@ static FuncOpAnalysisState getFuncOpAnalysisState(const AnalysisState &state, Optional<const FuncAnalysisState *> maybeState = state.getDialectState<FuncAnalysisState>( func::FuncDialect::getDialectNamespace()); - if (!maybeState.has_value()) + if (!maybeState.hasValue()) return FuncOpAnalysisState::NotAnalyzed; - const auto &analyzedFuncOps = maybeState.value()->analyzedFuncOps; + const auto &analyzedFuncOps = maybeState.getValue()->analyzedFuncOps; auto it = analyzedFuncOps.find(funcOp); if (it == analyzedFuncOps.end()) return FuncOpAnalysisState::NotAnalyzed; diff --git a/mlir/lib/Dialect/DLTI/DLTI.cpp b/mlir/lib/Dialect/DLTI/DLTI.cpp index eaf6f1e6..046152a 100644 --- a/mlir/lib/Dialect/DLTI/DLTI.cpp +++ b/mlir/lib/Dialect/DLTI/DLTI.cpp @@ -73,11 +73,11 @@ DataLayoutEntryAttr DataLayoutEntryAttr::parse(AsmParser &parser) { std::string identifier; SMLoc idLoc = parser.getCurrentLocation(); OptionalParseResult parsedType = parser.parseOptionalType(type); - if (parsedType.has_value() && failed(parsedType.value())) + if (parsedType.hasValue() && failed(parsedType.getValue())) return {}; - if (!parsedType.has_value()) { + if (!parsedType.hasValue()) { OptionalParseResult parsedString = parser.parseOptionalString(&identifier); - if (!parsedString.has_value() || failed(parsedString.value())) { + if (!parsedString.hasValue() || failed(parsedString.getValue())) { parser.emitError(idLoc) << "expected a type or a quoted string"; return {}; } diff --git a/mlir/lib/Dialect/EmitC/IR/EmitC.cpp b/mlir/lib/Dialect/EmitC/IR/EmitC.cpp index f2a19cd..be6dd41 100644 --- a/mlir/lib/Dialect/EmitC/IR/EmitC.cpp +++ b/mlir/lib/Dialect/EmitC/IR/EmitC.cpp @@ -151,7 +151,7 @@ ParseResult IncludeOp::parse(OpAsmParser &parser, OperationState &result) { StringAttr include; OptionalParseResult includeParseResult = parser.parseOptionalAttribute(include, "include", result.attributes); - if (!includeParseResult.has_value()) + if (!includeParseResult.hasValue()) return parser.emitError(parser.getNameLoc()) << "expected string attribute"; if (standardInclude && parser.parseOptionalGreater()) diff --git a/mlir/lib/Dialect/GPU/Transforms/SerializeToBlob.cpp b/mlir/lib/Dialect/GPU/Transforms/SerializeToBlob.cpp index 29f2448..35bf594 100644 --- a/mlir/lib/Dialect/GPU/Transforms/SerializeToBlob.cpp +++ b/mlir/lib/Dialect/GPU/Transforms/SerializeToBlob.cpp @@ -75,10 +75,10 @@ void gpu::SerializeToBlobPass::runOnOperation() { Optional<std::string> maybeTargetISA = translateToISA(*llvmModule, *targetMachine); - if (!maybeTargetISA.has_value()) + if (!maybeTargetISA.hasValue()) return signalPassFailure(); - std::string targetISA = std::move(maybeTargetISA.value()); + std::string targetISA = std::move(maybeTargetISA.getValue()); LLVM_DEBUG({ llvm::dbgs() << "ISA for module: " << getOperation().getNameAttr() << "\n"; diff --git a/mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp b/mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp index 0cc2fca..63a89d5 100644 --- a/mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp +++ b/mlir/lib/Dialect/LLVMIR/IR/LLVMDialect.cpp @@ -237,8 +237,9 @@ ParseResult AllocaOp::parse(OpAsmParser &parser, OperationState &result) { Optional<NamedAttribute> alignmentAttr = result.attributes.getNamed("alignment"); - if (alignmentAttr.has_value()) { - auto alignmentInt = alignmentAttr->getValue().dyn_cast<IntegerAttr>(); + if (alignmentAttr.hasValue()) { + auto alignmentInt = + alignmentAttr.getValue().getValue().dyn_cast<IntegerAttr>(); if (!alignmentInt) return parser.emitError(parser.getNameLoc(), "expected integer alignment"); @@ -271,11 +272,11 @@ ParseResult AllocaOp::parse(OpAsmParser &parser, OperationState &result) { /// the attribute, but not both. static LogicalResult verifyOpaquePtr(Operation *op, LLVMPointerType ptrType, Optional<Type> ptrElementType) { - if (ptrType.isOpaque() && !ptrElementType.has_value()) { + if (ptrType.isOpaque() && !ptrElementType.hasValue()) { return op->emitOpError() << "expected '" << kElemTypeAttrName << "' attribute if opaque pointer type is used"; } - if (!ptrType.isOpaque() && ptrElementType.has_value()) { + if (!ptrType.isOpaque() && ptrElementType.hasValue()) { return op->emitOpError() << "unexpected '" << kElemTypeAttrName << "' attribute when non-opaque pointer type is used"; @@ -340,10 +341,10 @@ static ParseResult parseSwitchOpCases( do { int64_t value = 0; OptionalParseResult integerParseResult = parser.parseOptionalInteger(value); - if (values.empty() && !integerParseResult.has_value()) + if (values.empty() && !integerParseResult.hasValue()) return success(); - if (!integerParseResult.has_value() || integerParseResult.value()) + if (!integerParseResult.hasValue() || integerParseResult.getValue()) return failure(); values.push_back(APInt(bitWidth, value)); @@ -616,8 +617,8 @@ parseGEPIndices(OpAsmParser &parser, int32_t constantIndex; OptionalParseResult parsedInteger = parser.parseOptionalInteger(constantIndex); - if (parsedInteger.has_value()) { - if (failed(parsedInteger.value())) + if (parsedInteger.hasValue()) { + if (failed(parsedInteger.getValue())) return failure(); constantIndices.push_back(constantIndex); return success(); @@ -915,13 +916,13 @@ LogicalResult InvokeOp::verify() { void InvokeOp::print(OpAsmPrinter &p) { auto callee = getCallee(); - bool isDirect = callee.has_value(); + bool isDirect = callee.hasValue(); p << ' '; // Either function name or pointer if (isDirect) - p.printSymbolName(callee.value()); + p.printSymbolName(callee.getValue()); else p << getOperand(0); @@ -1208,13 +1209,13 @@ LogicalResult CallOp::verify() { void CallOp::print(OpAsmPrinter &p) { auto callee = getCallee(); - bool isDirect = callee.has_value(); + bool isDirect = callee.hasValue(); // Print the direct callee if present as a function attribute, or an indirect // callee (first operand) otherwise. p << ' '; if (isDirect) - p.printSymbolName(callee.value()); + p.printSymbolName(callee.getValue()); else p << getOperand(0); @@ -1926,7 +1927,7 @@ ParseResult GlobalOp::parse(OpAsmParser &parser, OperationState &result) { OptionalParseResult parseResult = parser.parseOptionalRegion(initRegion, /*arguments=*/{}, /*argTypes=*/{}); - if (parseResult.has_value() && failed(*parseResult)) + if (parseResult.hasValue() && failed(*parseResult)) return failure(); } @@ -1986,8 +1987,8 @@ LogicalResult GlobalOp::verify() { } Optional<uint64_t> alignAttr = getAlignment(); - if (alignAttr.has_value()) { - uint64_t value = alignAttr.value(); + if (alignAttr.hasValue()) { + uint64_t value = alignAttr.getValue(); if (!llvm::isPowerOf2_64(value)) return emitError() << "alignment attribute is not a power of 2"; } @@ -2260,7 +2261,7 @@ ParseResult LLVMFuncOp::parse(OpAsmParser &parser, OperationState &result) { auto *body = result.addRegion(); OptionalParseResult parseResult = parser.parseOptionalRegion(*body, entryArgs); - return failure(parseResult.has_value() && failed(*parseResult)); + return failure(parseResult.hasValue() && failed(*parseResult)); } // Print the LLVMFuncOp. Collects argument and result types and passes them to diff --git a/mlir/lib/Dialect/LLVMIR/IR/LLVMTypeSyntax.cpp b/mlir/lib/Dialect/LLVMIR/IR/LLVMTypeSyntax.cpp index 295f59f..04015ef 100644 --- a/mlir/lib/Dialect/LLVMIR/IR/LLVMTypeSyntax.cpp +++ b/mlir/lib/Dialect/LLVMIR/IR/LLVMTypeSyntax.cpp @@ -232,7 +232,7 @@ static LLVMPointerType parsePointerType(AsmParser &parser) { unsigned addressSpace = 0; OptionalParseResult opr = parser.parseOptionalInteger(addressSpace); - if (opr.has_value()) { + if (opr.hasValue()) { if (failed(*opr) || parser.parseGreater()) return LLVMPointerType(); return parser.getChecked<LLVMPointerType>(loc, parser.getContext(), @@ -442,8 +442,8 @@ static Type dispatchParse(AsmParser &parser, bool allowAny = true) { // Try parsing any MLIR type. Type type; OptionalParseResult result = parser.parseOptionalType(type); - if (result.has_value()) { - if (failed(result.value())) + if (result.hasValue()) { + if (failed(result.getValue())) return nullptr; if (!allowAny) { parser.emitError(keyLoc) << "unexpected type, expected keyword"; diff --git a/mlir/lib/Dialect/LLVMIR/IR/NVVMDialect.cpp b/mlir/lib/Dialect/LLVMIR/IR/NVVMDialect.cpp index d5d84bd..7d4691a 100644 --- a/mlir/lib/Dialect/LLVMIR/IR/NVVMDialect.cpp +++ b/mlir/lib/Dialect/LLVMIR/IR/NVVMDialect.cpp @@ -117,15 +117,15 @@ static bool isIntegerPtxType(MMATypes type) { MMATypes MmaOp::accumPtxType() { Optional<mlir::NVVM::MMATypes> val = inferOperandMMAType( getODSOperands(2).getTypes().front(), /*isAccum=*/true); - assert(val && "accumulator PTX type should always be inferrable"); - return val.value(); + assert(val.hasValue() && "accumulator PTX type should always be inferrable"); + return val.getValue(); } MMATypes MmaOp::resultPtxType() { Optional<mlir::NVVM::MMATypes> val = inferOperandMMAType(getResult().getType(), /*isAccum=*/true); - assert(val && "result PTX type should always be inferrable"); - return val.value(); + assert(val.hasValue() && "result PTX type should always be inferrable"); + return val.getValue(); } void MmaOp::print(OpAsmPrinter &p) { @@ -224,10 +224,10 @@ void MmaOp::build(OpBuilder &builder, OperationState &result, Type resultType, result.addAttribute("layoutB", MMALayoutAttr::get(ctx, MMALayout::col)); } - if (intOverflow) + if (intOverflow.hasValue()) result.addAttribute("intOverflowBehavior", MMAIntOverflowAttr::get(ctx, *intOverflow)); - if (b1Op) + if (b1Op.hasValue()) result.addAttribute("b1Op", MMAB1OpAttr::get(ctx, *b1Op)); result.addTypes(resultType); @@ -311,13 +311,13 @@ ParseResult MmaOp::parse(OpAsmParser &parser, OperationState &result) { for (unsigned idx = 0; idx < names.size(); idx++) { const auto &frag = frags[idx]; Optional<NamedAttribute> attr = namedAttributes.getNamed(names[idx]); - if (!frag.elemtype.has_value() && !attr) { + if (!frag.elemtype.hasValue() && !attr.hasValue()) { return parser.emitError( parser.getNameLoc(), "attribute " + names[idx] + " is not provided explicitly and cannot be inferred"); } - if (!attr) + if (!attr.hasValue()) result.addAttribute( names[idx], MMATypesAttr::get(parser.getContext(), *frag.elemtype)); } @@ -399,10 +399,10 @@ LogicalResult MmaOp::verify() { break; default: return emitError("invalid shape or multiplicand type: " + - stringifyEnum(getMultiplicandAPtxType().value())); + stringifyEnum(getMultiplicandAPtxType().getValue())); } - if (isIntegerPtxType(getMultiplicandAPtxType().value())) { + if (isIntegerPtxType(getMultiplicandAPtxType().getValue())) { expectedResult.push_back(s32x4StructTy); expectedC.emplace_back(4, i32Ty); multiplicandFragType = i32Ty; @@ -440,16 +440,16 @@ LogicalResult MmaOp::verify() { context, SmallVector<Type>(2, f64Ty))); allowedShapes.push_back({8, 8, 4}); } - if (isIntegerPtxType(getMultiplicandAPtxType().value())) { + if (isIntegerPtxType(getMultiplicandAPtxType().getValue())) { expectedA.push_back({i32Ty}); expectedB.push_back({i32Ty}); expectedC.push_back({i32Ty, i32Ty}); expectedResult.push_back(s32x2StructTy); - if (isInt4PtxType(getMultiplicandAPtxType().value())) + if (isInt4PtxType(getMultiplicandAPtxType().getValue())) allowedShapes.push_back({8, 8, 32}); - if (isInt8PtxType(getMultiplicandAPtxType().value())) + if (isInt8PtxType(getMultiplicandAPtxType().getValue())) allowedShapes.push_back({8, 8, 16}); - if (getMultiplicandAPtxType().value() == MMATypes::b1) + if (getMultiplicandAPtxType().getValue() == MMATypes::b1) allowedShapes.push_back({8, 8, 128}); } } diff --git a/mlir/lib/Dialect/Linalg/Transforms/Fusion.cpp b/mlir/lib/Dialect/Linalg/Transforms/Fusion.cpp index 8bff2c2..2b783a8 100644 --- a/mlir/lib/Dialect/Linalg/Transforms/Fusion.cpp +++ b/mlir/lib/Dialect/Linalg/Transforms/Fusion.cpp @@ -777,14 +777,16 @@ fuseOperations(OpBuilder &b, LinalgOp rootOp, TiledLinalgOp tiledLinalgOp, LinalgDependenceGraph::DependenceType::RAW) continue; - unsigned resultIndex = dependence.getDependentOpViewResultNum().value(); + unsigned resultIndex = + dependence.getDependentOpViewResultNum().getValue(); LinalgOp consumer = origOpToFusedOp.lookup(dependence.getIndexingOp()); if (!consumer) continue; Value replacementValue = fusedOp.getOperation()->getResult(resultIndex); consumer.getOperation()->setOperand( - dependence.getIndexingOpViewOperandNum().value(), replacementValue); + dependence.getIndexingOpViewOperandNum().getValue(), + replacementValue); } // At this point, all Linalg uses of the tensors produced by `origOp` have diff --git a/mlir/lib/Dialect/Linalg/Transforms/Promotion.cpp b/mlir/lib/Dialect/Linalg/Transforms/Promotion.cpp index 88d986b..1f2ca25 100644 --- a/mlir/lib/Dialect/Linalg/Transforms/Promotion.cpp +++ b/mlir/lib/Dialect/Linalg/Transforms/Promotion.cpp @@ -49,8 +49,8 @@ static Value allocBuffer(ImplicitLocOpBuilder &b, auto width = layout.getTypeSize(elementType); IntegerAttr alignmentAttr; - if (alignment) - alignmentAttr = b.getI64IntegerAttr(alignment.value()); + if (alignment.hasValue()) + alignmentAttr = b.getI64IntegerAttr(alignment.getValue()); // Static buffer. if (auto cst = allocSize.getDefiningOp<arith::ConstantIndexOp>()) { @@ -233,7 +233,7 @@ FailureOr<PromotionInfo> mlir::linalg::promoteSubviewAsNewBuffer( Value size = failed(upperBound) ? rangeValue.size - : b.create<arith::ConstantIndexOp>(loc, upperBound.value()); + : b.create<arith::ConstantIndexOp>(loc, upperBound.getValue()); LLVM_DEBUG(llvm::dbgs() << "Extracted tightest: " << size << "\n"); fullSizes.push_back(size); partialSizes.push_back( diff --git a/mlir/lib/Dialect/Linalg/Transforms/Transforms.cpp b/mlir/lib/Dialect/Linalg/Transforms/Transforms.cpp index 67ca94b9..a3b95b3 100644 --- a/mlir/lib/Dialect/Linalg/Transforms/Transforms.cpp +++ b/mlir/lib/Dialect/Linalg/Transforms/Transforms.cpp @@ -102,8 +102,9 @@ LogicalResult mlir::linalg::LinalgTransformationFilter::checkAndNotify( void mlir::linalg::LinalgTransformationFilter:: replaceLinalgTransformationFilter(PatternRewriter &rewriter, Operation *op) const { - if (replacement) - op->setAttr(LinalgTransforms::kLinalgTransformMarker, replacement.value()); + if (replacement.hasValue()) + op->setAttr(LinalgTransforms::kLinalgTransformMarker, + replacement.getValue()); else op->removeAttr( rewriter.getStringAttr(LinalgTransforms::kLinalgTransformMarker)); @@ -440,10 +441,10 @@ LogicalResult mlir::linalg::LinalgBaseTileAndFusePattern::matchAndRewrite( if (failed(unfusedTiledOp)) return failure(); rewriter.replaceOp(tiledAndFusedOps->op, - getTiledOpResult(unfusedTiledOp.value())); + getTiledOpResult(unfusedTiledOp.getValue())); tiledAndFusedOps->op = unfusedTiledOp->op; } - op->replaceAllUsesWith(getTiledAndFusedOpResult(tiledAndFusedOps.value())); + op->replaceAllUsesWith(getTiledAndFusedOpResult(tiledAndFusedOps.getValue())); filter.replaceLinalgTransformationFilter(rewriter, tiledAndFusedOps->op.getOperation()); diff --git a/mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp b/mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp index 85351c5..014c5be 100644 --- a/mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp +++ b/mlir/lib/Dialect/MemRef/IR/MemRefOps.cpp @@ -1297,8 +1297,8 @@ LogicalResult GlobalOp::verify() { // Verify that the initial value, if present, is either a unit attribute or // an elements attribute. - if (initial_value().has_value()) { - Attribute initValue = initial_value().value(); + if (initial_value().hasValue()) { + Attribute initValue = initial_value().getValue(); if (!initValue.isa<UnitAttr>() && !initValue.isa<ElementsAttr>()) return emitOpError("initial value should be a unit or elements " "attribute, but got ") @@ -1329,8 +1329,8 @@ LogicalResult GlobalOp::verify() { ElementsAttr GlobalOp::getConstantInitValue() { auto initVal = initial_value(); - if (constant() && initVal.has_value()) - return initVal->cast<ElementsAttr>(); + if (constant() && initVal.hasValue()) + return initVal.getValue().cast<ElementsAttr>(); return {}; } @@ -2483,14 +2483,14 @@ static bool isTrivialSubViewOp(SubViewOp subViewOp) { // Check offsets are zero. if (llvm::any_of(mixedOffsets, [](OpFoldResult ofr) { Optional<int64_t> intValue = getConstantIntValue(ofr); - return !intValue || *intValue != 0; + return !intValue || intValue.getValue() != 0; })) return false; // Check strides are one. if (llvm::any_of(mixedStrides, [](OpFoldResult ofr) { Optional<int64_t> intValue = getConstantIntValue(ofr); - return !intValue || *intValue != 1; + return !intValue || intValue.getValue() != 1; })) return false; diff --git a/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp b/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp index b2960a6..ec1b6e9 100644 --- a/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp +++ b/mlir/lib/Dialect/OpenACC/IR/OpenACC.cpp @@ -243,7 +243,7 @@ ParseResult ParallelOp::parse(OpAsmParser &parser, OperationState &result) { // async()? async = parseOptionalOperandAndType(parser, ParallelOp::getAsyncKeyword(), result); - if (async.has_value() && failed(*async)) + if (async.hasValue() && failed(*async)) return failure(); // wait()? @@ -254,19 +254,19 @@ ParseResult ParallelOp::parse(OpAsmParser &parser, OperationState &result) { // num_gangs(value)? numGangs = parseOptionalOperandAndType( parser, ParallelOp::getNumGangsKeyword(), result); - if (numGangs.has_value() && failed(*numGangs)) + if (numGangs.hasValue() && failed(*numGangs)) return failure(); // num_workers(value)? numWorkers = parseOptionalOperandAndType( parser, ParallelOp::getNumWorkersKeyword(), result); - if (numWorkers.has_value() && failed(*numWorkers)) + if (numWorkers.hasValue() && failed(*numWorkers)) return failure(); // vector_length(value)? vectorLength = parseOptionalOperandAndType( parser, ParallelOp::getVectorLengthKeyword(), result); - if (vectorLength.has_value() && failed(*vectorLength)) + if (vectorLength.hasValue() && failed(*vectorLength)) return failure(); // if()? @@ -362,11 +362,11 @@ ParseResult ParallelOp::parse(OpAsmParser &parser, OperationState &result) { result.addAttribute( ParallelOp::getOperandSegmentSizeAttr(), builder.getI32VectorAttr( - {static_cast<int32_t>(async.has_value() ? 1 : 0), + {static_cast<int32_t>(async.hasValue() ? 1 : 0), static_cast<int32_t>(waitOperands.size()), - static_cast<int32_t>(numGangs.has_value() ? 1 : 0), - static_cast<int32_t>(numWorkers.has_value() ? 1 : 0), - static_cast<int32_t>(vectorLength.has_value() ? 1 : 0), + static_cast<int32_t>(numGangs.hasValue() ? 1 : 0), + static_cast<int32_t>(numWorkers.hasValue() ? 1 : 0), + static_cast<int32_t>(vectorLength.hasValue() ? 1 : 0), static_cast<int32_t>(hasIfCond ? 1 : 0), static_cast<int32_t>(hasSelfCond ? 1 : 0), static_cast<int32_t>(reductionOperands.size()), @@ -531,13 +531,13 @@ ParseResult LoopOp::parse(OpAsmParser &parser, OperationState &result) { if (succeeded(parser.parseOptionalLParen())) { gangNum = parserOptionalOperandAndTypeWithPrefix( parser, result, LoopOp::getGangNumKeyword()); - if (gangNum.has_value() && failed(*gangNum)) + if (gangNum.hasValue() && failed(*gangNum)) return failure(); // FIXME: Comma should require subsequent operands. (void)parser.parseOptionalComma(); gangStatic = parserOptionalOperandAndTypeWithPrefix( parser, result, LoopOp::getGangStaticKeyword()); - if (gangStatic.has_value() && failed(*gangStatic)) + if (gangStatic.hasValue() && failed(*gangStatic)) return failure(); // FIXME: Why allow optional last commas? (void)parser.parseOptionalComma(); @@ -551,7 +551,7 @@ ParseResult LoopOp::parse(OpAsmParser &parser, OperationState &result) { // optional worker operand worker = parseOptionalOperandAndType(parser, result); - if (worker.has_value() && failed(*worker)) + if (worker.hasValue() && failed(*worker)) return failure(); // vector? @@ -560,7 +560,7 @@ ParseResult LoopOp::parse(OpAsmParser &parser, OperationState &result) { // optional vector operand vector = parseOptionalOperandAndType(parser, result); - if (vector.has_value() && failed(*vector)) + if (vector.hasValue() && failed(*vector)) return failure(); // tile()? @@ -591,10 +591,10 @@ ParseResult LoopOp::parse(OpAsmParser &parser, OperationState &result) { result.addAttribute(LoopOp::getOperandSegmentSizeAttr(), builder.getI32VectorAttr( - {static_cast<int32_t>(gangNum.has_value() ? 1 : 0), - static_cast<int32_t>(gangStatic.has_value() ? 1 : 0), - static_cast<int32_t>(worker.has_value() ? 1 : 0), - static_cast<int32_t>(vector.has_value() ? 1 : 0), + {static_cast<int32_t>(gangNum.hasValue() ? 1 : 0), + static_cast<int32_t>(gangStatic.hasValue() ? 1 : 0), + static_cast<int32_t>(worker.hasValue() ? 1 : 0), + static_cast<int32_t>(vector.hasValue() ? 1 : 0), static_cast<int32_t>(tileOperands.size()), static_cast<int32_t>(privateOperands.size()), static_cast<int32_t>(reductionOperands.size())})); diff --git a/mlir/lib/Dialect/PDL/IR/PDLTypes.cpp b/mlir/lib/Dialect/PDL/IR/PDLTypes.cpp index f3b1923..13e19d4 100644 --- a/mlir/lib/Dialect/PDL/IR/PDLTypes.cpp +++ b/mlir/lib/Dialect/PDL/IR/PDLTypes.cpp @@ -40,7 +40,7 @@ static Type parsePDLType(AsmParser &parser) { { Type genType; auto parseResult = generatedTypeParser(parser, typeTag, genType); - if (parseResult.has_value()) + if (parseResult.hasValue()) return genType; } diff --git a/mlir/lib/Dialect/Quant/IR/TypeParser.cpp b/mlir/lib/Dialect/Quant/IR/TypeParser.cpp index 91e7ec7..951f62a 100644 --- a/mlir/lib/Dialect/Quant/IR/TypeParser.cpp +++ b/mlir/lib/Dialect/Quant/IR/TypeParser.cpp @@ -30,7 +30,7 @@ static IntegerType parseStorageType(DialectAsmParser &parser, bool &isSigned) { StringRef identifier; unsigned storageTypeWidth = 0; OptionalParseResult result = parser.parseOptionalType(type); - if (result.has_value()) { + if (result.hasValue()) { if (!succeeded(*result)) return nullptr; isSigned = !type.isUnsigned(); diff --git a/mlir/lib/Dialect/SCF/IR/SCF.cpp b/mlir/lib/Dialect/SCF/IR/SCF.cpp index 503c36d..293238e 100644 --- a/mlir/lib/Dialect/SCF/IR/SCF.cpp +++ b/mlir/lib/Dialect/SCF/IR/SCF.cpp @@ -2711,7 +2711,7 @@ ParseResult scf::WhileOp::parse(OpAsmParser &parser, OperationState &result) { OptionalParseResult listResult = parser.parseOptionalAssignmentList(regionArgs, operands); - if (listResult.has_value() && failed(listResult.value())) + if (listResult.hasValue() && failed(listResult.getValue())) return failure(); FunctionType functionType; diff --git a/mlir/lib/Dialect/SCF/Transforms/TileUsingInterface.cpp b/mlir/lib/Dialect/SCF/Transforms/TileUsingInterface.cpp index 63d34e4..1bad67f 100644 --- a/mlir/lib/Dialect/SCF/Transforms/TileUsingInterface.cpp +++ b/mlir/lib/Dialect/SCF/Transforms/TileUsingInterface.cpp @@ -340,11 +340,11 @@ scf::TileConsumerAndFuseProducersUsingSCFForOp::returningMatchAndRewrite( // 2c. Generate the tiled implementation of the producer of the source rewriter.setInsertionPoint(candidateSliceOp); FailureOr<Value> fusedProducerValue = - tensor::replaceExtractSliceWithTiledProducer(rewriter, candidateSliceOp, - fusableProducer.value()); + tensor::replaceExtractSliceWithTiledProducer( + rewriter, candidateSliceOp, fusableProducer.getValue()); if (failed(fusedProducerValue)) continue; - rewriter.replaceOp(candidateSliceOp, fusedProducerValue.value()); + rewriter.replaceOp(candidateSliceOp, fusedProducerValue.getValue()); // 2d. The operands of the fused producer might themselved be slices of // values produced by operations that implement the `TilingInterface`. diff --git a/mlir/lib/Dialect/SCF/Utils/AffineCanonicalizationUtils.cpp b/mlir/lib/Dialect/SCF/Utils/AffineCanonicalizationUtils.cpp index 024731a..958b5a2 100644 --- a/mlir/lib/Dialect/SCF/Utils/AffineCanonicalizationUtils.cpp +++ b/mlir/lib/Dialect/SCF/Utils/AffineCanonicalizationUtils.cpp @@ -27,8 +27,9 @@ using namespace presburger; static void unpackOptionalValues(ArrayRef<Optional<Value>> source, SmallVector<Value> &target) { - target = llvm::to_vector<4>(llvm::map_range( - source, [](Optional<Value> val) { return val ? *val : Value(); })); + target = llvm::to_vector<4>(llvm::map_range(source, [](Optional<Value> val) { + return val.hasValue() ? *val : Value(); + })); } /// Bound an identifier `pos` in a given FlatAffineValueConstraints with diff --git a/mlir/lib/Dialect/SPIRV/IR/SPIRVAttributes.cpp b/mlir/lib/Dialect/SPIRV/IR/SPIRVAttributes.cpp index 7b7ff84..4accfc1 100644 --- a/mlir/lib/Dialect/SPIRV/IR/SPIRVAttributes.cpp +++ b/mlir/lib/Dialect/SPIRV/IR/SPIRVAttributes.cpp @@ -387,7 +387,7 @@ static Attribute parseInterfaceVarABIAttr(DialectAsmParser &parser) { uint32_t descriptorSet = 0; auto descriptorSetParseResult = parser.parseOptionalInteger(descriptorSet); - if (!descriptorSetParseResult.has_value() || + if (!descriptorSetParseResult.hasValue() || failed(*descriptorSetParseResult)) { parser.emitError(loc, "missing descriptor set"); return {}; @@ -404,7 +404,7 @@ static Attribute parseInterfaceVarABIAttr(DialectAsmParser &parser) { uint32_t binding = 0; auto bindingParseResult = parser.parseOptionalInteger(binding); - if (!bindingParseResult.has_value() || failed(*bindingParseResult)) { + if (!bindingParseResult.hasValue() || failed(*bindingParseResult)) { parser.emitError(loc, "missing binding"); return {}; } @@ -583,8 +583,8 @@ Attribute SPIRVDialect::parseAttribute(DialectAsmParser &parser, Attribute attr; OptionalParseResult result = generatedAttributeParser(parser, attrKind, type, attr); - if (result.has_value()) { - if (failed(result.value())) + if (result.hasValue()) { + if (failed(result.getValue())) return {}; return attr; } diff --git a/mlir/lib/Dialect/SPIRV/IR/SPIRVCanonicalization.cpp b/mlir/lib/Dialect/SPIRV/IR/SPIRVCanonicalization.cpp index 9ca9c15..aaa0fb3 100644 --- a/mlir/lib/Dialect/SPIRV/IR/SPIRVCanonicalization.cpp +++ b/mlir/lib/Dialect/SPIRV/IR/SPIRVCanonicalization.cpp @@ -216,11 +216,11 @@ OpFoldResult spirv::LogicalAndOp::fold(ArrayRef<Attribute> operands) { if (Optional<bool> rhs = getScalarOrSplatBoolAttr(operands.back())) { // x && true = x - if (rhs.value()) + if (rhs.getValue()) return operand1(); // x && false = false - if (!rhs.value()) + if (!rhs.getValue()) return operands.back(); } @@ -247,12 +247,12 @@ OpFoldResult spirv::LogicalOrOp::fold(ArrayRef<Attribute> operands) { assert(operands.size() == 2 && "spv.LogicalOr should take two operands"); if (auto rhs = getScalarOrSplatBoolAttr(operands.back())) { - if (rhs.value()) + if (rhs.getValue()) // x || true = true return operands.back(); // x || false = x - if (!rhs.value()) + if (!rhs.getValue()) return operand1(); } diff --git a/mlir/lib/Dialect/SPIRV/IR/SPIRVDialect.cpp b/mlir/lib/Dialect/SPIRV/IR/SPIRVDialect.cpp index dff5971..ee717d2 100644 --- a/mlir/lib/Dialect/SPIRV/IR/SPIRVDialect.cpp +++ b/mlir/lib/Dialect/SPIRV/IR/SPIRVDialect.cpp @@ -496,8 +496,8 @@ template <typename ParseType, typename... Args> struct ParseCommaSeparatedList { auto remainingValues = ParseCommaSeparatedList<Args...>{}(dialect, parser); if (!remainingValues) return llvm::None; - return std::tuple_cat(std::tuple<ParseType>(parseVal.value()), - remainingValues.value()); + return std::tuple_cat(std::tuple<ParseType>(parseVal.getValue()), + remainingValues.getValue()); } }; @@ -571,7 +571,7 @@ static ParseResult parseStructMemberDecorations( SMLoc offsetLoc = parser.getCurrentLocation(); StructType::OffsetInfo offset = 0; OptionalParseResult offsetParseResult = parser.parseOptionalInteger(offset); - if (offsetParseResult.has_value()) { + if (offsetParseResult.hasValue()) { if (failed(*offsetParseResult)) return failure(); @@ -588,7 +588,7 @@ static ParseResult parseStructMemberDecorations( return success(); // If there was an offset, make sure to parse the comma. - if (offsetParseResult.has_value() && parser.parseComma()) + if (offsetParseResult.hasValue() && parser.parseComma()) return failure(); // Check for spirv::Decorations. @@ -607,11 +607,11 @@ static ParseResult parseStructMemberDecorations( memberDecorationInfo.emplace_back( static_cast<uint32_t>(memberTypes.size() - 1), 1, - memberDecoration.value(), memberDecorationValue.value()); + memberDecoration.getValue(), memberDecorationValue.getValue()); } else { memberDecorationInfo.emplace_back( static_cast<uint32_t>(memberTypes.size() - 1), 0, - memberDecoration.value(), 0); + memberDecoration.getValue(), 0); } return success(); }; diff --git a/mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp b/mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp index 4af79a1..4e7338f 100644 --- a/mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp +++ b/mlir/lib/Dialect/SPIRV/IR/SPIRVOps.cpp @@ -2236,7 +2236,7 @@ ParseResult spirv::FuncOp::parse(OpAsmParser &parser, OperationState &state) { // Parse the optional function body. auto *body = state.addRegion(); OptionalParseResult result = parser.parseOptionalRegion(*body, entryArgs); - return failure(result.has_value() && failed(*result)); + return failure(result.hasValue() && failed(*result)); } void spirv::FuncOp::print(OpAsmPrinter &printer) { diff --git a/mlir/lib/Dialect/SPIRV/Transforms/LowerABIAttributesPass.cpp b/mlir/lib/Dialect/SPIRV/Transforms/LowerABIAttributesPass.cpp index 263f00e..3ea2224 100644 --- a/mlir/lib/Dialect/SPIRV/Transforms/LowerABIAttributesPass.cpp +++ b/mlir/lib/Dialect/SPIRV/Transforms/LowerABIAttributesPass.cpp @@ -131,8 +131,8 @@ static LogicalResult lowerEntryPointABIAttr(spirv::FuncOp funcOp, return funcOp.emitRemark("lower entry point failure: could not select " "execution model based on 'spv.target_env'"); - builder.create<spirv::EntryPointOp>(funcOp.getLoc(), executionModel.value(), - funcOp, interfaceVars); + builder.create<spirv::EntryPointOp>( + funcOp.getLoc(), executionModel.getValue(), funcOp, interfaceVars); // Specifies the spv.ExecutionModeOp. auto localSizeAttr = entryPointAttr.getLocalSize(); diff --git a/mlir/lib/Dialect/Shape/IR/Shape.cpp b/mlir/lib/Dialect/Shape/IR/Shape.cpp index 6fd8fa6..b3f6c4c 100644 --- a/mlir/lib/Dialect/Shape/IR/Shape.cpp +++ b/mlir/lib/Dialect/Shape/IR/Shape.cpp @@ -1247,11 +1247,11 @@ OpFoldResult GetExtentOp::fold(ArrayRef<Attribute> operands) { if (!elements) return nullptr; Optional<int64_t> dim = getConstantDim(); - if (!dim.has_value()) + if (!dim.hasValue()) return nullptr; - if (dim.value() >= elements.getNumElements()) + if (dim.getValue() >= elements.getNumElements()) return nullptr; - return elements.getValues<Attribute>()[(uint64_t)dim.value()]; + return elements.getValues<Attribute>()[(uint64_t)dim.getValue()]; } void GetExtentOp::build(OpBuilder &builder, OperationState &result, Value shape, diff --git a/mlir/lib/Dialect/SparseTensor/Transforms/Sparsification.cpp b/mlir/lib/Dialect/SparseTensor/Transforms/Sparsification.cpp index 0504ea0..8c62290 100644 --- a/mlir/lib/Dialect/SparseTensor/Transforms/Sparsification.cpp +++ b/mlir/lib/Dialect/SparseTensor/Transforms/Sparsification.cpp @@ -1729,9 +1729,9 @@ public: // Builds the tensor expression for the Linalg operation in SSA form. Optional<unsigned> optExp = merger.buildTensorExpFromLinalg(op); - if (!optExp.has_value()) + if (!optExp.hasValue()) return failure(); - unsigned exp = optExp.value(); + unsigned exp = optExp.getValue(); // Rejects an inadmissable tensor expression. OpOperand *sparseOut = nullptr; diff --git a/mlir/lib/Dialect/SparseTensor/Utils/Merger.cpp b/mlir/lib/Dialect/SparseTensor/Utils/Merger.cpp index 9482e71..ed19cf7 100644 --- a/mlir/lib/Dialect/SparseTensor/Utils/Merger.cpp +++ b/mlir/lib/Dialect/SparseTensor/Utils/Merger.cpp @@ -893,8 +893,8 @@ Optional<unsigned> Merger::buildTensorExp(linalg::GenericOp op, Value v) { // Construct unary operations if subexpression can be built. if (def->getNumOperands() == 1) { auto x = buildTensorExp(op, def->getOperand(0)); - if (x) { - unsigned e = x.value(); + if (x.hasValue()) { + unsigned e = x.getValue(); if (isa<math::AbsOp>(def)) return addExp(kAbsF, e); if (isa<complex::AbsOp>(def)) @@ -966,9 +966,9 @@ Optional<unsigned> Merger::buildTensorExp(linalg::GenericOp op, Value v) { if (def->getNumOperands() == 2) { auto x = buildTensorExp(op, def->getOperand(0)); auto y = buildTensorExp(op, def->getOperand(1)); - if (x.has_value() && y.has_value()) { - unsigned e0 = x.value(); - unsigned e1 = y.value(); + if (x.hasValue() && y.hasValue()) { + unsigned e0 = x.getValue(); + unsigned e1 = y.getValue(); if (isa<arith::MulFOp>(def)) return addExp(kMulF, e0, e1); if (isa<complex::MulOp>(def)) diff --git a/mlir/lib/Dialect/Tensor/Transforms/SwapExtractSliceWithProducer.cpp b/mlir/lib/Dialect/Tensor/Transforms/SwapExtractSliceWithProducer.cpp index 8798164..8d570cf 100644 --- a/mlir/lib/Dialect/Tensor/Transforms/SwapExtractSliceWithProducer.cpp +++ b/mlir/lib/Dialect/Tensor/Transforms/SwapExtractSliceWithProducer.cpp @@ -39,5 +39,5 @@ FailureOr<Value> tensor::replaceExtractSliceWithTiledProducer( if (failed(tiledResult)) return failure(); - return tiledResult.value(); + return tiledResult.getValue(); } diff --git a/mlir/lib/Dialect/Tosa/Transforms/TosaDecomposeTransposeConv.cpp b/mlir/lib/Dialect/Tosa/Transforms/TosaDecomposeTransposeConv.cpp index a0a9262..120e502 100644 --- a/mlir/lib/Dialect/Tosa/Transforms/TosaDecomposeTransposeConv.cpp +++ b/mlir/lib/Dialect/Tosa/Transforms/TosaDecomposeTransposeConv.cpp @@ -208,8 +208,8 @@ public: Value weightPaddingVal = createOpAndInfer<tosa::ConstOp>( rewriter, loc, weightPaddingAttr.getType(), weightPaddingAttr); - if (op.quantization_info().has_value()) { - auto quantInfo = op.quantization_info().value(); + if (op.quantization_info().hasValue()) { + auto quantInfo = op.quantization_info().getValue(); weight = createOpAndInfer<tosa::PadOp>( rewriter, loc, UnrankedTensorType::get(weightETy), weight, weightPaddingVal, nullptr, @@ -272,8 +272,8 @@ public: Value inputPaddingVal = createOpAndInfer<tosa::ConstOp>( rewriter, loc, inputPaddingAttr.getType(), inputPaddingAttr); - if (op.quantization_info().has_value()) { - auto quantInfo = op.quantization_info().value(); + if (op.quantization_info().hasValue()) { + auto quantInfo = op.quantization_info().getValue(); input = createOpAndInfer<tosa::PadOp>( rewriter, loc, UnrankedTensorType::get(inputETy), input, inputPaddingVal, nullptr, diff --git a/mlir/lib/Dialect/Transform/IR/TransformOps.cpp b/mlir/lib/Dialect/Transform/IR/TransformOps.cpp index 23e7b5d..d83a9de 100644 --- a/mlir/lib/Dialect/Transform/IR/TransformOps.cpp +++ b/mlir/lib/Dialect/Transform/IR/TransformOps.cpp @@ -134,12 +134,12 @@ void transform::AlternativesOp::getSuccessorRegions( Optional<unsigned> index, ArrayRef<Attribute> operands, SmallVectorImpl<RegionSuccessor> ®ions) { for (Region &alternative : - llvm::drop_begin(getAlternatives(), index ? *index + 1 : 0)) { + llvm::drop_begin(getAlternatives(), index.hasValue() ? *index + 1 : 0)) { regions.emplace_back(&alternative, !getOperands().empty() ? alternative.getArguments() : Block::BlockArgListType()); } - if (index) + if (index.hasValue()) regions.emplace_back(getOperation()->getResults()); } diff --git a/mlir/lib/Dialect/Utils/ReshapeOpsUtils.cpp b/mlir/lib/Dialect/Utils/ReshapeOpsUtils.cpp index b26b3d9..64937be 100644 --- a/mlir/lib/Dialect/Utils/ReshapeOpsUtils.cpp +++ b/mlir/lib/Dialect/Utils/ReshapeOpsUtils.cpp @@ -238,7 +238,7 @@ LogicalResult mlir::reshapeLikeShapesAreCompatible( return emitError("invalid to have a single dimension (" + Twine(map.index()) + ") expanded into multiple dynamic dims (" + - Twine(expandedDimStart + dynamicShape.value()) + + Twine(expandedDimStart + dynamicShape.getValue()) + "," + Twine(expandedDimStart + dim.index()) + ")"); } dynamicShape = dim.index(); diff --git a/mlir/lib/Dialect/Vector/IR/VectorOps.cpp b/mlir/lib/Dialect/Vector/IR/VectorOps.cpp index 387e5f1..ebf3662 100644 --- a/mlir/lib/Dialect/Vector/IR/VectorOps.cpp +++ b/mlir/lib/Dialect/Vector/IR/VectorOps.cpp @@ -2677,8 +2677,8 @@ void TransferReadOp::build(OpBuilder &builder, OperationState &result, ValueRange indices, AffineMap permutationMap, Optional<ArrayRef<bool>> inBounds) { auto permutationMapAttr = AffineMapAttr::get(permutationMap); - auto inBoundsAttr = (inBounds && !inBounds->empty()) - ? builder.getBoolArrayAttr(inBounds.value()) + auto inBoundsAttr = (inBounds && !inBounds.getValue().empty()) + ? builder.getBoolArrayAttr(inBounds.getValue()) : ArrayAttr(); build(builder, result, vectorType, source, indices, permutationMapAttr, inBoundsAttr); @@ -2692,8 +2692,8 @@ void TransferReadOp::build(OpBuilder &builder, OperationState &result, AffineMap permutationMap = getTransferMinorIdentityMap( source.getType().cast<ShapedType>(), vectorType); auto permutationMapAttr = AffineMapAttr::get(permutationMap); - auto inBoundsAttr = (inBounds && !inBounds->empty()) - ? builder.getBoolArrayAttr(inBounds.value()) + auto inBoundsAttr = (inBounds && !inBounds.getValue().empty()) + ? builder.getBoolArrayAttr(inBounds.getValue()) : ArrayAttr(); build(builder, result, vectorType, source, indices, permutationMapAttr, padding, @@ -3216,8 +3216,8 @@ void TransferWriteOp::build(OpBuilder &builder, OperationState &result, AffineMap permutationMap, Optional<ArrayRef<bool>> inBounds) { auto permutationMapAttr = AffineMapAttr::get(permutationMap); - auto inBoundsAttr = (inBounds && !inBounds->empty()) - ? builder.getBoolArrayAttr(inBounds.value()) + auto inBoundsAttr = (inBounds && !inBounds.getValue().empty()) + ? builder.getBoolArrayAttr(inBounds.getValue()) : ArrayAttr(); build(builder, result, vector, dest, indices, permutationMapAttr, /*mask=*/Value(), inBoundsAttr); diff --git a/mlir/lib/Dialect/Vector/Transforms/VectorTransferPermutationMapRewritePatterns.cpp b/mlir/lib/Dialect/Vector/Transforms/VectorTransferPermutationMapRewritePatterns.cpp index e419fc2..9488145 100644 --- a/mlir/lib/Dialect/Vector/Transforms/VectorTransferPermutationMapRewritePatterns.cpp +++ b/mlir/lib/Dialect/Vector/Transforms/VectorTransferPermutationMapRewritePatterns.cpp @@ -105,9 +105,10 @@ struct TransferReadPermutationLowering // Transpose in_bounds attribute. ArrayAttr newInBoundsAttr = - op.getInBounds() ? transposeInBoundsAttr( - rewriter, op.getInBounds().value(), permutation) - : ArrayAttr(); + op.getInBounds() + ? transposeInBoundsAttr(rewriter, op.getInBounds().getValue(), + permutation) + : ArrayAttr(); // Generate new transfer_read operation. VectorType newReadType = @@ -175,9 +176,10 @@ struct TransferWritePermutationLowering // Transpose in_bounds attribute. ArrayAttr newInBoundsAttr = - op.getInBounds() ? transposeInBoundsAttr( - rewriter, op.getInBounds().value(), permutation) - : ArrayAttr(); + op.getInBounds() + ? transposeInBoundsAttr(rewriter, op.getInBounds().getValue(), + permutation) + : ArrayAttr(); // Generate new transfer_write operation. Value newVec = rewriter.create<vector::TransposeOp>( diff --git a/mlir/lib/Dialect/Vector/Transforms/VectorTransforms.cpp b/mlir/lib/Dialect/Vector/Transforms/VectorTransforms.cpp index 26e4cac..67635d6 100644 --- a/mlir/lib/Dialect/Vector/Transforms/VectorTransforms.cpp +++ b/mlir/lib/Dialect/Vector/Transforms/VectorTransforms.cpp @@ -553,9 +553,9 @@ public: Value b = rewriter.create<vector::BroadcastOp>(loc, lhsType, op.getRhs()); Optional<Value> mult = createContractArithOp(loc, op.getLhs(), b, acc, kind, rewriter, isInt); - if (!mult.has_value()) + if (!mult.hasValue()) return failure(); - rewriter.replaceOp(op, mult.value()); + rewriter.replaceOp(op, mult.getValue()); return success(); } @@ -571,9 +571,9 @@ public: r = rewriter.create<vector::ExtractOp>(loc, rhsType, acc, pos); Optional<Value> m = createContractArithOp(loc, a, op.getRhs(), r, kind, rewriter, isInt); - if (!m.has_value()) + if (!m.hasValue()) return failure(); - result = rewriter.create<vector::InsertOp>(loc, resType, m.value(), + result = rewriter.create<vector::InsertOp>(loc, resType, m.getValue(), result, pos); } rewriter.replaceOp(op, result); @@ -1824,8 +1824,8 @@ Value ContractionOpLowering::lowerParallel(vector::ContractionOp op, } assert(iterIndex >= 0 && "parallel index not listed in operand mapping"); Optional<int64_t> lookup = getResultIndex(iMap[2], iterIndex); - assert(lookup && "parallel index not listed in reduction"); - int64_t resIndex = lookup.value(); + assert(lookup.hasValue() && "parallel index not listed in reduction"); + int64_t resIndex = lookup.getValue(); // Construct new iterator types and affine map array attribute. std::array<AffineMap, 3> lowIndexingMaps = { adjustMap(iMap[0], iterIndex, rewriter), @@ -1864,10 +1864,10 @@ Value ContractionOpLowering::lowerReduction(vector::ContractionOp op, SmallVector<AffineMap, 4> iMap = op.getIndexingMaps(); Optional<int64_t> lookupLhs = getResultIndex(iMap[0], iterIndex); Optional<int64_t> lookupRhs = getResultIndex(iMap[1], iterIndex); - assert(lookupLhs && "missing LHS parallel index"); - assert(lookupRhs && "missing RHS parallel index"); - int64_t lhsIndex = lookupLhs.value(); - int64_t rhsIndex = lookupRhs.value(); + assert(lookupLhs.hasValue() && "missing LHS parallel index"); + assert(lookupRhs.hasValue() && "missing RHS parallel index"); + int64_t lhsIndex = lookupLhs.getValue(); + int64_t rhsIndex = lookupRhs.getValue(); int64_t dimSize = lhsType.getDimSize(lhsIndex); assert(dimSize == rhsType.getDimSize(rhsIndex) && "corrupt shape"); // Base case. diff --git a/mlir/lib/IR/FunctionImplementation.cpp b/mlir/lib/IR/FunctionImplementation.cpp index 9481e4a..a9160a9 100644 --- a/mlir/lib/IR/FunctionImplementation.cpp +++ b/mlir/lib/IR/FunctionImplementation.cpp @@ -41,8 +41,8 @@ parseFunctionArgumentList(OpAsmParser &parser, bool allowVariadic, OpAsmParser::Argument argument; auto argPresent = parser.parseOptionalArgument( argument, /*allowType=*/true, /*allowAttrs=*/true); - if (argPresent.has_value()) { - if (failed(argPresent.value())) + if (argPresent.hasValue()) { + if (failed(argPresent.getValue())) return failure(); // Present but malformed. // Reject this if the preceding argument was missing a name. @@ -229,7 +229,7 @@ ParseResult mlir::function_interface_impl::parseFunctionOp( OptionalParseResult parseResult = parser.parseOptionalRegion(*body, entryArgs, /*enableNameShadowing=*/false); - if (parseResult.has_value()) { + if (parseResult.hasValue()) { if (failed(*parseResult)) return failure(); // Function body was parsed, make sure its not empty. diff --git a/mlir/lib/Interfaces/ControlFlowInterfaces.cpp b/mlir/lib/Interfaces/ControlFlowInterfaces.cpp index d84218c..991f16e 100644 --- a/mlir/lib/Interfaces/ControlFlowInterfaces.cpp +++ b/mlir/lib/Interfaces/ControlFlowInterfaces.cpp @@ -107,20 +107,20 @@ verifyTypesAlongAllEdges(Operation *op, Optional<unsigned> sourceNo, auto printEdgeName = [&](InFlightDiagnostic &diag) -> InFlightDiagnostic & { diag << "from "; if (sourceNo) - diag << "Region #" << sourceNo.value(); + diag << "Region #" << sourceNo.getValue(); else diag << "parent operands"; diag << " to "; if (succRegionNo) - diag << "Region #" << succRegionNo.value(); + diag << "Region #" << succRegionNo.getValue(); else diag << "parent results"; return diag; }; Optional<TypeRange> sourceTypes = getInputsTypesForRegion(succRegionNo); - if (!sourceTypes.has_value()) + if (!sourceTypes.hasValue()) continue; TypeRange succInputsTypes = succ.getSuccessorInputs().getTypes(); diff --git a/mlir/lib/Interfaces/ViewLikeInterface.cpp b/mlir/lib/Interfaces/ViewLikeInterface.cpp index 36489d4..4ecf539 100644 --- a/mlir/lib/Interfaces/ViewLikeInterface.cpp +++ b/mlir/lib/Interfaces/ViewLikeInterface.cpp @@ -121,7 +121,7 @@ static ParseResult parseOperandsOrIntegersImpl( while (true) { OpAsmParser::UnresolvedOperand operand; auto res = parser.parseOptionalOperand(operand); - if (res.has_value() && succeeded(res.value())) { + if (res.hasValue() && succeeded(res.getValue())) { values.push_back(operand); attrVals.push_back(dynVal); } else { diff --git a/mlir/lib/Parser/AffineParser.cpp b/mlir/lib/Parser/AffineParser.cpp index eb65dde..f62455c 100644 --- a/mlir/lib/Parser/AffineParser.cpp +++ b/mlir/lib/Parser/AffineParser.cpp @@ -324,11 +324,11 @@ AffineExpr AffineParser::parseSymbolSSAIdExpr() { /// affine-expr ::= integer-literal AffineExpr AffineParser::parseIntegerExpr() { auto val = getToken().getUInt64IntegerValue(); - if (!val.has_value() || (int64_t)val.value() < 0) + if (!val.hasValue() || (int64_t)val.getValue() < 0) return emitError("constant too large for index"), nullptr; consumeToken(Token::integer); - return builder.getAffineConstantExpr((int64_t)val.value()); + return builder.getAffineConstantExpr((int64_t)val.getValue()); } /// Parses an expression that can be a valid operand of an affine expression. diff --git a/mlir/lib/Parser/AttributeParser.cpp b/mlir/lib/Parser/AttributeParser.cpp index eafebe9..efc1c22 100644 --- a/mlir/lib/Parser/AttributeParser.cpp +++ b/mlir/lib/Parser/AttributeParser.cpp @@ -211,7 +211,7 @@ Attribute Parser::parseAttribute(Type type) { // better error message. Type type; OptionalParseResult result = parseOptionalType(type); - if (!result.has_value()) + if (!result.hasValue()) return emitWrongTokenError("expected attribute value"), Attribute(); return failed(*result) ? Attribute() : TypeAttr::get(type); } @@ -245,7 +245,7 @@ OptionalParseResult Parser::parseOptionalAttribute(Attribute &attribute, // Parse an optional type attribute. Type type; OptionalParseResult result = parseOptionalType(type); - if (result.has_value() && succeeded(*result)) + if (result.hasValue() && succeeded(*result)) attribute = TypeAttr::get(type); return result; } @@ -666,8 +666,8 @@ TensorLiteralParser::getFloatAttrElements(SMLoc loc, FloatType eltTy, DenseElementsAttr TensorLiteralParser::getStringAttr(SMLoc loc, ShapedType type, Type eltTy) { - if (hexStorage) { - auto stringValue = hexStorage->getStringValue(); + if (hexStorage.hasValue()) { + auto stringValue = hexStorage.getValue().getStringValue(); return DenseStringElementsAttr::get(type, {stringValue}); } diff --git a/mlir/lib/Parser/LocationParser.cpp b/mlir/lib/Parser/LocationParser.cpp index cf1e8af..4749c16 100644 --- a/mlir/lib/Parser/LocationParser.cpp +++ b/mlir/lib/Parser/LocationParser.cpp @@ -118,11 +118,11 @@ ParseResult Parser::parseNameOrFileLineColLocation(LocationAttr &loc) { return emitWrongTokenError( "expected integer column number in FileLineColLoc"); auto column = getToken().getUnsignedIntegerValue(); - if (!column.has_value()) + if (!column.hasValue()) return emitError("expected integer column number in FileLineColLoc"); consumeToken(Token::integer); - loc = FileLineColLoc::get(ctx, str, line.value(), column.value()); + loc = FileLineColLoc::get(ctx, str, line.getValue(), column.getValue()); return success(); } diff --git a/mlir/lib/Parser/Parser.cpp b/mlir/lib/Parser/Parser.cpp index 6100134..170d571 100644 --- a/mlir/lib/Parser/Parser.cpp +++ b/mlir/lib/Parser/Parser.cpp @@ -1857,8 +1857,8 @@ ParseResult OperationParser::parseRegionBody(Region ®ion, SMLoc startLoc, .attachNote(getEncodedSourceLocation(*defLoc)) << "previously referenced here"; } - Location loc = entryArg.sourceLoc.has_value() - ? entryArg.sourceLoc.value() + Location loc = entryArg.sourceLoc.hasValue() + ? entryArg.sourceLoc.getValue() : getEncodedSourceLocation(argInfo.location); BlockArgument arg = block->addArgument(entryArg.type, loc); diff --git a/mlir/lib/Parser/TypeParser.cpp b/mlir/lib/Parser/TypeParser.cpp index 5c69ad2..52fae4b 100644 --- a/mlir/lib/Parser/TypeParser.cpp +++ b/mlir/lib/Parser/TypeParser.cpp @@ -310,9 +310,9 @@ Type Parser::parseNonFunctionType() { // integer-type case Token::inttype: { auto width = getToken().getIntTypeBitwidth(); - if (!width.has_value()) + if (!width.hasValue()) return (emitError("invalid integer width"), nullptr); - if (width.value() > IntegerType::kMaxWidth) { + if (width.getValue() > IntegerType::kMaxWidth) { emitError(getToken().getLoc(), "integer bitwidth is limited to ") << IntegerType::kMaxWidth << " bits"; return nullptr; diff --git a/mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp b/mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp index 1b1a18f..32237bd 100644 --- a/mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp +++ b/mlir/lib/Target/LLVMIR/ConvertFromLLVMIR.cpp @@ -432,8 +432,8 @@ GlobalOp Importer::processGlobal(llvm::GlobalVariable *gv) { uint64_t alignment = 0; llvm::MaybeAlign maybeAlign = gv->getAlign(); - if (maybeAlign) { - llvm::Align align = maybeAlign.value(); + if (maybeAlign.hasValue()) { + llvm::Align align = maybeAlign.getValue(); alignment = align.value(); } diff --git a/mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp b/mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp index fac9b64..d0cb2d3 100644 --- a/mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp +++ b/mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp @@ -28,9 +28,9 @@ using namespace mlir; namespace { static llvm::omp::ScheduleKind convertToScheduleKind(Optional<omp::ClauseScheduleKind> schedKind) { - if (!schedKind.has_value()) + if (!schedKind.hasValue()) return llvm::omp::OMP_SCHEDULE_Default; - switch (schedKind.value()) { + switch (schedKind.getValue()) { case omp::ClauseScheduleKind::Static: return llvm::omp::OMP_SCHEDULE_Static; case omp::ClauseScheduleKind::Dynamic: diff --git a/mlir/lib/Target/LLVMIR/ModuleTranslation.cpp b/mlir/lib/Target/LLVMIR/ModuleTranslation.cpp index 93498c7..923cffc1 100644 --- a/mlir/lib/Target/LLVMIR/ModuleTranslation.cpp +++ b/mlir/lib/Target/LLVMIR/ModuleTranslation.cpp @@ -666,17 +666,17 @@ LogicalResult ModuleTranslation::convertGlobals() { : llvm::GlobalValue::NotThreadLocal, addrSpace); - if (op.getUnnamedAddr().has_value()) + if (op.getUnnamedAddr().hasValue()) var->setUnnamedAddr(convertUnnamedAddrToLLVM(*op.getUnnamedAddr())); - if (op.getSection().has_value()) + if (op.getSection().hasValue()) var->setSection(*op.getSection()); addRuntimePreemptionSpecifier(op.getDsoLocal(), var); Optional<uint64_t> alignment = op.getAlignment(); - if (alignment) - var->setAlignment(llvm::MaybeAlign(alignment.value())); + if (alignment.hasValue()) + var->setAlignment(llvm::MaybeAlign(alignment.getValue())); globalsMapping.try_emplace(op, var); } diff --git a/mlir/lib/Target/SPIRV/Deserialization/Deserializer.cpp b/mlir/lib/Target/SPIRV/Deserialization/Deserializer.cpp index 383bdc4..361413e 100644 --- a/mlir/lib/Target/SPIRV/Deserialization/Deserializer.cpp +++ b/mlir/lib/Target/SPIRV/Deserialization/Deserializer.cpp @@ -377,7 +377,7 @@ spirv::Deserializer::processFunction(ArrayRef<uint32_t> operands) { std::string fnName = getFunctionSymbol(fnID); auto funcOp = opBuilder.create<spirv::FuncOp>( - unknownLoc, fnName, functionType, fnControl.value()); + unknownLoc, fnName, functionType, fnControl.getValue()); curFunction = funcMap[fnID] = funcOp; auto *entryBlock = funcOp.addEntryBlock(); LLVM_DEBUG({ @@ -883,7 +883,7 @@ spirv::Deserializer::processCooperativeMatrixType(ArrayRef<uint32_t> operands) { unsigned columns = getConstantInt(operands[4]).getInt(); typeMap[operands[0]] = spirv::CooperativeMatrixNVType::get( - elementTy, scope.value(), rows, columns); + elementTy, scope.getValue(), rows, columns); return success(); } @@ -1067,8 +1067,8 @@ spirv::Deserializer::processImageType(ArrayRef<uint32_t> operands) { << operands[7]; typeMap[operands[0]] = spirv::ImageType::get( - elementTy, dim.value(), depthInfo.value(), arrayedInfo.value(), - samplingInfo.value(), samplerUseInfo.value(), format.value()); + elementTy, dim.getValue(), depthInfo.getValue(), arrayedInfo.getValue(), + samplingInfo.getValue(), samplerUseInfo.getValue(), format.getValue()); return success(); } diff --git a/mlir/test/lib/Analysis/TestMemRefDependenceCheck.cpp b/mlir/test/lib/Analysis/TestMemRefDependenceCheck.cpp index a45e21a..eebd9e3 100644 --- a/mlir/test/lib/Analysis/TestMemRefDependenceCheck.cpp +++ b/mlir/test/lib/Analysis/TestMemRefDependenceCheck.cpp @@ -52,14 +52,16 @@ getDirectionVectorStr(bool ret, unsigned numCommonLoops, unsigned loopNestDepth, std::string result; for (const auto &dependenceComponent : dependenceComponents) { std::string lbStr = "-inf"; - if (dependenceComponent.lb.has_value() && - dependenceComponent.lb.value() != std::numeric_limits<int64_t>::min()) - lbStr = std::to_string(dependenceComponent.lb.value()); + if (dependenceComponent.lb.hasValue() && + dependenceComponent.lb.getValue() != + std::numeric_limits<int64_t>::min()) + lbStr = std::to_string(dependenceComponent.lb.getValue()); std::string ubStr = "+inf"; - if (dependenceComponent.ub.has_value() && - dependenceComponent.ub.value() != std::numeric_limits<int64_t>::max()) - ubStr = std::to_string(dependenceComponent.ub.value()); + if (dependenceComponent.ub.hasValue() && + dependenceComponent.ub.getValue() != + std::numeric_limits<int64_t>::max()) + ubStr = std::to_string(dependenceComponent.ub.getValue()); result += "[" + lbStr + ", " + ubStr + "]"; } diff --git a/mlir/test/lib/Dialect/Test/TestDialect.cpp b/mlir/test/lib/Dialect/Test/TestDialect.cpp index 64cf476..45d345e 100644 --- a/mlir/test/lib/Dialect/Test/TestDialect.cpp +++ b/mlir/test/lib/Dialect/Test/TestDialect.cpp @@ -1310,8 +1310,8 @@ void RegionIfOp::getSuccessorRegions( Optional<unsigned> index, ArrayRef<Attribute> operands, SmallVectorImpl<RegionSuccessor> ®ions) { // We always branch to the join region. - if (index) { - if (index.value() < 2) + if (index.hasValue()) { + if (index.getValue() < 2) regions.push_back(RegionSuccessor(&getJoinRegion(), getJoinArgs())); else regions.push_back(RegionSuccessor(getResults())); diff --git a/mlir/test/lib/Dialect/Test/TestTypeDefs.td b/mlir/test/lib/Dialect/Test/TestTypeDefs.td index 9853b4a..fd50dd3 100644 --- a/mlir/test/lib/Dialect/Test/TestTypeDefs.td +++ b/mlir/test/lib/Dialect/Test/TestTypeDefs.td @@ -292,9 +292,9 @@ class DefaultValuedAPFloat<string value> let parser = [{ [&]() -> mlir::FailureOr<llvm::Optional<llvm::APFloat>> { mlir::FloatAttr attr; auto result = $_parser.parseOptionalAttribute(attr); - if (result.has_value() && mlir::succeeded(*result)) + if (result.hasValue() && mlir::succeeded(*result)) return {attr.getValue()}; - if (!result.has_value()) + if (!result.hasValue()) return llvm::Optional<llvm::APFloat>(); return mlir::failure(); }() }]; diff --git a/mlir/test/lib/Dialect/Test/TestTypes.cpp b/mlir/test/lib/Dialect/Test/TestTypes.cpp index 76e67ed..5418025 100644 --- a/mlir/test/lib/Dialect/Test/TestTypes.cpp +++ b/mlir/test/lib/Dialect/Test/TestTypes.cpp @@ -414,15 +414,15 @@ Type TestDialect::parseTestType(AsmParser &parser, { Type genType; auto parseResult = generatedTypeParser(parser, typeTag, genType); - if (parseResult.has_value()) + if (parseResult.hasValue()) return genType; } { Type dynType; auto parseResult = parseOptionalDynamicType(typeTag, parser, dynType); - if (parseResult.has_value()) { - if (succeeded(parseResult.value())) + if (parseResult.hasValue()) { + if (succeeded(parseResult.getValue())) return dynType; return Type(); } diff --git a/mlir/test/lib/Dialect/Test/TestTypes.h b/mlir/test/lib/Dialect/Test/TestTypes.h index 654600b..bd6421d 100644 --- a/mlir/test/lib/Dialect/Test/TestTypes.h +++ b/mlir/test/lib/Dialect/Test/TestTypes.h @@ -77,7 +77,7 @@ struct FieldParser<Optional<int>> { Optional<int> value; value.emplace(); OptionalParseResult result = parser.parseOptionalInteger(*value); - if (result.has_value()) { + if (result.hasValue()) { if (succeeded(*result)) return value; return failure(); diff --git a/mlir/test/lib/Dialect/Transform/TestTransformDialectExtension.cpp b/mlir/test/lib/Dialect/Transform/TestTransformDialectExtension.cpp index a81090b..9242a51 100644 --- a/mlir/test/lib/Dialect/Transform/TestTransformDialectExtension.cpp +++ b/mlir/test/lib/Dialect/Transform/TestTransformDialectExtension.cpp @@ -52,12 +52,12 @@ public: static ParseResult parse(OpAsmParser &parser, OperationState &state) { StringAttr message; OptionalParseResult result = parser.parseOptionalAttribute(message); - if (!result.has_value()) + if (!result.hasValue()) return success(); - if (result.value().succeeded()) + if (result.getValue().succeeded()) state.addAttribute("message", message); - return result.value(); + return result.getValue(); } void print(OpAsmPrinter &printer) { diff --git a/mlir/test/lib/Transforms/TestIntRangeInference.cpp b/mlir/test/lib/Transforms/TestIntRangeInference.cpp index f9f8db4..1bd2a24 100644 --- a/mlir/test/lib/Transforms/TestIntRangeInference.cpp +++ b/mlir/test/lib/Transforms/TestIntRangeInference.cpp @@ -25,9 +25,9 @@ static LogicalResult replaceWithConstant(IntRangeAnalysis &analysis, Optional<ConstantIntRanges> maybeInferredRange = analysis.getResult(value); if (!maybeInferredRange) return failure(); - const ConstantIntRanges &inferredRange = maybeInferredRange.value(); + const ConstantIntRanges &inferredRange = maybeInferredRange.getValue(); Optional<APInt> maybeConstValue = inferredRange.getConstantValue(); - if (!maybeConstValue.has_value()) + if (!maybeConstValue.hasValue()) return failure(); Operation *maybeDefiningOp = value.getDefiningOp(); diff --git a/mlir/test/mlir-tblgen/default-type-attr-print-parser.td b/mlir/test/mlir-tblgen/default-type-attr-print-parser.td index 88328fd..ac898a9 100644 --- a/mlir/test/mlir-tblgen/default-type-attr-print-parser.td +++ b/mlir/test/mlir-tblgen/default-type-attr-print-parser.td @@ -32,7 +32,7 @@ def AttrA : TestAttr<"AttrA"> { // ATTR: { // ATTR: ::mlir::Attribute attr; // ATTR: auto parseResult = generatedAttributeParser(parser, attrTag, type, attr); -// ATTR: if (parseResult.has_value()) +// ATTR: if (parseResult.hasValue()) // ATTR: return attr; // ATTR: } // ATTR: parser.emitError(typeLoc) << "unknown attribute `" @@ -61,7 +61,7 @@ def TypeA : TestType<"TypeA"> { // TYPE: return ::mlir::Type(); // TYPE: ::mlir::Type genType; // TYPE: auto parseResult = generatedTypeParser(parser, mnemonic, genType); -// TYPE: if (parseResult.has_value()) +// TYPE: if (parseResult.hasValue()) // TYPE: return genType; // TYPE: parser.emitError(typeLoc) << "unknown type `" // TYPE: << mnemonic << "` in dialect `" << getNamespace() << "`"; diff --git a/mlir/tools/mlir-linalg-ods-gen/mlir-linalg-ods-yaml-gen.cpp b/mlir/tools/mlir-linalg-ods-gen/mlir-linalg-ods-yaml-gen.cpp index 2c28d0e..9140c53 100644 --- a/mlir/tools/mlir-linalg-ods-gen/mlir-linalg-ods-yaml-gen.cpp +++ b/mlir/tools/mlir-linalg-ods-gen/mlir-linalg-ods-yaml-gen.cpp @@ -730,16 +730,16 @@ static LogicalResult generateNamedGenericOpOds(LinalgOpConfig &opConfig, } // Add the index attributes to the op definition and builders. if (arg.kind == LinalgOperandDefKind::IndexAttr) { - assert(arg.indexAttrMap.has_value()); - assert(arg.defaultIndices.has_value()); + assert(arg.indexAttrMap.hasValue()); + assert(arg.defaultIndices.hasValue()); size_t size = arg.indexAttrMap->affineMap().getNumResults(); - assert(arg.defaultIndices->size() == size); + assert(arg.defaultIndices.getValue().size() == size); static const char typeFmt[] = "RankedI64ElementsAttr<[{0}]>"; static const char defFmt[] = "DefaultValuedAttr<{0}, \"{ {1} }\">:${2}"; std::string defaultVals; llvm::raw_string_ostream ss(defaultVals); llvm::interleave( - arg.defaultIndices.value(), ss, + arg.defaultIndices.getValue(), ss, [&](int64_t val) { ss << "static_cast<int64_t>(" << val << ")"; }, ", "); attrDefs.push_back(llvm::formatv(defFmt, llvm::formatv(typeFmt, size), @@ -1088,11 +1088,11 @@ if ({1}Iter != attrs.end()) {{ if (expression.scalarFn->attrName) { if (llvm::none_of(args, [&](LinalgOperandDef &arg) { return isFunctionAttribute(arg.kind) && - arg.name == expression.scalarFn->attrName.value(); + arg.name == expression.scalarFn->attrName.getValue(); })) { emitError(genContext.getLoc()) << "missing function attribute " - << expression.scalarFn->attrName.value(); + << expression.scalarFn->attrName.getValue(); } funcType = llvm::formatv("{0}Val", *expression.scalarFn->attrName); } @@ -1101,17 +1101,17 @@ if ({1}Iter != attrs.end()) {{ // Add the optional type parameter to the operands. SmallVector<std::string> operandCppValues; if (expression.scalarFn->kind == ScalarFnKind::Type) { - assert(expression.scalarFn->typeVar.has_value()); + assert(expression.scalarFn->typeVar.hasValue()); Optional<std::string> typeCppValue = - findTypeValue(expression.scalarFn->typeVar.value(), args); + findTypeValue(expression.scalarFn->typeVar.getValue(), args); if (!typeCppValue) { emitError(genContext.getLoc()) - << "type variable " << expression.scalarFn->typeVar.value() + << "type variable " << expression.scalarFn->typeVar.getValue() << ", used in a type conversion, must map to a predefined or " << "an argument type but it does not"; return None; } - operandCppValues.push_back(typeCppValue.value()); + operandCppValues.push_back(typeCppValue.getValue()); } // Collect the scalar operands. diff --git a/mlir/tools/mlir-tblgen/AttrOrTypeDefGen.cpp b/mlir/tools/mlir-tblgen/AttrOrTypeDefGen.cpp index 53cc698..759143d 100644 --- a/mlir/tools/mlir-tblgen/AttrOrTypeDefGen.cpp +++ b/mlir/tools/mlir-tblgen/AttrOrTypeDefGen.cpp @@ -678,7 +678,7 @@ static const char *const dialectDefaultAttrPrinterParserDispatch = R"( {{ ::mlir::Attribute attr; auto parseResult = generatedAttributeParser(parser, attrTag, type, attr); - if (parseResult.has_value()) + if (parseResult.hasValue()) return attr; } {1} @@ -700,8 +700,8 @@ static const char *const dialectDynamicAttrParserDispatch = R"( { ::mlir::Attribute genAttr; auto parseResult = parseOptionalDynamicAttr(attrTag, parser, genAttr); - if (parseResult.has_value()) { - if (::mlir::succeeded(*parseResult)) + if (parseResult.hasValue()) { + if (::mlir::succeeded(parseResult.getValue())) return genAttr; return Attribute(); } @@ -727,7 +727,7 @@ static const char *const dialectDefaultTypePrinterParserDispatch = R"( return ::mlir::Type(); ::mlir::Type genType; auto parseResult = generatedTypeParser(parser, mnemonic, genType); - if (parseResult.has_value()) + if (parseResult.hasValue()) return genType; {1} parser.emitError(typeLoc) << "unknown type `" @@ -747,7 +747,7 @@ void {0}::printType(::mlir::Type type, static const char *const dialectDynamicTypeParserDispatch = R"( { auto parseResult = parseOptionalDynamicType(mnemonic, parser, genType); - if (parseResult.has_value()) { + if (parseResult.hasValue()) { if (::mlir::succeeded(parseResult.getValue())) return genType; return Type(); diff --git a/mlir/tools/mlir-tblgen/OpFormatGen.cpp b/mlir/tools/mlir-tblgen/OpFormatGen.cpp index 1269622..212fe0e 100644 --- a/mlir/tools/mlir-tblgen/OpFormatGen.cpp +++ b/mlir/tools/mlir-tblgen/OpFormatGen.cpp @@ -408,7 +408,7 @@ const char *const optionalAttrParserCode = R"( { ::mlir::OptionalParseResult parseResult = parser.parseOptionalAttribute({0}Attr, {1}, "{0}", result.attributes); - if (parseResult.has_value() && failed(*parseResult)) + if (parseResult.hasValue() && failed(*parseResult)) return ::mlir::failure(); } )"; @@ -445,7 +445,7 @@ const char *const enumAttrParserCode = R"( parser.parseOptionalAttribute(attrVal, parser.getBuilder().getNoneType(), "{0}", attrStorage); - if (parseResult.has_value()) {{ + if (parseResult.hasValue()) {{ if (failed(*parseResult)) return ::mlir::failure(); attrStr = attrVal.getValue(); @@ -479,7 +479,7 @@ const char *const optionalOperandParserCode = R"( ::mlir::OpAsmParser::UnresolvedOperand operand; ::mlir::OptionalParseResult parseResult = parser.parseOptionalOperand(operand); - if (parseResult.has_value()) { + if (parseResult.hasValue()) { if (failed(*parseResult)) return ::mlir::failure(); {0}Operands.push_back(operand); @@ -532,7 +532,7 @@ const char *const optionalTypeParserCode = R"( ::mlir::Type optionalType; ::mlir::OptionalParseResult parseResult = parser.parseOptionalType(optionalType); - if (parseResult.has_value()) { + if (parseResult.hasValue()) { if (failed(*parseResult)) return ::mlir::failure(); {0}Types.push_back(optionalType); @@ -584,7 +584,7 @@ const char *regionListParserCode = R"( { std::unique_ptr<::mlir::Region> region; auto firstRegionResult = parser.parseOptionalRegion(region); - if (firstRegionResult.has_value()) { + if (firstRegionResult.hasValue()) { if (failed(*firstRegionResult)) return ::mlir::failure(); {0}Regions.emplace_back(std::move(region)); @@ -622,7 +622,7 @@ const char *regionListEnsureSingleBlockParserCode = R"( const char *optionalRegionParserCode = R"( { auto parseResult = parser.parseOptionalRegion(*{0}Region); - if (parseResult.has_value() && failed(*parseResult)) + if (parseResult.hasValue() && failed(*parseResult)) return ::mlir::failure(); } )"; @@ -656,7 +656,7 @@ const char *successorListParserCode = R"( { ::mlir::Block *succ; auto firstSucc = parser.parseOptionalSuccessor(succ); - if (firstSucc.has_value()) { + if (firstSucc.hasValue()) { if (failed(*firstSucc)) return ::mlir::failure(); {0}Successors.emplace_back(succ); diff --git a/mlir/unittests/Analysis/Presburger/IntegerPolyhedronTest.cpp b/mlir/unittests/Analysis/Presburger/IntegerPolyhedronTest.cpp index 5929e92..f69b4ee 100644 --- a/mlir/unittests/Analysis/Presburger/IntegerPolyhedronTest.cpp +++ b/mlir/unittests/Analysis/Presburger/IntegerPolyhedronTest.cpp @@ -66,8 +66,8 @@ static void checkSample(bool hasSample, const IntegerPolyhedron &poly, maybeLexMin = poly.findIntegerLexMin(); if (!hasSample) { - EXPECT_FALSE(maybeSample.has_value()); - if (maybeSample.has_value()) { + EXPECT_FALSE(maybeSample.hasValue()); + if (maybeSample.hasValue()) { llvm::errs() << "findIntegerSample gave sample: "; dump(*maybeSample); } @@ -78,7 +78,7 @@ static void checkSample(bool hasSample, const IntegerPolyhedron &poly, dump(*maybeLexMin); } } else { - ASSERT_TRUE(maybeSample.has_value()); + ASSERT_TRUE(maybeSample.hasValue()); EXPECT_TRUE(poly.containsPoint(*maybeSample)); ASSERT_FALSE(maybeLexMin.isEmpty()); diff --git a/mlir/unittests/Analysis/Presburger/PWMAFunctionTest.cpp b/mlir/unittests/Analysis/Presburger/PWMAFunctionTest.cpp index 1c959c6..27d0252 100644 --- a/mlir/unittests/Analysis/Presburger/PWMAFunctionTest.cpp +++ b/mlir/unittests/Analysis/Presburger/PWMAFunctionTest.cpp @@ -138,7 +138,7 @@ TEST(PWMAFunction, valueAt) { EXPECT_THAT(*nonNegPWMAF.valueAt({2, 3}), ElementsAre(11, 23)); EXPECT_THAT(*nonNegPWMAF.valueAt({-2, 3}), ElementsAre(11, 23)); EXPECT_THAT(*nonNegPWMAF.valueAt({2, -3}), ElementsAre(-1, -1)); - EXPECT_FALSE(nonNegPWMAF.valueAt({-2, -3}).has_value()); + EXPECT_FALSE(nonNegPWMAF.valueAt({-2, -3}).hasValue()); PWMAFunction divPWMAF = parsePWMAF( /*numInputs=*/2, /*numOutputs=*/2, @@ -149,11 +149,11 @@ TEST(PWMAFunction, valueAt) { }); EXPECT_THAT(*divPWMAF.valueAt({4, 3}), ElementsAre(11, 23)); EXPECT_THAT(*divPWMAF.valueAt({4, -3}), ElementsAre(-1, -1)); - EXPECT_FALSE(divPWMAF.valueAt({3, 3}).has_value()); - EXPECT_FALSE(divPWMAF.valueAt({3, -3}).has_value()); + EXPECT_FALSE(divPWMAF.valueAt({3, 3}).hasValue()); + EXPECT_FALSE(divPWMAF.valueAt({3, -3}).hasValue()); EXPECT_THAT(*divPWMAF.valueAt({-2, 3}), ElementsAre(11, 23)); - EXPECT_FALSE(divPWMAF.valueAt({-2, -3}).has_value()); + EXPECT_FALSE(divPWMAF.valueAt({-2, -3}).hasValue()); } TEST(PWMAFunction, removeIdRangeRegressionTest) { diff --git a/mlir/unittests/Analysis/Presburger/PresburgerSetTest.cpp b/mlir/unittests/Analysis/Presburger/PresburgerSetTest.cpp index aa71825..0c98f48 100644 --- a/mlir/unittests/Analysis/Presburger/PresburgerSetTest.cpp +++ b/mlir/unittests/Analysis/Presburger/PresburgerSetTest.cpp @@ -762,7 +762,7 @@ void testComputeReprAtPoints(IntegerPolyhedron poly, EXPECT_TRUE(repr.hasOnlyDivLocals()); EXPECT_TRUE(repr.getSpace().isCompatible(poly.getSpace())); for (const SmallVector<int64_t, 4> &point : points) { - EXPECT_EQ(poly.containsPointNoLocal(point).has_value(), + EXPECT_EQ(poly.containsPointNoLocal(point).hasValue(), repr.containsPoint(point)); } } diff --git a/mlir/unittests/Analysis/Presburger/SimplexTest.cpp b/mlir/unittests/Analysis/Presburger/SimplexTest.cpp index df03935..4c55c92 100644 --- a/mlir/unittests/Analysis/Presburger/SimplexTest.cpp +++ b/mlir/unittests/Analysis/Presburger/SimplexTest.cpp @@ -196,7 +196,7 @@ TEST(SimplexTest, getSamplePointIfIntegral) { }, {}) .getSamplePointIfIntegral() - .has_value()); + .hasValue()); auto maybeSample = simplexFromConstraints(2, {// x = y - 2. @@ -208,7 +208,7 @@ TEST(SimplexTest, getSamplePointIfIntegral) { {}) .getSamplePointIfIntegral(); - EXPECT_TRUE(maybeSample.has_value()); + EXPECT_TRUE(maybeSample.hasValue()); EXPECT_THAT(*maybeSample, testing::ElementsAre(0, 2)); auto maybeSample2 = simplexFromConstraints(2, @@ -220,7 +220,7 @@ TEST(SimplexTest, getSamplePointIfIntegral) { {0, 1, -2} // y = 2. }) .getSamplePointIfIntegral(); - EXPECT_TRUE(maybeSample2.has_value()); + EXPECT_TRUE(maybeSample2.hasValue()); EXPECT_THAT(*maybeSample2, testing::ElementsAre(0, 2)); EXPECT_FALSE(simplexFromConstraints(1, @@ -229,7 +229,7 @@ TEST(SimplexTest, getSamplePointIfIntegral) { {-2, +1}}, {}) .getSamplePointIfIntegral() - .has_value()); + .hasValue()); } /// Some basic sanity checks involving zero or one variables. @@ -545,7 +545,7 @@ TEST(SimplexTest, addDivisionVariable) { simplex.addInequality({1, 0, -3}); // x >= 3. simplex.addInequality({-1, 0, 9}); // x <= 9. Optional<SmallVector<int64_t, 8>> sample = simplex.findIntegerSample(); - ASSERT_TRUE(sample.has_value()); + ASSERT_TRUE(sample.hasValue()); EXPECT_EQ((*sample)[0] / 2, (*sample)[1]); } diff --git a/mlir/unittests/IR/OperationSupportTest.cpp b/mlir/unittests/IR/OperationSupportTest.cpp index 4f6a98d..2511a5d3 100644 --- a/mlir/unittests/IR/OperationSupportTest.cpp +++ b/mlir/unittests/IR/OperationSupportTest.cpp @@ -247,7 +247,7 @@ TEST(NamedAttrListTest, TestAppendAssign) { attrs.append("foo", b.getStringAttr("zoo")); { auto dup = attrs.findDuplicate(); - ASSERT_TRUE(dup.has_value()); + ASSERT_TRUE(dup.hasValue()); } SmallVector<NamedAttribute> newAttrs = { @@ -257,7 +257,7 @@ TEST(NamedAttrListTest, TestAppendAssign) { attrs.assign(newAttrs); auto dup = attrs.findDuplicate(); - ASSERT_FALSE(dup.has_value()); + ASSERT_FALSE(dup.hasValue()); { auto *it = attrs.begin(); diff --git a/mlir/unittests/Interfaces/ControlFlowInterfacesTest.cpp b/mlir/unittests/Interfaces/ControlFlowInterfacesTest.cpp index af02a45..b92f319 100644 --- a/mlir/unittests/Interfaces/ControlFlowInterfacesTest.cpp +++ b/mlir/unittests/Interfaces/ControlFlowInterfacesTest.cpp @@ -79,7 +79,7 @@ struct DoubleLoopRegionsOp void getSuccessorRegions(Optional<unsigned> index, ArrayRef<Attribute> operands, SmallVectorImpl<RegionSuccessor> ®ions) { - if (index.has_value()) { + if (index.hasValue()) { regions.push_back(RegionSuccessor()); regions.push_back(RegionSuccessor(&getOperation()->getRegion(*index))); } diff --git a/mlir/unittests/Pass/AnalysisManagerTest.cpp b/mlir/unittests/Pass/AnalysisManagerTest.cpp index 5fa17f3..cef8da7 100644 --- a/mlir/unittests/Pass/AnalysisManagerTest.cpp +++ b/mlir/unittests/Pass/AnalysisManagerTest.cpp @@ -52,8 +52,8 @@ TEST(AnalysisManagerTest, FineGrainModuleAnalysisPreservation) { am.invalidate(pa); // Check that only MyAnalysis is preserved. - EXPECT_TRUE(am.getCachedAnalysis<MyAnalysis>().has_value()); - EXPECT_FALSE(am.getCachedAnalysis<OtherAnalysis>().has_value()); + EXPECT_TRUE(am.getCachedAnalysis<MyAnalysis>().hasValue()); + EXPECT_FALSE(am.getCachedAnalysis<OtherAnalysis>().hasValue()); } TEST(AnalysisManagerTest, FineGrainFunctionAnalysisPreservation) { @@ -83,8 +83,8 @@ TEST(AnalysisManagerTest, FineGrainFunctionAnalysisPreservation) { fam.invalidate(pa); // Check that only MyAnalysis is preserved. - EXPECT_TRUE(fam.getCachedAnalysis<MyAnalysis>().has_value()); - EXPECT_FALSE(fam.getCachedAnalysis<OtherAnalysis>().has_value()); + EXPECT_TRUE(fam.getCachedAnalysis<MyAnalysis>().hasValue()); + EXPECT_FALSE(fam.getCachedAnalysis<OtherAnalysis>().hasValue()); } TEST(AnalysisManagerTest, FineGrainChildFunctionAnalysisPreservation) { @@ -106,7 +106,7 @@ TEST(AnalysisManagerTest, FineGrainChildFunctionAnalysisPreservation) { AnalysisManager am = mam; // Check that the analysis cache is initially empty. - EXPECT_FALSE(am.getCachedChildAnalysis<MyAnalysis>(func1).has_value()); + EXPECT_FALSE(am.getCachedChildAnalysis<MyAnalysis>(func1).hasValue()); // Query two different analyses, but only preserve one before invalidating. am.getChildAnalysis<MyAnalysis>(func1); @@ -117,8 +117,8 @@ TEST(AnalysisManagerTest, FineGrainChildFunctionAnalysisPreservation) { am.invalidate(pa); // Check that only MyAnalysis is preserved. - EXPECT_TRUE(am.getCachedChildAnalysis<MyAnalysis>(func1).has_value()); - EXPECT_FALSE(am.getCachedChildAnalysis<OtherAnalysis>(func1).has_value()); + EXPECT_TRUE(am.getCachedChildAnalysis<MyAnalysis>(func1).hasValue()); + EXPECT_FALSE(am.getCachedChildAnalysis<OtherAnalysis>(func1).hasValue()); } /// Test analyses with custom invalidation logic. @@ -150,13 +150,13 @@ TEST(AnalysisManagerTest, CustomInvalidation) { // Check that the analysis is invalidated properly. am.getAnalysis<CustomInvalidatingAnalysis>(); am.invalidate(pa); - EXPECT_FALSE(am.getCachedAnalysis<CustomInvalidatingAnalysis>().has_value()); + EXPECT_FALSE(am.getCachedAnalysis<CustomInvalidatingAnalysis>().hasValue()); // Check that the analysis is preserved properly. am.getAnalysis<CustomInvalidatingAnalysis>(); pa.preserve<TestAnalysisSet>(); am.invalidate(pa); - EXPECT_TRUE(am.getCachedAnalysis<CustomInvalidatingAnalysis>().has_value()); + EXPECT_TRUE(am.getCachedAnalysis<CustomInvalidatingAnalysis>().hasValue()); } TEST(AnalysisManagerTest, OpSpecificAnalysis) { @@ -169,7 +169,7 @@ TEST(AnalysisManagerTest, OpSpecificAnalysis) { // Query the op specific analysis for the module and verify that its cached. am.getAnalysis<OpSpecificAnalysis, ModuleOp>(); - EXPECT_TRUE(am.getCachedAnalysis<OpSpecificAnalysis>().has_value()); + EXPECT_TRUE(am.getCachedAnalysis<OpSpecificAnalysis>().hasValue()); } struct AnalysisWithDependency { @@ -194,15 +194,15 @@ TEST(AnalysisManagerTest, DependentAnalysis) { AnalysisManager am = mam; am.getAnalysis<AnalysisWithDependency>(); - EXPECT_TRUE(am.getCachedAnalysis<AnalysisWithDependency>().has_value()); - EXPECT_TRUE(am.getCachedAnalysis<MyAnalysis>().has_value()); + EXPECT_TRUE(am.getCachedAnalysis<AnalysisWithDependency>().hasValue()); + EXPECT_TRUE(am.getCachedAnalysis<MyAnalysis>().hasValue()); detail::PreservedAnalyses pa; pa.preserve<AnalysisWithDependency>(); am.invalidate(pa); - EXPECT_FALSE(am.getCachedAnalysis<AnalysisWithDependency>().has_value()); - EXPECT_FALSE(am.getCachedAnalysis<MyAnalysis>().has_value()); + EXPECT_FALSE(am.getCachedAnalysis<AnalysisWithDependency>().hasValue()); + EXPECT_FALSE(am.getCachedAnalysis<MyAnalysis>().hasValue()); } struct AnalysisWithNestedDependency { @@ -227,19 +227,18 @@ TEST(AnalysisManagerTest, NestedDependentAnalysis) { AnalysisManager am = mam; am.getAnalysis<AnalysisWithNestedDependency>(); - EXPECT_TRUE(am.getCachedAnalysis<AnalysisWithNestedDependency>().has_value()); - EXPECT_TRUE(am.getCachedAnalysis<AnalysisWithDependency>().has_value()); - EXPECT_TRUE(am.getCachedAnalysis<MyAnalysis>().has_value()); + EXPECT_TRUE(am.getCachedAnalysis<AnalysisWithNestedDependency>().hasValue()); + EXPECT_TRUE(am.getCachedAnalysis<AnalysisWithDependency>().hasValue()); + EXPECT_TRUE(am.getCachedAnalysis<MyAnalysis>().hasValue()); detail::PreservedAnalyses pa; pa.preserve<AnalysisWithDependency>(); pa.preserve<AnalysisWithNestedDependency>(); am.invalidate(pa); - EXPECT_FALSE( - am.getCachedAnalysis<AnalysisWithNestedDependency>().has_value()); - EXPECT_FALSE(am.getCachedAnalysis<AnalysisWithDependency>().has_value()); - EXPECT_FALSE(am.getCachedAnalysis<MyAnalysis>().has_value()); + EXPECT_FALSE(am.getCachedAnalysis<AnalysisWithNestedDependency>().hasValue()); + EXPECT_FALSE(am.getCachedAnalysis<AnalysisWithDependency>().hasValue()); + EXPECT_FALSE(am.getCachedAnalysis<MyAnalysis>().hasValue()); } struct AnalysisWith2Ctors { diff --git a/polly/lib/Exchange/JSONExporter.cpp b/polly/lib/Exchange/JSONExporter.cpp index d882ea6..e92055b 100644 --- a/polly/lib/Exchange/JSONExporter.cpp +++ b/polly/lib/Exchange/JSONExporter.cpp @@ -218,8 +218,8 @@ static bool importContext(Scop &S, const json::Object &JScop) { return false; } - isl::set NewContext = - isl::set{S.getIslCtx().get(), JScop.getString("context")->str()}; + isl::set NewContext = isl::set{S.getIslCtx().get(), + JScop.getString("context").getValue().str()}; // Check whether the context was parsed successfully. if (NewContext.is_null()) { @@ -290,10 +290,10 @@ static bool importSchedule(Scop &S, const json::Object &JScop, } Optional<StringRef> Schedule = statements[Index].getAsObject()->getString("schedule"); - assert(Schedule && + assert(Schedule.hasValue() && "Schedules that contain extension nodes require special handling."); - isl_map *Map = - isl_map_read_from_str(S.getIslCtx().get(), Schedule->str().c_str()); + isl_map *Map = isl_map_read_from_str(S.getIslCtx().get(), + Schedule.getValue().str().c_str()); // Check whether the schedule was parsed successfully if (!Map) { @@ -575,14 +575,14 @@ static bool areArraysEqual(ScopArrayInfo *SAI, const json::Object &Array) { for (unsigned i = 1; i < Array.getArray("sizes")->size(); i++) { SAI->getDimensionSize(i)->print(RawStringOstream); const json::Array &SizesArray = *Array.getArray("sizes"); - if (RawStringOstream.str() != SizesArray[i].getAsString().value()) + if (RawStringOstream.str() != SizesArray[i].getAsString().getValue()) return false; Buffer.clear(); } // Check if key 'type' differs from the current one or is not valid. SAI->getElementType()->print(RawStringOstream); - if (RawStringOstream.str() != Array.getString("type").value()) { + if (RawStringOstream.str() != Array.getString("type").getValue()) { errs() << "Array has not a valid type.\n"; return false; } @@ -652,8 +652,9 @@ static bool importArrays(Scop &S, const json::Object &JScop) { for (; ArrayIdx < Arrays.size(); ArrayIdx++) { const json::Object &Array = *Arrays[ArrayIdx].getAsObject(); - auto *ElementType = parseTextType(Array.get("type")->getAsString()->str(), - S.getSE()->getContext()); + auto *ElementType = + parseTextType(Array.get("type")->getAsString().getValue().str(), + S.getSE()->getContext()); if (!ElementType) { errs() << "Error while parsing element type for new array.\n"; return false; @@ -673,10 +674,10 @@ static bool importArrays(Scop &S, const json::Object &JScop) { } auto NewSAI = S.createScopArrayInfo( - ElementType, Array.getString("name")->str(), DimSizes); + ElementType, Array.getString("name").getValue().str(), DimSizes); if (Array.get("allocation")) { - NewSAI->setIsOnHeap(Array.getString("allocation").value() == "heap"); + NewSAI->setIsOnHeap(Array.getString("allocation").getValue() == "heap"); } } diff --git a/polly/lib/Transform/ManualOptimizer.cpp b/polly/lib/Transform/ManualOptimizer.cpp index 21d83d9..ef705ec 100644 --- a/polly/lib/Transform/ManualOptimizer.cpp +++ b/polly/lib/Transform/ManualOptimizer.cpp @@ -42,8 +42,8 @@ static TransformationMode hasUnrollTransformation(MDNode *LoopID) { Optional<int> Count = getOptionalIntLoopAttribute(LoopID, "llvm.loop.unroll.count"); - if (Count) - return *Count == 1 ? TM_SuppressedByUser : TM_ForcedByUser; + if (Count.hasValue()) + return Count.getValue() == 1 ? TM_SuppressedByUser : TM_ForcedByUser; if (getBooleanLoopAttribute(LoopID, "llvm.loop.unroll.enable")) return TM_ForcedByUser; diff --git a/polly/lib/Transform/MatmulOptimizer.cpp b/polly/lib/Transform/MatmulOptimizer.cpp index d7418d3..4a40fac 100644 --- a/polly/lib/Transform/MatmulOptimizer.cpp +++ b/polly/lib/Transform/MatmulOptimizer.cpp @@ -570,29 +570,29 @@ static void getTargetCacheParameters(const llvm::TargetTransformInfo *TTI) { auto L1DCache = llvm::TargetTransformInfo::CacheLevel::L1D; auto L2DCache = llvm::TargetTransformInfo::CacheLevel::L2D; if (FirstCacheLevelSize == -1) { - if (TTI->getCacheSize(L1DCache).has_value()) - FirstCacheLevelSize = TTI->getCacheSize(L1DCache).value(); + if (TTI->getCacheSize(L1DCache).hasValue()) + FirstCacheLevelSize = TTI->getCacheSize(L1DCache).getValue(); else FirstCacheLevelSize = static_cast<int>(FirstCacheLevelDefaultSize); } if (SecondCacheLevelSize == -1) { - if (TTI->getCacheSize(L2DCache).has_value()) - SecondCacheLevelSize = TTI->getCacheSize(L2DCache).value(); + if (TTI->getCacheSize(L2DCache).hasValue()) + SecondCacheLevelSize = TTI->getCacheSize(L2DCache).getValue(); else SecondCacheLevelSize = static_cast<int>(SecondCacheLevelDefaultSize); } if (FirstCacheLevelAssociativity == -1) { - if (TTI->getCacheAssociativity(L1DCache).has_value()) + if (TTI->getCacheAssociativity(L1DCache).hasValue()) FirstCacheLevelAssociativity = - TTI->getCacheAssociativity(L1DCache).value(); + TTI->getCacheAssociativity(L1DCache).getValue(); else FirstCacheLevelAssociativity = static_cast<int>(FirstCacheLevelDefaultAssociativity); } if (SecondCacheLevelAssociativity == -1) { - if (TTI->getCacheAssociativity(L2DCache).has_value()) + if (TTI->getCacheAssociativity(L2DCache).hasValue()) SecondCacheLevelAssociativity = - TTI->getCacheAssociativity(L2DCache).value(); + TTI->getCacheAssociativity(L2DCache).getValue(); else SecondCacheLevelAssociativity = static_cast<int>(SecondCacheLevelDefaultAssociativity); |