[BOLT][NFC] Use std::optional in BAT

[Amir]

Summary

Part of an ongoing migration from llvm::Optional to std::optional:

https://discourse.llvm.org/t/deprecating-llvm-optional-x-hasvalue-getvalue-getvalueor/63716

[kazu]

Thanks a lot!

[Amir]

3d573fdbb49a0a106a0825d331dee4b87eb5d3c9

bolt/include/bolt/Profile/BoltAddressTranslation.h

 //===- bolt/Profile/BoltAddressTranslation.h --------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef BOLT_PROFILE_BOLTADDRESSTRANSLATION_H
 #define BOLT_PROFILE_BOLTADDRESSTRANSLATION_H
 
-#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringRef.h"
 #include <cstdint>
 #include <map>
+#include <optional>
 #include <system_error>
 
 namespace llvm {
 class raw_ostream;
 
 namespace object {
 class ELFObjectFileBase;
 } // namespace object
public:
   /// addresses in function located at \p FuncAddress.
   uint64_t translate(uint64_t FuncAddress, uint64_t Offset,
                      bool IsBranchSrc) const;
 
   /// Use the map keys containing basic block addresses to infer fall-throughs
   /// taken in the path started at FirstLBR.To and ending at SecondLBR.From.
   /// Return std::nullopt if trace is invalid or the list of fall-throughs
   /// otherwise.
-  Optional<FallthroughListTy> getFallthroughsInTrace(uint64_t FuncAddress,
+  std::optional<FallthroughListTy> getFallthroughsInTrace(uint64_t FuncAddress,
                                                           uint64_t From,
                                                           uint64_t To) const;
 
   /// If available, fetch the address of the hot part linked to the cold part
   /// at \p Address. Return 0 otherwise.
   uint64_t fetchParentAddress(uint64_t Address) const;
 
   /// True if the input binary has a translation table we can use to convert
   /// addresses when aggregating profile
   bool enabledFor(llvm::object::ELFObjectFileBase *InputFile) const;

bolt/include/bolt/Profile/DataAggregator.h

private:
   /// Return true if the trace is valid, false otherwise.
   bool recordTrace(
       BinaryFunction &BF, const LBREntry &First, const LBREntry &Second,
       uint64_t Count = 1,
       SmallVector<std::pair<uint64_t, uint64_t>, 16> *Branches = nullptr) const;
 
   /// Return a vector of offsets corresponding to a trace in a function
   /// (see recordTrace() above).
-  Optional<SmallVector<std::pair<uint64_t, uint64_t>, 16>>
+  std::optional<SmallVector<std::pair<uint64_t, uint64_t>, 16>>
   getFallthroughsInTrace(BinaryFunction &BF, const LBREntry &First,
                          const LBREntry &Second, uint64_t Count = 1) const;
 
   /// Record external entry into the function \p BF.
   ///
   /// Return true if the entry is valid, false otherwise.
   bool recordEntry(BinaryFunction &BF, uint64_t To, bool Mispred,
                    uint64_t Count = 1) const;

bolt/lib/Profile/BoltAddressTranslation.cpp

uint64_t BoltAddressTranslation::translate(uint64_t FuncAddress,
   // Branch source addresses are translated to the first instruction of the
   // source BB to avoid accounting for modifications BOLT may have made in the
   // BB regarding deletion/addition of instructions.
   if (IsBranchSrc)
     return Val;
   return Offset - KeyVal->first + Val;
 }
 
-Optional<BoltAddressTranslation::FallthroughListTy>
+std::optional<BoltAddressTranslation::FallthroughListTy>
 BoltAddressTranslation::getFallthroughsInTrace(uint64_t FuncAddress,
                                                uint64_t From,
                                                uint64_t To) const {
   SmallVector<std::pair<uint64_t, uint64_t>, 16> Res;
 
   // Filter out trivial case
   if (From >= To)
     return Res;

bolt/lib/Profile/DataAggregator.cpp

LLVM_DEBUG(
         dbgs() << "Invalid trace starting in " << FromFunc->getPrintName()
                << " @ " << Twine::utohexstr(First.To - FromFunc->getAddress())
                << " and ending in " << ToFunc->getPrintName() << " @ "
                << ToFunc->getPrintName() << " @ "
                << Twine::utohexstr(Second.From - ToFunc->getAddress()) << '\n');
     return false;
   }
 
-  Optional<BoltAddressTranslation::FallthroughListTy> FTs =
+  std::optional<BoltAddressTranslation::FallthroughListTy> FTs =
       BAT ? BAT->getFallthroughsInTrace(FromFunc->getAddress(), First.To,
                                         Second.From)
           : getFallthroughsInTrace(*FromFunc, First, Second, Count);
   if (!FTs) {
     LLVM_DEBUG(
         dbgs() << "Invalid trace starting in " << FromFunc->getPrintName()
                << " @ " << Twine::utohexstr(First.To - FromFunc->getAddress())
                << " and ending in " << ToFunc->getPrintName() << " @ "
while (BB != ToBB) {
     }
 
     BB = NextBB;
   }
 
   return true;
 }
 
-Optional<SmallVector<std::pair<uint64_t, uint64_t>, 16>>
+std::optional<SmallVector<std::pair<uint64_t, uint64_t>, 16>>
 DataAggregator::getFallthroughsInTrace(BinaryFunction &BF,
                                        const LBREntry &FirstLBR,
                                        const LBREntry &SecondLBR,
                                        uint64_t Count) const {
   SmallVector<std::pair<uint64_t, uint64_t>, 16> Res;
 
   if (!recordTrace(BF, FirstLBR, SecondLBR, Count, &Res))
     return std::nullopt;