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

[maksfb]

LGTM

[Amir]

Rebase

bolt/include/bolt/Core/BinaryFunction.h

 //===- bolt/Core/BinaryFunction.h - Low-level function ----------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
const BinaryBasicBlock *getBasicBlockForLabel(const MCSymbol *Label) const {
     return LabelToBB.lookup(Label);
   }
 
   /// Retrieve the landing pad BB associated with invoke instruction \p Invoke
   /// that is in \p BB. Return nullptr if none exists
   BinaryBasicBlock *getLandingPadBBFor(const BinaryBasicBlock &BB,
                                        const MCInst &InvokeInst) const {
     assert(BC.MIB->isInvoke(InvokeInst) && "must be invoke instruction");
-    const Optional<MCPlus::MCLandingPad> LP = BC.MIB->getEHInfo(InvokeInst);
+    const std::optional<MCPlus::MCLandingPad> LP =
+        BC.MIB->getEHInfo(InvokeInst);
     if (LP && LP->first) {
       BinaryBasicBlock *LBB = BB.getLandingPad(LP->first);
       assert(LBB && "Landing pad should be defined");
       return LBB;
     }
     return nullptr;
   }
 

bolt/include/bolt/Core/MCPlusBuilder.h

 //===- bolt/Core/MCPlusBuilder.h - Interface for MCPlus ---------*- 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This file contains the declaration of MCPlusBuilder class, which provides
 // means to create/analyze/modify instructions at MCPlus level.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef BOLT_CORE_MCPLUSBUILDER_H
 #define BOLT_CORE_MCPLUSBUILDER_H
 
 #include "bolt/Core/MCPlus.h"
 #include "bolt/Core/Relocation.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/BitVector.h"
-#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/MC/MCAsmBackend.h"
 #include "llvm/MC/MCDisassembler/MCSymbolizer.h"
 #include "llvm/MC/MCExpr.h"
 #include "llvm/MC/MCInst.h"
 #include "llvm/MC/MCInstrAnalysis.h"
 #include "llvm/MC/MCInstrDesc.h"
 #include "llvm/MC/MCInstrInfo.h"
 #include "llvm/Support/Allocator.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/ErrorOr.h"
 #include <cassert>
 #include <cstdint>
 #include <map>
+#include <optional>
 #include <system_error>
 #include <unordered_map>
 #include <unordered_set>
 
 namespace llvm {
 class MCContext;
 class MCFixup;
 class MCRegisterInfo;
for (int I = AnnotationInst->getNumOperands() - 1; I >= 0; --I) {
         AnnotationInst->getOperand(I).setImm(AnnotationValue);
         return;
       }
     }
 
     AnnotationInst->addOperand(MCOperand::createImm(AnnotationValue));
   }
 
-  Optional<int64_t> getAnnotationOpValue(const MCInst &Inst,
+  std::optional<int64_t> getAnnotationOpValue(const MCInst &Inst,
                                               unsigned Index) const {
     const MCInst *AnnotationInst = getAnnotationInst(Inst);
     if (!AnnotationInst)
       return std::nullopt;
 
     for (int I = AnnotationInst->getNumOperands() - 1; I >= 0; --I) {
       int64_t ImmValue = AnnotationInst->getOperand(I).getImm();
       if (extractAnnotationIndex(ImmValue) == Index) {
         return extractAnnotationValue(ImmValue);
public:
   /// Return true if \p Inst is an instruction that potentially traps when
   /// working with addresses not aligned to the size of the operand.
   virtual bool requiresAlignedAddress(const MCInst &Inst) const {
     llvm_unreachable("not implemented");
     return false;
   }
 
   /// Return handler and action info for invoke instruction if present.
-  Optional<MCPlus::MCLandingPad> getEHInfo(const MCInst &Inst) const;
+  std::optional<MCPlus::MCLandingPad> getEHInfo(const MCInst &Inst) const;
 
   /// Add handler and action info for call instruction.
   void addEHInfo(MCInst &Inst, const MCPlus::MCLandingPad &LP);
 
   /// Update exception-handling info for the invoke instruction \p Inst.
   /// Return true on success and false otherwise, e.g. if the instruction is
   /// not an invoke.
   bool updateEHInfo(MCInst &Inst, const MCPlus::MCLandingPad &LP);
public:
   /// Set jump table addressed by this instruction.
   bool setJumpTable(MCInst &Inst, uint64_t Value, uint16_t IndexReg,
                     AllocatorIdTy AllocId = 0);
 
   /// Disassociate instruction with a jump table.
   bool unsetJumpTable(MCInst &Inst);
 
   /// Return destination of conditional tail call instruction if \p Inst is one.
-  Optional<uint64_t> getConditionalTailCall(const MCInst &Inst) const;
+  std::optional<uint64_t> getConditionalTailCall(const MCInst &Inst) const;
 
   /// Mark the \p Instruction as a conditional tail call, and set its
   /// destination address if it is known. If \p Instruction was already marked,
   /// update its destination with \p Dest.
   bool setConditionalTailCall(MCInst &Inst, uint64_t Dest = 0);
 
   /// If \p Inst was marked as a conditional tail call convert it to a regular
   /// branch. Return true if the instruction was converted.
   bool unsetConditionalTailCall(MCInst &Inst);
 
   /// Return offset of \p Inst in the original function, if available.
-  Optional<uint32_t> getOffset(const MCInst &Inst) const;
+  std::optional<uint32_t> getOffset(const MCInst &Inst) const;
 
   /// Return the offset if the annotation is present, or \p Default otherwise.
   uint32_t getOffsetWithDefault(const MCInst &Inst, uint32_t Default) const;
 
   /// Set offset of \p Inst in the original function.
   bool setOffset(MCInst &Inst, uint32_t Offset, AllocatorIdTy AllocatorId = 0);
 
   /// Remove offset annotation.

   /// (dest + n) instead of dest.
   virtual InstructionListType createInlineMemcpy(bool ReturnEnd) const {
     llvm_unreachable("not implemented");
     return {};
   }
 
   /// Create a target-specific relocation out of the \p Fixup.
   /// Note that not every fixup could be converted into a relocation.
-  virtual Optional<Relocation> createRelocation(const MCFixup &Fixup,
-                                                const MCAsmBackend &MAB) const {
+  virtual std::optional<Relocation>
+  createRelocation(const MCFixup &Fixup, const MCAsmBackend &MAB) const {
     llvm_unreachable("not implemented");
     return Relocation();
   }
 
   /// Returns true if instruction is a call frame pseudo instruction.
   virtual bool isCFI(const MCInst &Inst) const {
     return Inst.getOpcode() == TargetOpcode::CFI_INSTRUCTION;
   }
virtual bool createEHLabel(MCInst &Inst, const MCSymbol *Label,
     Inst.setOpcode(TargetOpcode::EH_LABEL);
     Inst.clear();
     Inst.addOperand(MCOperand::createExpr(
         MCSymbolRefExpr::create(Label, MCSymbolRefExpr::VK_None, *Ctx)));
     return true;
   }
 
   /// Return annotation index matching the \p Name.
-  Optional<unsigned> getAnnotationIndex(StringRef Name) const {
+  std::optional<unsigned> getAnnotationIndex(StringRef Name) const {
     auto AI = AnnotationNameIndexMap.find(Name);
     if (AI != AnnotationNameIndexMap.end())
       return AI->second;
     return std::nullopt;
   }
 
   /// Return annotation index matching the \p Name. Create a new index if the
   /// \p Name wasn't registered previously.
ValueType &getOrCreateAnnotationAs(MCInst &Inst, StringRef Name,
     const unsigned Index = getOrCreateAnnotationIndex(Name);
     return getOrCreateAnnotationAs<ValueType>(Inst, Index, AllocatorId);
   }
 
   /// Get an annotation as a specific value. Assumes that the annotation exists.
   /// Use hasAnnotation() if the annotation may not exist.
   template <typename ValueType>
   ValueType &getAnnotationAs(const MCInst &Inst, unsigned Index) const {
-    Optional<int64_t> Value = getAnnotationOpValue(Inst, Index);
+    std::optional<int64_t> Value = getAnnotationOpValue(Inst, Index);
     assert(Value && "annotation should exist");
     return reinterpret_cast<MCPlus::MCSimpleAnnotation<ValueType> *>(*Value)
         ->getValue();
   }
 
   /// Get an annotation as a specific value. Assumes that the annotation exists.
   /// Use hasAnnotation() if the annotation may not exist.
   template <typename ValueType>

bolt/lib/Core/BinaryContext.cpp

 //===- bolt/Core/BinaryContext.cpp - Low-level context --------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
if (MIB->isCFI(Instruction)) {
     OS << Endl;
     return;
   }
   InstPrinter->printInst(&Instruction, 0, "", *STI, OS);
   if (MIB->isCall(Instruction)) {
     if (MIB->isTailCall(Instruction))
       OS << " # TAILCALL ";
     if (MIB->isInvoke(Instruction)) {
-      const Optional<MCPlus::MCLandingPad> EHInfo = MIB->getEHInfo(Instruction);
+      const std::optional<MCPlus::MCLandingPad> EHInfo =
+          MIB->getEHInfo(Instruction);
       OS << " # handler: ";
       if (EHInfo->first)
         OS << *EHInfo->first;
       else
         OS << '0';
       OS << "; action: " << EHInfo->second;
       const int64_t GnuArgsSize = MIB->getGnuArgsSize(Instruction);
       if (GnuArgsSize >= 0)
         OS << "; GNU_args_size = " << GnuArgsSize;
     }
   } else if (MIB->isIndirectBranch(Instruction)) {
     if (uint64_t JTAddress = MIB->getJumpTable(Instruction)) {
       OS << " # JUMPTABLE @0x" << Twine::utohexstr(JTAddress);
     } else {
       OS << " # UNKNOWN CONTROL FLOW";
     }
   }
-  if (Optional<uint32_t> Offset = MIB->getOffset(Instruction))
+  if (std::optional<uint32_t> Offset = MIB->getOffset(Instruction))
     OS << " # Offset: " << *Offset;
 
   MIB->printAnnotations(Instruction, OS);
 
   if (opts::PrintDebugInfo)
     printDebugInfo(OS, Instruction, Function, DwCtx.get());
 
   if ((opts::PrintRelocations || PrintRelocations) && Function) {

bolt/lib/Core/BinaryFunction.cpp

 //===- bolt/Core/BinaryFunction.cpp - Low-level function ------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
for (uint64_t Offset = 0; Offset < getSize(); Offset += Size) {
     // Emit the instruction using temp emitter and generate relocations.
     SmallString<256> Code;
     SmallVector<MCFixup, 4> Fixups;
     raw_svector_ostream VecOS(Code);
     Emitter.MCE->encodeInstruction(Instruction, VecOS, Fixups, *BC.STI);
 
     // Create relocation for every fixup.
     for (const MCFixup &Fixup : Fixups) {
-      Optional<Relocation> Rel = BC.MIB->createRelocation(Fixup, *BC.MAB);
+      std::optional<Relocation> Rel = BC.MIB->createRelocation(Fixup, *BC.MAB);
       if (!Rel) {
         Success = false;
         continue;
       }
 
       if (Relocation::getSizeForType(Rel->Type) < 4) {
         // If the instruction uses a short form, then we might not be able
         // to handle the rewrite without relaxation, and hence cannot reliably
void BinaryFunction::recomputeLandingPads() {
   }
 
   for (BinaryBasicBlock *BB : BasicBlocks) {
     std::unordered_set<const BinaryBasicBlock *> BBLandingPads;
     for (MCInst &Instr : *BB) {
       if (!BC.MIB->isInvoke(Instr))
         continue;
 
-      const Optional<MCPlus::MCLandingPad> EHInfo = BC.MIB->getEHInfo(Instr);
+      const std::optional<MCPlus::MCLandingPad> EHInfo =
+          BC.MIB->getEHInfo(Instr);
       if (!EHInfo || !EHInfo->first)
         continue;
 
       BinaryBasicBlock *LPBlock = getBasicBlockForLabel(EHInfo->first);
       if (!BBLandingPads.count(LPBlock)) {
         BBLandingPads.insert(LPBlock);
         BB->LandingPads.emplace_back(LPBlock);
         LPBlock->Throwers.emplace_back(BB);
void BinaryFunction::removeConditionalTailCalls() {
   std::vector<std::unique_ptr<BinaryBasicBlock>> NewBlocks;
 
   for (auto BBI = begin(); BBI != end(); ++BBI) {
     BinaryBasicBlock &BB = *BBI;
     MCInst *CTCInstr = BB.getLastNonPseudoInstr();
     if (!CTCInstr)
       continue;
 
-    Optional<uint64_t> TargetAddressOrNone =
+    std::optional<uint64_t> TargetAddressOrNone =
         BC.MIB->getConditionalTailCall(*CTCInstr);
     if (!TargetAddressOrNone)
       continue;
 
     // Gather all necessary information about CTC instruction before
     // annotations are destroyed.
     const int32_t CFIStateBeforeCTC = BB.getCFIStateAtInstr(CTCInstr);
     uint64_t CTCTakenCount = BinaryBasicBlock::COUNT_NO_PROFILE;

bolt/lib/Core/Exceptions.cpp

 //===- bolt/Core/Exceptions.cpp - Helpers for C++ exceptions --------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
for (BinaryBasicBlock *const BB : FF) {
 
         // Ignore the call if it's a continuation of a no-throw gap.
         if (!Throws && !StartRange)
           continue;
 
         // Extract exception handling information from the instruction.
         const MCSymbol *LP = nullptr;
         uint64_t Action = 0;
-        if (const Optional<MCPlus::MCLandingPad> EHInfo =
+        if (const std::optional<MCPlus::MCLandingPad> EHInfo =
                 BC.MIB->getEHInfo(*II))
           std::tie(LP, Action) = *EHInfo;
 
         // No action if the exception handler has not changed.
         if (Throws && StartRange && PreviousEH.LP == LP &&
             PreviousEH.Action == Action)
           continue;
 

bolt/lib/Core/MCPlusBuilder.cpp

 //===- bolt/Core/MCPlusBuilder.cpp - Interface for MCPlus -----------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //

 bool MCPlusBuilder::isTailCall(const MCInst &Inst) const {
   if (hasAnnotation(Inst, MCAnnotation::kTailCall))
     return true;
   if (getConditionalTailCall(Inst))
     return true;
   return false;
 }
 
-Optional<MCLandingPad> MCPlusBuilder::getEHInfo(const MCInst &Inst) const {
+std::optional<MCLandingPad> MCPlusBuilder::getEHInfo(const MCInst &Inst) const {
   if (!isCall(Inst))
     return std::nullopt;
-  Optional<int64_t> LPSym =
+  std::optional<int64_t> LPSym =
       getAnnotationOpValue(Inst, MCAnnotation::kEHLandingPad);
   if (!LPSym)
     return std::nullopt;
-  Optional<int64_t> Action =
+  std::optional<int64_t> Action =
       getAnnotationOpValue(Inst, MCAnnotation::kEHAction);
   if (!Action)
     return std::nullopt;
 
   return std::make_pair(reinterpret_cast<const MCSymbol *>(*LPSym),
                         static_cast<uint64_t>(*Action));
 }
 
bool MCPlusBuilder::updateEHInfo(MCInst &Inst, const MCLandingPad &LP) {
   setAnnotationOpValue(Inst, MCAnnotation::kEHLandingPad,
                        reinterpret_cast<int64_t>(LP.first));
   setAnnotationOpValue(Inst, MCAnnotation::kEHAction,
                        static_cast<int64_t>(LP.second));
   return true;
 }
 
 int64_t MCPlusBuilder::getGnuArgsSize(const MCInst &Inst) const {
-  Optional<int64_t> Value =
+  std::optional<int64_t> Value =
       getAnnotationOpValue(Inst, MCAnnotation::kGnuArgsSize);
   if (!Value)
     return -1LL;
   return *Value;
 }
 
 void MCPlusBuilder::addGnuArgsSize(MCInst &Inst, int64_t GnuArgsSize,
                                    AllocatorIdTy AllocId) {
   assert(GnuArgsSize >= 0 && "cannot set GNU_args_size to negative value");
   assert(getGnuArgsSize(Inst) == -1LL && "GNU_args_size already set");
   assert(isInvoke(Inst) && "GNU_args_size can only be set for invoke");
 
   setAnnotationOpValue(Inst, MCAnnotation::kGnuArgsSize, GnuArgsSize, AllocId);
 }
 
 uint64_t MCPlusBuilder::getJumpTable(const MCInst &Inst) const {
-  Optional<int64_t> Value =
+  std::optional<int64_t> Value =
       getAnnotationOpValue(Inst, MCAnnotation::kJumpTable);
   if (!Value)
     return 0;
   return *Value;
 }
 
 uint16_t MCPlusBuilder::getJumpTableIndexReg(const MCInst &Inst) const {
   return getAnnotationAs<uint16_t>(Inst, "JTIndexReg");

 bool MCPlusBuilder::unsetJumpTable(MCInst &Inst) {
   if (!getJumpTable(Inst))
     return false;
   removeAnnotation(Inst, MCAnnotation::kJumpTable);
   removeAnnotation(Inst, "JTIndexReg");
   return true;
 }
 
-Optional<uint64_t>
+std::optional<uint64_t>
 MCPlusBuilder::getConditionalTailCall(const MCInst &Inst) const {
-  Optional<int64_t> Value =
+  std::optional<int64_t> Value =
       getAnnotationOpValue(Inst, MCAnnotation::kConditionalTailCall);
   if (!Value)
     return std::nullopt;
   return static_cast<uint64_t>(*Value);
 }
 
 bool MCPlusBuilder::setConditionalTailCall(MCInst &Inst, uint64_t Dest) {
   if (!isConditionalBranch(Inst))
     return false;
 
   setAnnotationOpValue(Inst, MCAnnotation::kConditionalTailCall, Dest);
   return true;
 }
 
 bool MCPlusBuilder::unsetConditionalTailCall(MCInst &Inst) {
   if (!getConditionalTailCall(Inst))
     return false;
   removeAnnotation(Inst, MCAnnotation::kConditionalTailCall);
   return true;
 }
 
-Optional<uint32_t> MCPlusBuilder::getOffset(const MCInst &Inst) const {
-  Optional<int64_t> Value = getAnnotationOpValue(Inst, MCAnnotation::kOffset);
+std::optional<uint32_t> MCPlusBuilder::getOffset(const MCInst &Inst) const {
+  std::optional<int64_t> Value =
+      getAnnotationOpValue(Inst, MCAnnotation::kOffset);
   if (!Value)
     return std::nullopt;
   return static_cast<uint32_t>(*Value);
 }
 
 uint32_t MCPlusBuilder::getOffsetWithDefault(const MCInst &Inst,
                                              uint32_t Default) const {
-  if (Optional<uint32_t> Offset = getOffset(Inst))
+  if (std::optional<uint32_t> Offset = getOffset(Inst))
     return *Offset;
   return Default;
 }
 
 bool MCPlusBuilder::setOffset(MCInst &Inst, uint32_t Offset,
                               AllocatorIdTy AllocatorId) {
   setAnnotationOpValue(Inst, MCAnnotation::kOffset, Offset, AllocatorId);
   return true;

bolt/lib/Passes/DataflowAnalysis.cpp

 //===- bolt/Passes/DataflowAnalysis.cpp -----------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
if (Pred->isValid())
       Task(ProgramPoint::getLastPointAt(*Pred));
   }
   if (!BB.isLandingPad())
     return;
   for (BinaryBasicBlock *Thrower : BB.throwers()) {
     for (MCInst &Inst : *Thrower) {
       if (!MIB->isInvoke(Inst))
         continue;
-      const Optional<MCPlus::MCLandingPad> EHInfo = MIB->getEHInfo(Inst);
+      const std::optional<MCPlus::MCLandingPad> EHInfo = MIB->getEHInfo(Inst);
       if (!EHInfo || EHInfo->first != BB.getLabel())
         continue;
       Task(ProgramPoint(&Inst));
     }
   }
 }
 
 /// Operates on all successors of a basic block.

bolt/lib/Passes/IdenticalCodeFolding.cpp

 //===- bolt/Passes/IdenticalCodeFolding.cpp -------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
bool isInstrEquivalentWith(const MCInst &InstA, const BinaryBasicBlock &BBA,
   //    * instructions with landing pads
   //
   // Most of the common cases should be handled by MCPlus::equals()
   // that compares regular instruction operands.
   //
   // NB: there's no need to compare jump table indirect jump instructions
   //     separately as jump tables are handled by comparing corresponding
   //     symbols.
-  const Optional<MCPlus::MCLandingPad> EHInfoA = BC.MIB->getEHInfo(InstA);
-  const Optional<MCPlus::MCLandingPad> EHInfoB = BC.MIB->getEHInfo(InstB);
+  const std::optional<MCPlus::MCLandingPad> EHInfoA = BC.MIB->getEHInfo(InstA);
+  const std::optional<MCPlus::MCLandingPad> EHInfoB = BC.MIB->getEHInfo(InstB);
 
   if (EHInfoA || EHInfoB) {
     if (!EHInfoA && (EHInfoB->first || EHInfoB->second))
       return false;
 
     if (!EHInfoB && (EHInfoA->first || EHInfoA->second))
       return false;
 

bolt/lib/Passes/Inliner.cpp

 //===- bolt/Passes/Inliner.cpp - Inlining pass for low-level binary IR ----===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
assert(!Callee.isMultiEntry() &&
          "cannot inline function with multiple entries");
   assert(!Callee.hasJumpTables() &&
          "cannot inline function with jump table(s)");
 
   // Get information about the call site.
   const bool CSIsInvoke = BC.MIB->isInvoke(*CallInst);
   const bool CSIsTailCall = BC.MIB->isTailCall(*CallInst);
   const int64_t CSGNUArgsSize = BC.MIB->getGnuArgsSize(*CallInst);
-  const Optional<MCPlus::MCLandingPad> CSEHInfo = BC.MIB->getEHInfo(*CallInst);
+  const std::optional<MCPlus::MCLandingPad> CSEHInfo =
+      BC.MIB->getEHInfo(*CallInst);
 
   // Split basic block at the call site if there will be more incoming edges
   // coming from the callee.
   BinaryBasicBlock *FirstInlinedBB = &CallerBB;
   if (Callee.front().pred_size() && CallInst != CallerBB.begin()) {
     FirstInlinedBB = CallerBB.splitAt(CallInst);
     CallInst = FirstInlinedBB->begin();
   }

bolt/lib/Passes/SplitFunctions.cpp

 //===- bolt/Passes/SplitFunctions.cpp - Pass for splitting function code --===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
SplitFunctions::createEHTrampolines(BinaryFunction &BF) const {
   // Map real landing pads to the corresponding trampolines.
   TrampolineSetType LPTrampolines;
 
   // Iterate over the copy of basic blocks since we are adding new blocks to the
   // function which will invalidate its iterators.
   std::vector<BinaryBasicBlock *> Blocks(BF.pbegin(), BF.pend());
   for (BinaryBasicBlock *BB : Blocks) {
     for (MCInst &Instr : *BB) {
-      const Optional<MCPlus::MCLandingPad> EHInfo = MIB->getEHInfo(Instr);
+      const std::optional<MCPlus::MCLandingPad> EHInfo = MIB->getEHInfo(Instr);
       if (!EHInfo || !EHInfo->first)
         continue;
 
       const MCSymbol *LPLabel = EHInfo->first;
       BinaryBasicBlock *LPBlock = BF.getBasicBlockForLabel(LPLabel);
       if (BB->getFragmentNum() == LPBlock->getFragmentNum())
         continue;
 

bolt/lib/Profile/YAMLProfileWriter.cpp

 //===- bolt/Profile/YAMLProfileWriter.cpp - YAML profile serializer -------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
for (const BinaryBasicBlock *BB : BF.dfs()) {
 
     YamlBB.ExecCount = BB->getKnownExecutionCount();
 
     for (const MCInst &Instr : *BB) {
       if (!BC.MIB->isCall(Instr) && !BC.MIB->isIndirectBranch(Instr))
         continue;
 
       yaml::bolt::CallSiteInfo CSI;
-      Optional<uint32_t> Offset = BC.MIB->getOffset(Instr);
+      std::optional<uint32_t> Offset = BC.MIB->getOffset(Instr);
       if (!Offset || *Offset < BB->getInputOffset())
         continue;
       CSI.Offset = *Offset - BB->getInputOffset();
 
       if (BC.MIB->isIndirectCall(Instr) || BC.MIB->isIndirectBranch(Instr)) {
         const auto ICSP = BC.MIB->tryGetAnnotationAs<IndirectCallSiteProfile>(
             Instr, "CallProfile");
         if (!ICSP)

bolt/lib/Target/X86/X86MCPlusBuilder.cpp

 //===- bolt/Target/X86/X86MCPlusBuilder.cpp -------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
Code.emplace_back(MCInstBuilder(X86::CMP64ri8)
                           .addImm(Imm));
     Code.emplace_back(MCInstBuilder(X86::JCC_1)
                           .addExpr(MCSymbolRefExpr::create(
                               Target, MCSymbolRefExpr::VK_None, *Ctx))
                           .addImm(X86::COND_E));
     return Code;
   }
 
-  Optional<Relocation>
+  std::optional<Relocation>
   createRelocation(const MCFixup &Fixup,
                    const MCAsmBackend &MAB) const override {
     const MCFixupKindInfo &FKI = MAB.getFixupKindInfo(Fixup.getKind());
 
     assert(FKI.TargetOffset == 0 && "0-bit relocation offset expected");
     const uint64_t RelOffset = Fixup.getOffset();
 
     uint64_t RelType;
for (unsigned int i = 0; i < Targets.size(); ++i) {
           else
             CallOrJmp.addOperand(MCOperand::createImm(Targets[i].second));
         }
         if (IsTailCall)
           setTailCall(CallOrJmp);
 
         if (CallOrJmp.getOpcode() == X86::CALL64r ||
             CallOrJmp.getOpcode() == X86::CALL64pcrel32) {
-          if (Optional<uint32_t> Offset = getOffset(CallInst))
+          if (std::optional<uint32_t> Offset = getOffset(CallInst))
             // Annotated as duplicated call
             setOffset(CallOrJmp, *Offset);
         }
 
         if (isInvoke(CallInst) && !isInvoke(CallOrJmp)) {
           // Copy over any EH or GNU args size information from the original
           // call.
-          Optional<MCPlus::MCLandingPad> EHInfo = getEHInfo(CallInst);
+          std::optional<MCPlus::MCLandingPad> EHInfo = getEHInfo(CallInst);
           if (EHInfo)
             addEHInfo(CallOrJmp, *EHInfo);
           int64_t GnuArgsSize = getGnuArgsSize(CallInst);
           if (GnuArgsSize >= 0)
             addGnuArgsSize(CallOrJmp, GnuArgsSize);
         }
 
         if (!IsTailCall) {

bolt/unittests/Core/MCPlusBuilder.cpp

 #ifdef AARCH64_AVAILABLE
 #include "AArch64Subtarget.h"
 #endif // AARCH64_AVAILABLE
 
 #ifdef X86_AVAILABLE
 #include "X86Subtarget.h"
 #endif // X86_AVAILABLE
 
TEST_P(MCPlusBuilderTester, Annotation) {
   bool Success = BC->MIB->createTailCall(Inst, BC->Ctx->createNamedTempSymbol(),
                                          BC->Ctx.get());
   ASSERT_TRUE(Success);
   MCSymbol *LPSymbol = BC->Ctx->createNamedTempSymbol("LP");
   uint64_t Value = INT32_MIN;
   // Test encodeAnnotationImm using this indirect way
   BC->MIB->addEHInfo(Inst, MCPlus::MCLandingPad(LPSymbol, Value));
   // Round-trip encoding-decoding check for negative values
-  Optional<MCPlus::MCLandingPad> EHInfo = BC->MIB->getEHInfo(Inst);
+  std::optional<MCPlus::MCLandingPad> EHInfo = BC->MIB->getEHInfo(Inst);
   ASSERT_TRUE(EHInfo.has_value());
   MCPlus::MCLandingPad LP = EHInfo.value();
   uint64_t DecodedValue = LP.second;
   ASSERT_EQ(Value, DecodedValue);
 
   // Large int64 should trigger an out of range assertion
   Value = 0x1FF'FFFF'FFFF'FFFFULL;
   Inst.clear();
   Success = BC->MIB->createTailCall(Inst, BC->Ctx->createNamedTempSymbol(),
                                     BC->Ctx.get());
   ASSERT_TRUE(Success);
   ASSERT_DEATH(BC->MIB->addEHInfo(Inst, MCPlus::MCLandingPad(LPSymbol, Value)),
                "annotation value out of range");
 }