[BOLT][NFC] Use std::optional for findAttributeInfo

[Amir]

Summary

LLVM started switching from llvm::Optional to std::optional:
https://discourse.llvm.org/t/deprecating-llvm-optional-x-hasvalue-getvalue-getvalueor/63716/11

[maksfb]

Is LLVM switching from ADT's Optional<> to std::optional<>? Could you include a link to any relevant discussion?

[Amir]

In D139259#3973362, @maksfb wrote:

Is LLVM switching from ADT's Optional<> to std::optional<>? Could you include a link to any relevant discussion?

Yes, added a link to discourse thread. It looks like the migration is in full swing, with many commits over the past 2 weeks
(that overwhelm our buildbots)

[maksfb]

LGTM

bolt/include/bolt/Core/DebugData.h

struct AttrInfo {
   uint32_t Size; // Size of the attribute.
 };
 
 /// Finds attributes FormValue and Offset.
 ///
 /// \param DIE die to look up in.
 /// \param AbbrevDecl abbrev declaration for the die.
 /// \param Index an index in Abbrev declaration entry.
-Optional<AttrInfo>
+std::optional<AttrInfo>
 findAttributeInfo(const DWARFDie DIE,
                   const DWARFAbbreviationDeclaration *AbbrevDecl,
                   uint32_t Index);
 
 /// Finds attributes FormValue and Offset.
 ///
 /// \param DIE die to look up in.
 /// \param Attr the attribute to extract.
 /// \return an optional AttrInfo with DWARFFormValue and Offset.
-Optional<AttrInfo> findAttributeInfo(const DWARFDie DIE, dwarf::Attribute Attr);
+std::optional<AttrInfo> findAttributeInfo(const DWARFDie DIE,
+                                          dwarf::Attribute Attr);
 
 // DWARF5 Header in order of encoding.
 // Types represent encodnig sizes.
 using UnitLengthType = uint32_t;
 using VersionType = uint16_t;
 using AddressSizeType = uint8_t;
 using SegmentSelectorType = uint8_t;
 using OffsetEntryCountType = uint32_t;

