[LLDB] Change OSO to use DieRef

[ayermolo]

Summary

Following example of DWO changing it to use DIERef.

Depends on D138618

[ayermolo]

Updated based on Gregs suggestion.

[labath]

lldb/source/Plugins/SymbolFile/DWARF/DIERef.h

32

Where is this constructor being used?

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

10

unused include?

[ayermolo]

lldb/source/Plugins/SymbolFile/DWARF/DIERef.h

32

In SymbolFileDWARF.cpp
SymbolFileDWARF::GetUID
SymbolFileDWARF::DecodeUID

[labath]

lldb/source/Plugins/SymbolFile/DWARF/DIERef.h

32

I'm sorry, I must have clicked the wrong line. My question was about the constructor below this (line 40).

[ayermolo]

lldb/source/Plugins/SymbolFile/DWARF/DIERef.h

32

Ah yes, sorry. Removed.

[ayermolo]

addressed comments

lldb/source/Plugins/SymbolFile/DWARF/DIERef.h

 ///   the DIERef references the main file.
 /// - section: identifies the section of the debug info entry in the given file:
 ///   debug_info or debug_types.
 /// - die_offset: The offset of the debug info entry as an absolute offset from
 ///   the beginning of the section specified in the section field.
 class DIERef {
 public:
   enum Section : uint8_t { DebugInfo, DebugTypes };
+  enum IndexType : uint8_t { DWONum, OSONum };
 
-  DIERef(std::optional<uint32_t> dwo_num, Section section,
+  DIERef(std::optional<uint32_t> dwo_oso_num, Section section,
          dw_offset_t die_offset)
-      : m_die_offset(die_offset), m_dwo_num(dwo_num.value_or(0)),
-        m_dwo_num_valid(dwo_num ? true : false), m_section(section) {
-    assert(this->dwo_num() == dwo_num && "Dwo number out of range?");
+      : m_die_offset(die_offset), m_dwo_oso_num(dwo_oso_num.value_or(0)),
+        m_dwo_num_valid(dwo_oso_num ? true : false), m_oso_num_valid(0),
+        m_section(section) {
+    assert(this->dwo_num() == dwo_oso_num && "Dwo number out of range?");
   }
 
   explicit DIERef(lldb::user_id_t uid) {
     m_die_offset = uid & k_die_offset_mask;
     m_dwo_num_valid = (uid & k_dwo_num_valid_bit) != 0;
-    m_dwo_num =
+    m_oso_num_valid = (uid & k_oso_num_valid_bit) != 0;
+    m_dwo_oso_num =
         m_dwo_num_valid ? (uid >> k_die_offset_bit_size) & k_dwo_num_mask : 0;
     m_section =
         (uid & k_section_bit) != 0 ? Section::DebugTypes : Section::DebugInfo;
   }
 
   lldb::user_id_t get_id() const {
     return lldb::user_id_t(dwo_num().value_or(0)) << k_die_offset_bit_size |
            die_offset() | (m_dwo_num_valid ? k_dwo_num_valid_bit : 0) |
+           (m_oso_num_valid ? k_oso_num_valid_bit : 0) |
            (section() == Section::DebugTypes ? k_section_bit : 0);
   }
 
   std::optional<uint32_t> dwo_num() const {
     if (m_dwo_num_valid)
-      return m_dwo_num;
+      return m_dwo_oso_num;
+    return std::nullopt;
+  }
+
+  std::optional<uint32_t> oso_num() const {
+    if (m_oso_num_valid)
+      return m_dwo_oso_num;
     return std::nullopt;
   }
 
   Section section() const { return static_cast<Section>(m_section); }
 
   dw_offset_t die_offset() const { return m_die_offset; }
 
   bool operator<(DIERef other) const {
     if (m_dwo_num_valid != other.m_dwo_num_valid)
       return m_dwo_num_valid < other.m_dwo_num_valid;
-    if (m_dwo_num_valid && (m_dwo_num != other.m_dwo_num))
-      return m_dwo_num < other.m_dwo_num;
+    if (m_oso_num_valid != other.m_oso_num_valid)
+      return m_oso_num_valid < other.m_oso_num_valid;
+    if (m_dwo_num_valid && (m_dwo_oso_num != other.m_dwo_oso_num))
+      return m_dwo_oso_num < other.m_dwo_oso_num;
     if (m_section != other.m_section)
       return m_section < other.m_section;
     return m_die_offset < other.m_die_offset;
   }
 
   bool operator==(const DIERef &rhs) const {
     return dwo_num() == rhs.dwo_num() && m_section == rhs.m_section &&
            m_die_offset == rhs.m_die_offset;
public:
   ///
   /// \param encoder
   ///   A data encoder object that serialized bytes will be encoded into.
   ///
   void Encode(lldb_private::DataEncoder &encoder) const;
 
   static constexpr uint64_t k_die_offset_bit_size = DW_DIE_OFFSET_MAX_BITSIZE;
   static constexpr uint64_t k_dwo_num_bit_size =
-      64 - DW_DIE_OFFSET_MAX_BITSIZE - /* size of control bits */ 2;
+      64 - DW_DIE_OFFSET_MAX_BITSIZE - /* size of control bits */ 3;
 
   static constexpr uint64_t k_dwo_num_valid_bit =
       (1ull << (k_dwo_num_bit_size + k_die_offset_bit_size));
-  static constexpr uint64_t k_section_bit =
+  static constexpr uint64_t k_oso_num_valid_bit =
       (1ull << (k_dwo_num_bit_size + k_die_offset_bit_size + 1));
+  static constexpr uint64_t k_section_bit =
+      (1ull << (k_dwo_num_bit_size + k_die_offset_bit_size + 2));
 
   static constexpr uint64_t
       k_dwo_num_mask = (~0ull) >> (64 - k_dwo_num_bit_size); // 0x1fffff;
   static constexpr uint64_t k_die_offset_mask = (~0ull) >>
                                                 (64 - k_die_offset_bit_size);
 
 private:
   // Allow 2TB of .debug_info/.debug_types offset
   dw_offset_t m_die_offset : k_die_offset_bit_size;
   // Used for DWO index or for .o file index on mac
-  dw_offset_t m_dwo_num : k_dwo_num_bit_size;
+  dw_offset_t m_dwo_oso_num : k_dwo_num_bit_size;
   // Set to 1 if m_file_index is a DWO number
   dw_offset_t m_dwo_num_valid : 1;
+  // Set to 1 if m_file_index is a N_OSO index for mac debugging without a dSYM
+  // file
+  dw_offset_t m_oso_num_valid : 1;
   // Set to 0 for .debug_info 1 for .debug_types,
   dw_offset_t m_section : 1;
 };
 static_assert(sizeof(DIERef) == 8);
 
 typedef std::vector<DIERef> DIEArray;
 
 namespace llvm {
 template<> struct format_provider<DIERef> {
   static void format(const DIERef &ref, raw_ostream &OS, StringRef Style);
 };
 } // namespace llvm
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DIEREF_H

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

 void SymbolFileDWARF::ParseDeclsForContext(CompilerDeclContext decl_ctx) {
   auto *type_system = decl_ctx.GetTypeSystem();
   if (type_system != nullptr)
     type_system->GetDWARFParser()->EnsureAllDIEsInDeclContextHaveBeenParsed(
         decl_ctx);
 }
 
 user_id_t SymbolFileDWARF::GetUID(DIERef ref) {
-  if (GetDebugMapSymfile())
-    return GetID() | ref.die_offset();
-
   return DIERef(GetID(), ref.section(), ref.die_offset()).get_id();
 }
 
 std::optional<SymbolFileDWARF::DecodedUID>
 SymbolFileDWARF::DecodeUID(lldb::user_id_t uid) {
   // This method can be called without going through the symbol vendor so we
   // need to lock the module.
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.h

 //===-- SymbolFileDWARFDebugMap.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 LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_SYMBOLFILEDWARFDEBUGMAP_H
 #define LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_SYMBOLFILEDWARFDEBUGMAP_H
 
+#include "DIERef.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Utility/RangeMap.h"
 #include "llvm/Support/Chrono.h"
 #include <bitset>
 #include <map>
 #include <optional>
 #include <vector>
 
protected:
   /// upfront.
   uint32_t CalculateNumCompileUnits() override;
 
   /// This function actually returns the first compile unit the object file at
   /// the given index contains.
   lldb::CompUnitSP ParseCompileUnitAtIndex(uint32_t index) override;
 
   static uint32_t GetOSOIndexFromUserID(lldb::user_id_t uid) {
-    return (uint32_t)((uid >> 32ull) - 1ull);
+    std::optional<uint32_t> OsoNum = DIERef(uid).oso_num();
+    lldbassert(OsoNum && "Invalid OSO Index");
+    return *OsoNum;
   }
 
   static SymbolFileDWARF *GetSymbolFileAsSymbolFileDWARF(SymbolFile *sym_file);
 
   bool GetFileSpecForSO(uint32_t oso_idx, lldb_private::FileSpec &file_spec);
 
   CompileUnitInfo *GetCompUnitInfo(const lldb_private::SymbolContext &sc);
   CompileUnitInfo *GetCompUnitInfo(const lldb_private::CompileUnit &comp_unit);

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARFDebugMap.cpp

 //===-- SymbolFileDWARFDebugMap.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
 //
 //===----------------------------------------------------------------------===//
 
 #include "SymbolFileDWARFDebugMap.h"
 #include "DWARFCompileUnit.h"
 #include "DWARFDebugAranges.h"
 #include "DWARFDebugInfo.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Host/FileSystem.h"
if (exe_module_sp) {
           ObjectFile *exe_objfile = exe_module_sp->GetObjectFile();
           SymbolFile *exe_symfile = exe_module_sp->GetSymbolFile();
 
           if (exe_objfile && exe_symfile) {
             oso_symfile->SetDebugMapModule(exe_module_sp);
             // Set the ID of the symbol file DWARF to the index of the OSO
             // shifted left by 32 bits to provide a unique prefix for any
             // UserID's that get created in the symbol file.
-            oso_symfile->SetID(((uint64_t)m_cu_idx + 1ull) << 32ull);
+            oso_symfile->SetID((uint64_t)m_cu_idx + 1ull);
           }
           return symfile;
         }
       }
     }
     return nullptr;
   }
 

lldb/test/Shell/SymbolFile/DWARF/x86/debug_rnglists-dwo.s

 # RUN: cd %T
 # RUN: llvm-mc -triple=x86_64-pc-linux -filetype=obj %s >debug_rnglists-dwo.o
 # RUN: %lldb debug_rnglists-dwo.o -o "image lookup -v -s lookup_rnglists" \
 # RUN:   -o exit | FileCheck %s
 
 # CHECK-LABEL: image lookup -v -s lookup_rnglists
-# CHECK:  Function: id = {0x4000000000000028}, name = "rnglists", range = [0x0000000000000000-0x0000000000000003)
-# CHECK:    Blocks: id = {0x4000000000000028}, range = [0x00000000-0x00000003)
-# CHECK-NEXT:       id = {0x4000000000000037}, range = [0x00000001-0x00000002)
+# CHECK:  Function: id = {0x2000000000000028}, name = "rnglists", range = [0x0000000000000000-0x0000000000000003)
+# CHECK:    Blocks: id = {0x2000000000000028}, range = [0x00000000-0x00000003)
+# CHECK-NEXT:       id = {0x2000000000000037}, range = [0x00000001-0x00000002)
 
         .text
 rnglists:
         nop
 .Lblock1_begin:
 lookup_rnglists:
         nop
 .Lblock1_end: