Reduce bit manipulation

[labath]

fix

[labath]

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

1403–1436

This code is fully and exclusively in charge of user_id encoding for the "DWO" case. We can replace 32 by DW_DIE_OFFSET_MAX_BITSIZE from your patch and 0x3fffffff by something like llvm::maskTrailingOnes(62-DW_DIE_OFFSET_MAX_BITSIZE). I believe that is sufficient to make it die-offset-width agnostic.

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

771–789

This code is fully and exclusively in charge of DIERef->user_id_t conversion for the "oso" case. Replace 32 by DW_DIE_OFFSET_MAX_BITSIZE and dw_offset_t(XXX) by XXX & llvm::maskTrailingOnes<dw_offset_t>(DW_DIE_OFFSET_MAX_BITSIZE)

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

43

This shift and the one below cancel each other out. Their presence is just a historic artefact.

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 GetDebugMapSymfile()->GetUID({*this, ref});
 
-  lldbassert(GetDwoNum().value_or(0) <= 0x3fffffff);
-  return user_id_t(GetDwoNum().value_or(0)) << 32 | ref.die_offset() |
-         lldb::user_id_t(GetDwoNum().has_value()) << 62 |
+  lldbassert(ref.dwo_num().value_or(0) <= 0x3fffffff);
+  return user_id_t(ref.dwo_num().value_or(0)) << 32 | ref.die_offset() |
+         lldb::user_id_t(ref.dwo_num().has_value()) << 62 |
          lldb::user_id_t(ref.section() == DIERef::Section::DebugTypes) << 63;
 }
 
 llvm::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());
   // Anytime we get a "lldb::user_id_t" from an lldb_private::SymbolFile API we
   // must make sure we use the correct DWARF file when resolving things. On
   // MacOSX, when using SymbolFileDWARFDebugMap, we will use multiple
   // SymbolFileDWARF classes, one for each .o file. We can often end up with
   // references to other DWARF objects and we must be ready to receive a
   // "lldb::user_id_t" that specifies a DIE from another SymbolFileDWARF
   // instance.
   if (SymbolFileDWARFDebugMap *debug_map = GetDebugMapSymfile()) {
-    SymbolFileDWARF *dwarf = debug_map->GetSymbolFileByOSOIndex(
-        debug_map->GetOSOIndexFromUserID(uid));
-    return DecodedUID{
-        *dwarf, {std::nullopt, DIERef::Section::DebugInfo, dw_offset_t(uid)}};
+    return debug_map->DecodeUID(uid);
   }
   dw_offset_t die_offset = uid;
   if (die_offset == DW_INVALID_OFFSET)
     return std::nullopt;
 
   DIERef::Section section =
       uid >> 63 ? DIERef::Section::DebugTypes : DIERef::Section::DebugInfo;
 
   llvm::Optional<uint32_t> dwo_num;
   bool dwo_valid = uid >> 62 & 1;
   if (dwo_valid)
     dwo_num = uid >> 32 & 0x3fffffff;
 
   return DecodedUID{*this, {dwo_num, section, die_offset}};
 }
 
 DWARFDIE
 SymbolFileDWARF::GetDIE(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

 
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Utility/RangeMap.h"
 #include "llvm/Support/Chrono.h"
 #include <bitset>
 #include <map>
 #include <vector>
 
+#include "SymbolFileDWARF.h"
 #include "UniqueDWARFASTType.h"
 
-class SymbolFileDWARF;
 class DWARFCompileUnit;
 class DWARFDebugAranges;
 class DWARFDeclContext;
 
 class SymbolFileDWARFDebugMap : public lldb_private::SymbolFileCommon {
   /// LLVM RTTI support.
   static char ID;
 
protected:
   /// there's no efficient way to calculate the actual number of compile units
   /// 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);
-  }
+  lldb::user_id_t GetUID(SymbolFileDWARF::DecodedUID decoded_uid);
+
+  llvm::Optional<SymbolFileDWARF::DecodedUID> DecodeUID(lldb::user_id_t uid);
 
   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

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(m_cu_idx + 1);
           }
           return symfile;
         }
       }
     }
     return nullptr;
   }
 

 SymbolFileDWARFDebugMap::ParseVariablesForContext(const SymbolContext &sc) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   SymbolFileDWARF *oso_dwarf = GetSymbolFile(sc);
   if (oso_dwarf)
     return oso_dwarf->ParseVariablesForContext(sc);
   return 0;
 }
 
+static uint32_t GetOSOIndexFromUserID(lldb::user_id_t uid) {
+  return static_cast<uint32_t>((uid >> 32) - 1);
+}
+
+user_id_t
+SymbolFileDWARFDebugMap::GetUID(SymbolFileDWARF::DecodedUID decoded_uid) {
+  return ((static_cast<user_id_t>(decoded_uid.dwarf.GetID()) + 1) << 32) |
+         decoded_uid.ref.die_offset();
+}
+
+llvm::Optional<SymbolFileDWARF::DecodedUID>
+SymbolFileDWARFDebugMap::DecodeUID(user_id_t uid) {
+  if (SymbolFileDWARF *dwarf =
+          GetSymbolFileByOSOIndex(GetOSOIndexFromUserID(uid))) {
+    return SymbolFileDWARF::DecodedUID{
+        *dwarf, {std::nullopt, DIERef::Section::DebugInfo, dw_offset_t(uid)}};
+  }
+  return std::nullopt;
+}
+
 Type *SymbolFileDWARFDebugMap::ResolveTypeUID(lldb::user_id_t type_uid) {
   std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
   const uint64_t oso_idx = GetOSOIndexFromUserID(type_uid);
   SymbolFileDWARF *oso_dwarf = GetSymbolFileByOSOIndex(oso_idx);
   if (oso_dwarf)
     return oso_dwarf->ResolveTypeUID(type_uid);
   return nullptr;
 }

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

void GetObjCMethods(lldb_private::ConstString class_name,
                       llvm::function_ref<bool(DWARFDIE die)> callback) override;
 
   llvm::Expected<lldb::TypeSystemSP>
   GetTypeSystemForLanguage(lldb::LanguageType language) override;
 
   DWARFDIE
   GetDIE(const DIERef &die_ref) override;
 
-  llvm::Optional<uint32_t> GetDwoNum() override { return GetID() >> 32; }
+  llvm::Optional<uint32_t> GetDwoNum() override { return GetID(); }
 
   lldb::offset_t
   GetVendorDWARFOpcodeSize(const lldb_private::DataExtractor &data,
                            const lldb::offset_t data_offset,
                            const uint8_t op) const override;
 
   bool ParseVendorDWARFOpcode(
       uint8_t op, const lldb_private::DataExtractor &opcodes,

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

 
 char SymbolFileDWARFDwo::ID;
 
 SymbolFileDWARFDwo::SymbolFileDWARFDwo(SymbolFileDWARF &base_symbol_file,
                                        ObjectFileSP objfile, uint32_t id)
     : SymbolFileDWARF(objfile, objfile->GetSectionList(
                                    /*update_module_section_list*/ false)),
       m_base_symbol_file(base_symbol_file) {
-  SetID(user_id_t(id) << 32);
+  SetID(id);
 
   // Parsing of the dwarf unit index is not thread-safe, so we need to prime it
   // to enable subsequent concurrent lookups.
   m_context.GetAsLLVM().getCUIndex();
 }
 
 DWARFCompileUnit *SymbolFileDWARFDwo::GetDWOCompileUnitForHash(uint64_t hash) {
   if (const llvm::DWARFUnitIndex &index = m_context.GetAsLLVM().getCUIndex()) {