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

[Amir]

e8d6c537ac7c1caea865860fd32c1ba2623c4ddc

bolt/include/bolt/Passes/ReachingDefOrUse.h

 //===- bolt/Passes/ReachingDefOrUse.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_PASSES_REACHINGDEFORUSE_H
 #define BOLT_PASSES_REACHINGDEFORUSE_H
 
 #include "bolt/Passes/DataflowAnalysis.h"
 #include "bolt/Passes/RegAnalysis.h"
-#include "llvm/ADT/Optional.h"
 #include "llvm/MC/MCRegisterInfo.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Timer.h"
 
 namespace opts {
 extern llvm::cl::opt<bool> TimeOpts;
 }
 
 namespace llvm {
 namespace bolt {
 
 /// If \p Def is true, this computes a forward dataflow equation to
 /// propagate reaching definitions.
 /// If false, this computes a backward dataflow equation propagating
 /// uses to their definitions.
 template <bool Def = false>
 class ReachingDefOrUse
     : public InstrsDataflowAnalysis<ReachingDefOrUse<Def>, !Def> {
   friend class DataflowAnalysis<ReachingDefOrUse<Def>, BitVector, !Def>;
 
 public:
   ReachingDefOrUse(const RegAnalysis &RA, BinaryFunction &BF,
-                   Optional<MCPhysReg> TrackingReg = std::nullopt,
+                   std::optional<MCPhysReg> TrackingReg = std::nullopt,
                    MCPlusBuilder::AllocatorIdTy AllocId = 0)
       : InstrsDataflowAnalysis<ReachingDefOrUse<Def>, !Def>(BF, AllocId),
         RA(RA), TrackingReg(TrackingReg) {}
   virtual ~ReachingDefOrUse() {}
 
   bool isReachedBy(MCPhysReg Reg, ExprIterator Candidates) {
     for (auto I = Candidates; I != this->expr_end(); ++I) {
       BitVector BV = BitVector(this->BC.MRI->getNumRegs(), false);
public:
   void run() { InstrsDataflowAnalysis<ReachingDefOrUse<Def>, !Def>::run(); }
 
 protected:
   /// Reference to the result of reg analysis
   const RegAnalysis &RA;
 
   /// If set, limit the dataflow to only track instructions affecting this
   /// register. Otherwise the analysis can be too permissive.
-  Optional<MCPhysReg> TrackingReg;
+  std::optional<MCPhysReg> TrackingReg;
 
   void preflight() {
     // Populate our universe of tracked expressions with all instructions
     // except pseudos
     for (BinaryBasicBlock &BB : this->Func) {
       for (MCInst &Inst : BB) {
         this->Expressions.push_back(&Inst);
         this->ExprToIdx[&Inst] = this->NumInstrs++;