bolt/lib/Core/DebugData.cpp

 extern llvm::cl::opt<unsigned> Verbosity;
 } // namespace opts
 
 namespace llvm {
 class MCSymbol;
 
 namespace bolt {
 
-Optional<AttrInfo>
+std::optional<AttrInfo>
 findAttributeInfo(const DWARFDie DIE,
                   const DWARFAbbreviationDeclaration *AbbrevDecl,
                   uint32_t Index) {
   const DWARFUnit &U = *DIE.getDwarfUnit();
   uint64_t Offset =
       AbbrevDecl->getAttributeOffsetFromIndex(Index, DIE.getOffset(), U);
   std::optional<DWARFFormValue> Value =
       AbbrevDecl->getAttributeValueFromOffset(Index, Offset, U);
if (ValSizeOpt) {
     // This includes entire size of the entry, which might not be just the
     // encoding part. For example for DW_AT_loc it will include expression
     // location.
     ValSize = NewOffset - Offset;
   }
   return AttrInfo{*Value, DIE.getAbbreviationDeclarationPtr(), Offset, ValSize};
 }
 
-Optional<AttrInfo> findAttributeInfo(const DWARFDie DIE,
+std::optional<AttrInfo> findAttributeInfo(const DWARFDie DIE,
                                           dwarf::Attribute Attr) {
   if (!DIE.isValid())
     return std::nullopt;
   const DWARFAbbreviationDeclaration *AbbrevDecl =
       DIE.getAbbreviationDeclarationPtr();
   if (!AbbrevDecl)
     return std::nullopt;
   std::optional<uint32_t> Index = AbbrevDecl->findAttributeIndex(Attr);
   if (!Index)
void DebugLoclistWriter::finalizeDWARF5(
   std::unique_ptr<DebugBufferVector> Header = getDWARF5Header(
       {static_cast<uint32_t>(SizeOfArraySection + LocBodyBuffer.get()->size()),
        5, 8, 0, NumberOfEntries});
   *LocStream << *Header;
   *LocStream << *LocArrayBuffer;
   *LocStream << *LocBodyBuffer;
 
   if (!isSplitDwarf()) {
-    if (Optional<AttrInfo> AttrInfoVal =
+    if (std::optional<AttrInfo> AttrInfoVal =
             findAttributeInfo(CU.getUnitDIE(), dwarf::DW_AT_loclists_base))
       DebugInfoPatcher.addLE32Patch(AttrInfoVal->Offset,
                                     LoclistBaseOffset +
                                         getDWARF5RngListLocListHeaderSize());
     else {
       AbbrevWriter.addAttribute(
           CU, CU.getUnitDIE().getAbbreviationDeclarationPtr(),
           dwarf::DW_AT_loclists_base, dwarf::DW_FORM_sec_offset);
void DebugInfoBinaryPatcher::insertNewEntry(const DWARFDie &DIE,
                                             std::string &&Value) {
   const DWARFAbbreviationDeclaration *AbbrevDecl =
       DIE.getAbbreviationDeclarationPtr();
 
   // In case this DIE has no attributes.
   uint32_t Offset = DIE.getOffset() + 1;
   size_t NumOfAttributes = AbbrevDecl->getNumAttributes();
   if (NumOfAttributes) {
-    Optional<AttrInfo> Val =
+    std::optional<AttrInfo> Val =
         findAttributeInfo(DIE, AbbrevDecl, NumOfAttributes - 1);
     assert(Val && "Invalid Value.");
 
     Offset = Val->Offset + Val->Size - DWPUnitOffset;
   }
   std::lock_guard<std::mutex> Lock(WriterMutex);
   DebugPatches.emplace_back(new NewDebugEntry(Offset, std::move(Value)));
 }

bolt/lib/Rewrite/DWARFRewriter.cpp

 
 namespace llvm {
 namespace bolt {
 /// Finds attributes FormValue and Offset.
 ///
 /// \param DIE die to look up in.
 /// \param Attrs finds the first attribute that matches and extracts it.
 /// \return an optional AttrInfo with DWARFFormValue and Offset.
-Optional<AttrInfo> findAttributeInfo(const DWARFDie DIE,
+std::optional<AttrInfo> findAttributeInfo(const DWARFDie DIE,
                                           std::vector<dwarf::Attribute> Attrs) {
   for (dwarf::Attribute &Attr : Attrs)
-    if (Optional<AttrInfo> Info = findAttributeInfo(DIE, Attr))
+    if (std::optional<AttrInfo> Info = findAttributeInfo(DIE, Attr))
       return Info;
   return std::nullopt;
 }
 } // namespace bolt
 } // namespace llvm
 
 using namespace llvm;
 using namespace llvm::support::endian;
void DWARFRewriter::updateDebugInfo() {
   // Unordered maps to handle name collision if output DWO directory is
   // specified.
   std::unordered_map<std::string, uint32_t> NameToIndexMap;
   std::unordered_map<uint64_t, std::string> DWOIdToName;
   std::mutex AccessMutex;
 
   auto updateDWONameCompDir = [&](DWARFUnit &Unit) -> void {
     const DWARFDie &DIE = Unit.getUnitDIE();
-    Optional<AttrInfo> AttrInfoVal = findAttributeInfo(
+    std::optional<AttrInfo> AttrInfoVal = findAttributeInfo(
         DIE, {dwarf::DW_AT_dwo_name, dwarf::DW_AT_GNU_dwo_name});
     (void)AttrInfoVal;
     assert(AttrInfoVal && "Skeleton CU doesn't have dwo_name.");
 
     std::string ObjectName;
 
     {
       std::lock_guard<std::mutex> Lock(AccessMutex);
case dwarf::DW_TAG_call_site: {
           DebugInfoPatcher.addUDataPatch(AttrVal.Offset, Index, AttrVal.Size);
         } else if (AttrVal.V.getForm() == dwarf::DW_FORM_addr) {
           DebugInfoPatcher.addLE32Patch(AttrVal.Offset, UpdatedAddress);
         } else {
           errs() << "BOLT-ERROR: unsupported form for " << Entry << "\n";
         }
       };
 
-      if (Optional<AttrInfo> AttrVal =
+      if (std::optional<AttrInfo> AttrVal =
               findAttributeInfo(DIE, dwarf::DW_AT_call_pc))
         patchPC(*AttrVal, "DW_AT_call_pc");
 
-      if (Optional<AttrInfo> AttrVal =
+      if (std::optional<AttrInfo> AttrVal =
               findAttributeInfo(DIE, dwarf::DW_AT_call_return_pc))
         patchPC(*AttrVal, "DW_AT_call_return_pc");
 
       break;
     }
     default: {
       // Handle any tag that can have DW_AT_location attribute.
       DWARFFormValue Value;
       uint64_t AttrOffset;
-      if (Optional<AttrInfo> AttrVal =
+      if (std::optional<AttrInfo> AttrVal =
               findAttributeInfo(DIE, dwarf::DW_AT_location)) {
         AttrOffset = AttrVal->Offset;
         Value = AttrVal->V;
         if (Value.isFormClass(DWARFFormValue::FC_Constant) ||
             Value.isFormClass(DWARFFormValue::FC_SectionOffset)) {
           uint64_t Offset = Value.isFormClass(DWARFFormValue::FC_Constant)
                                 ? Value.getAsUnsignedConstant().value()
                                 : Value.getAsSectionOffset().value();
default: {
               }
             }
             // Update the size of the experssion.
             if (SizeDiff)
               DebugInfoPatcher.addUDataPatch(AttrOffset,
                                              SizeDiff + CurrEndOffset, 1);
           }
         }
-      } else if (Optional<AttrInfo> AttrVal =
+      } else if (std::optional<AttrInfo> AttrVal =
                      findAttributeInfo(DIE, dwarf::DW_AT_low_pc)) {
         AttrOffset = AttrVal->Offset;
         Value = AttrVal->V;
         const std::optional<uint64_t> Result = Value.getAsAddress();
         if (Result) {
           const uint64_t Address = *Result;
           uint64_t NewAddress = 0;
           if (const BinaryFunction *Function =
default: {
             DebugInfoPatcher.addLE64Patch(AttrOffset, NewAddress);
           }
         } else if (opts::Verbosity >= 1) {
           errs() << "BOLT-WARNING: unexpected form value for attribute at 0x"
                  << Twine::utohexstr(AttrOffset);
         }
       } else if (IsDWP && Unit.isDWOUnit()) {
         // Not a common path so don't want to search all DIEs all the time.
-        Optional<AttrInfo> SignatureAttrVal =
+        std::optional<AttrInfo> SignatureAttrVal =
             findAttributeInfo(DIE, dwarf::DW_AT_signature);
         if (!SignatureAttrVal)
           continue;
         // If input is DWP file we need to keep track of which TU came from each
         // CU, so we can write it out correctly.
         if (std::optional<uint64_t> Val =
                 SignatureAttrVal->V.getAsReferenceUVal())
           TypeSignaturesPerCU[*DIE.getDwarfUnit()->getDWOId()].insert(*Val);
for (const DWARFAbbreviationDeclaration::AttributeSpec &Decl :
       default:
         break;
       case dwarf::DW_FORM_ref1:
       case dwarf::DW_FORM_ref2:
       case dwarf::DW_FORM_ref4:
       case dwarf::DW_FORM_ref8:
       case dwarf::DW_FORM_ref_udata:
       case dwarf::DW_FORM_ref_addr: {
-        Optional<AttrInfo> AttrVal = findAttributeInfo(DIE, AbbrevDecl, Index);
+        std::optional<AttrInfo> AttrVal =
+            findAttributeInfo(DIE, AbbrevDecl, Index);
         uint32_t DestinationAddress =
             AttrVal->V.getRawUValue() +
             (Decl.Form == dwarf::DW_FORM_ref_addr ? 0 : Unit.getOffset());
         DebugInfoPatcher.addReferenceToPatch(
             AttrVal->Offset, DestinationAddress, AttrVal->Size, Decl.Form);
         // We can have only one reference, and it can be backward one.
         DebugInfoPatcher.addDestinationReferenceLabel(DestinationAddress);
         break;
if (opts::Verbosity >= 1)
              << "skipping update. DIE at offset 0x"
              << Twine::utohexstr(DIE.getOffset()) << '\n';
     return;
   }
 
   if (RangesBase) {
     // If DW_AT_GNU_ranges_base is present, update it. No further modifications
     // are needed for ranges base.
-    Optional<AttrInfo> RangesBaseAttrInfo =
+    std::optional<AttrInfo> RangesBaseAttrInfo =
         findAttributeInfo(DIE, dwarf::DW_AT_GNU_ranges_base);
     if (!RangesBaseAttrInfo)
       RangesBaseAttrInfo = findAttributeInfo(DIE, dwarf::DW_AT_rnglists_base);
 
     if (RangesBaseAttrInfo) {
       DebugInfoPatcher.addLE32Patch(RangesBaseAttrInfo->Offset,
                                     static_cast<uint32_t>(*RangesBase),
                                     RangesBaseAttrInfo->Size);
       RangesBase = std::nullopt;
     }
   }
 
-  Optional<AttrInfo> LowPCAttrInfo =
+  std::optional<AttrInfo> LowPCAttrInfo =
       findAttributeInfo(DIE, dwarf::DW_AT_low_pc);
-  if (Optional<AttrInfo> AttrVal =
+  if (std::optional<AttrInfo> AttrVal =
           findAttributeInfo(DIE, dwarf::DW_AT_ranges)) {
     // Case 1: The object was already non-contiguous and had DW_AT_ranges.
     // In this case we simply need to update the value of DW_AT_ranges
     // and introduce DW_AT_GNU_ranges_base if required.
     std::lock_guard<std::mutex> Lock(DebugInfoPatcherMutex);
     // For DWARF5 converting all of DW_AT_ranges into DW_FORM_rnglistx
     bool Converted = false;
     if (DIE.getDwarfUnit()->getVersion() >= 5 &&
if (std::optional<AttrInfo> AttrVal =
     reinterpret_cast<DebugInfoBinaryPatcher &>(DebugInfoPatcher)
         .insertNewEntry(DIE, *RangesBase);
 
     return;
   }
 
   // Case 2: The object has both DW_AT_low_pc and DW_AT_high_pc emitted back
   // to back. Replace with new attributes and patch the DIE.
-  Optional<AttrInfo> HighPCAttrInfo =
+  std::optional<AttrInfo> HighPCAttrInfo =
       findAttributeInfo(DIE, dwarf::DW_AT_high_pc);
   if (LowPCAttrInfo && HighPCAttrInfo) {
     convertToRangesPatchAbbrev(*DIE.getDwarfUnit(), AbbreviationDecl,
                                AbbrevWriter, RangesBase);
     convertToRangesPatchDebugInfo(DIE, DebugRangesOffset, DebugInfoPatcher,
                                   LowPCToUse, RangesBase);
   } else {
     if (opts::Verbosity >= 1)
const uint64_t Reloc32Type = BC.isAArch64()
                                    : static_cast<uint64_t>(ELF::R_X86_64_32);
 
   for (const std::unique_ptr<DWARFUnit> &CU : BC.DwCtx->compile_units()) {
     const unsigned CUID = CU->getOffset();
     MCSymbol *Label = BC.getDwarfLineTable(CUID).getLabel();
     if (!Label)
       continue;
 
-    Optional<AttrInfo> AttrVal =
+    std::optional<AttrInfo> AttrVal =
         findAttributeInfo(CU.get()->getUnitDIE(), dwarf::DW_AT_stmt_list);
     if (!AttrVal)
       continue;
 
     const uint64_t AttributeOffset = AttrVal->Offset;
     const uint64_t LineTableOffset = Layout.getSymbolOffset(*Label);
     DebugLineOffsetMap[GetStatementListValue(CU.get())] = LineTableOffset;
     assert(DbgInfoSection && ".debug_info section must exist");
     DebugInfoPatcher->addLE32Patch(AttributeOffset, LineTableOffset);
   }
 
   for (const std::unique_ptr<DWARFUnit> &TU : BC.DwCtx->types_section_units()) {
     DWARFUnit *Unit = TU.get();
-    Optional<AttrInfo> AttrVal =
+    std::optional<AttrInfo> AttrVal =
         findAttributeInfo(TU.get()->getUnitDIE(), dwarf::DW_AT_stmt_list);
     if (!AttrVal)
       continue;
     const uint64_t AttributeOffset = AttrVal->Offset;
     auto Iter = DebugLineOffsetMap.find(GetStatementListValue(Unit));
     assert(Iter != DebugLineOffsetMap.end() &&
            "Type Unit Updated Line Number Entry does not exist.");
     TypeInfoSection->addRelocation(AttributeOffset, nullptr, Reloc32Type,
if (AddrWriter->isInitialized()) {
     BC.registerOrUpdateNoteSection(".debug_addr",
                                    copyByteArray(AddressSectionContents),
                                    AddressSectionContents.size());
     for (auto &CU : BC.DwCtx->compile_units()) {
       DWARFDie DIE = CU->getUnitDIE();
       uint64_t Offset = 0;
       uint64_t AttrOffset = 0;
       uint32_t Size = 0;
-      Optional<AttrInfo> AttrValGnu =
+      std::optional<AttrInfo> AttrValGnu =
           findAttributeInfo(DIE, dwarf::DW_AT_GNU_addr_base);
-      Optional<AttrInfo> AttrVal =
+      std::optional<AttrInfo> AttrVal =
           findAttributeInfo(DIE, dwarf::DW_AT_addr_base);
 
       // For cases where Skeleton CU does not have DW_AT_GNU_addr_base
       if (!AttrValGnu && CU->getVersion() < 5)
         continue;
 
       if (!AttrVal && CU->getVersion() >= 5 && !AddrWriter->doesCUExist(*CU))
         continue;
for (std::pair<const uint64_t, std::unique_ptr<DebugLocWriter>> &Loc :
     *LocStream << *CurrCULocationLists;
   }
 
   return LocBuffer;
 }
 
 namespace {
 
-void getRangeAttrData(DWARFDie DIE, Optional<AttrInfo> &LowPCVal,
-                      Optional<AttrInfo> &HighPCVal) {
+void getRangeAttrData(DWARFDie DIE, std::optional<AttrInfo> &LowPCVal,
+                      std::optional<AttrInfo> &HighPCVal) {
   LowPCVal = findAttributeInfo(DIE, dwarf::DW_AT_low_pc);
   HighPCVal = findAttributeInfo(DIE, dwarf::DW_AT_high_pc);
   uint64_t LowPCOffset = LowPCVal->Offset;
   uint64_t HighPCOffset = HighPCVal->Offset;
   dwarf::Form LowPCForm = LowPCVal->V.getForm();
   dwarf::Form HighPCForm = HighPCVal->V.getForm();
 
   if (LowPCForm != dwarf::DW_FORM_addr &&
void DWARFRewriter::convertToRangesPatchAbbrev(
   AbbrevWriter.addAttributePatch(Unit, Abbrev, dwarf::DW_AT_high_pc,
                                  dwarf::DW_AT_ranges, RangesForm);
 }
 
 void DWARFRewriter::convertToRangesPatchDebugInfo(
     DWARFDie DIE, uint64_t RangesSectionOffset,
     SimpleBinaryPatcher &DebugInfoPatcher, uint64_t LowPCToUse,
     Optional<uint64_t> RangesBase) {
-  Optional<AttrInfo> LowPCVal;
-  Optional<AttrInfo> HighPCVal;
+  std::optional<AttrInfo> LowPCVal;
+  std::optional<AttrInfo> HighPCVal;
   getRangeAttrData(DIE, LowPCVal, HighPCVal);
   uint64_t LowPCOffset = LowPCVal->Offset;
   uint64_t HighPCOffset = HighPCVal->Offset;
 
   std::lock_guard<std::mutex> Lock(DebugInfoPatcherMutex);
   uint32_t BaseOffset = 0;
   dwarf::Form LowForm = LowPCVal->V.getForm();