[LLDB][DRAFT] Add 64bit support to LLDB

[ayermolo]

Summary

Test Plan:

lldb/include/lldb/Core/dwarf.h

 typedef int32_t dw_sleb128_t;
 typedef uint16_t dw_attr_t;
 typedef uint16_t dw_form_t;
 typedef llvm::dwarf::Tag dw_tag_t;
 typedef uint64_t dw_addr_t; // Dwarf address define that must be big enough for
                             // any addresses in the compile units that get
                             // parsed
 
-typedef uint32_t dw_offset_t; // Dwarf Debug Information Entry offset for any
+typedef uint64_t dw_offset_t; // Dwarf Debug Information Entry offset for any
                               // offset into the file
 
 /* Constants */
-#define DW_INVALID_OFFSET (~(dw_offset_t)0)
+#define DW_DIE_OFFSET_MAX_BITSIZE 40
+#define DW_INVALID_OFFSET (((uint64_t)1u << DW_DIE_OFFSET_MAX_BITSIZE) - 1)
 #define DW_INVALID_INDEX 0xFFFFFFFFul
 
 // #define DW_ADDR_none 0x0
 
 #define DW_EH_PE_MASK_ENCODING 0x0F
 
 typedef lldb_private::RangeVector<dw_addr_t, dw_addr_t, 2> DWARFRangeList;
 
 #endif // LLDB_CORE_DWARF_H

lldb/include/lldb/Symbol/DWARFCallFrameInfo.h

private:
 
   bool IsEHFrame() const;
 
   std::optional<FDEEntryMap::Entry>
   GetFirstFDEEntryInRange(const AddressRange &range);
 
   void GetFDEIndex();
 
-  bool FDEToUnwindPlan(uint32_t offset, Address startaddr,
+  bool FDEToUnwindPlan(dw_offset_t offset, Address startaddr,
                        UnwindPlan &unwind_plan);
 
   const CIE *GetCIE(dw_offset_t cie_offset);
 
   void GetCFIData();
 
   // Applies the specified DWARF opcode to the given row. This function handle
   // the commands operates only on a single row (these are the ones what can
private:
 
   FDEEntryMap m_fde_index;
   bool m_fde_index_initialized = false; // only scan the section for FDEs once
   std::mutex m_fde_index_mutex; // and isolate the thread that does it
 
   Type m_type;
 
   CIESP
-  ParseCIE(const uint32_t cie_offset);
+  ParseCIE(const dw_offset_t cie_offset);
 
   lldb::RegisterKind GetRegisterKind() const {
     return m_type == EH ? lldb::eRegisterKindEHFrame : lldb::eRegisterKindDWARF;
   }
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_SYMBOL_DWARFCALLFRAMEINFO_H

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

 //===-- DIERef.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_DIEREF_H
 #define LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_DIEREF_H
 
 #include "lldb/Core/dwarf.h"
 #include "llvm/Support/FormatProviders.h"
 #include <cassert>
+#include <cstdint>
 #include <optional>
 #include <vector>
 
 /// Identifies a DWARF debug info entry within a given Module. It contains three
 /// "coordinates":
 /// - dwo_num: identifies the dwo file in the Module. If this field is not set,
 ///   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 };
 
   DIERef(std::optional<uint32_t> dwo_num, Section section,
          dw_offset_t die_offset)
-      : m_dwo_num(dwo_num.value_or(0)), m_dwo_num_valid(bool(dwo_num)),
-        m_section(section), m_die_offset(die_offset) {
+      : m_die_offset(die_offset), m_dwo_num(dwo_num.value_or(0)),
+        m_dwo_num_valid(bool(dwo_num)), m_section(section) {
     assert(this->dwo_num() == dwo_num && "Dwo number out of range?");
   }
 
   std::optional<uint32_t> dwo_num() const {
     if (m_dwo_num_valid)
       return m_dwo_num;
     return std::nullopt;
   }
public:
   ///
   /// This allows this object to be serialized to disk.
   ///
   /// \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;
+
+  static constexpr uint64_t k_dwo_num_valid_bit_shift_by =
+      k_dwo_num_bit_size + k_die_offset_bit_size;
+  static constexpr uint64_t k_dwo_num_valid_bit =
+      (1ull << k_dwo_num_valid_bit_shift_by);
+  static constexpr uint64_t k_section_bit_shift_by =
+      k_dwo_num_valid_bit_shift_by + 1;
+  static constexpr uint64_t k_section_bit = (1ull << k_section_bit_shift_by);
+
+  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:
-  uint32_t m_dwo_num : 30;
-  uint32_t m_dwo_num_valid : 1;
-  uint32_t m_section : 1;
-  dw_offset_t m_die_offset;
+  // 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;
+  // Set to 1 if m_file_index is a DWO number
+  dw_offset_t m_dwo_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/DIERef.cpp

 //===-- DIERef.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 "DIERef.h"
 #include "lldb/Utility/DataEncoder.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "llvm/Support/Format.h"
+#include <cstdint>
 #include <optional>
 
 using namespace lldb;
 using namespace lldb_private;
 
 void llvm::format_provider<DIERef>::format(const DIERef &ref, raw_ostream &OS,
                                            StringRef Style) {
   if (ref.dwo_num())
     OS << format_hex_no_prefix(*ref.dwo_num(), 8) << "/";
   OS << (ref.section() == DIERef::DebugInfo ? "INFO" : "TYPE");
   OS << "/" << format_hex_no_prefix(ref.die_offset(), 8);
 }
 
-constexpr uint32_t k_dwo_num_mask = 0x3FFFFFFF;
-constexpr uint32_t k_dwo_num_valid_bitmask = (1u << 30);
-constexpr uint32_t k_section_bitmask = (1u << 31);
-
 std::optional<DIERef> DIERef::Decode(const DataExtractor &data,
                                      lldb::offset_t *offset_ptr) {
-  const uint32_t bitfield_storage = data.GetU32(offset_ptr);
-  uint32_t dwo_num = bitfield_storage & k_dwo_num_mask;
-  bool dwo_num_valid = (bitfield_storage & (k_dwo_num_valid_bitmask)) != 0;
-  Section section = (Section)((bitfield_storage & (k_section_bitmask)) != 0);
+  const uint64_t bitfield_storage = data.GetU64(offset_ptr);
+  uint32_t dwo_num =
+      (bitfield_storage >> k_die_offset_bit_size) & k_dwo_num_mask;
+  bool dwo_num_valid = (bitfield_storage & (k_dwo_num_valid_bit)) != 0;
+  Section section = (Section)((bitfield_storage & (k_section_bit)) != 0);
   // DIE offsets can't be zero and if we fail to decode something from data,
   // it will return 0
-  dw_offset_t die_offset = data.GetU32(offset_ptr);
+  dw_offset_t die_offset = bitfield_storage & DIERef::k_die_offset_mask;
   if (die_offset == 0)
     return std::nullopt;
   if (dwo_num_valid)
     return DIERef(dwo_num, section, die_offset);
-  else
-    return DIERef(std::nullopt, section, die_offset);
+
 }
 
 void DIERef::Encode(DataEncoder &encoder) const {
-  uint32_t bitfield_storage = m_dwo_num;
-  if (m_dwo_num_valid)
-    bitfield_storage |= k_dwo_num_valid_bitmask;
-  if (m_section)
-    bitfield_storage |= k_section_bitmask;
-  encoder.AppendU32(bitfield_storage);
-  static_assert(sizeof(m_die_offset) == 4, "m_die_offset must be 4 bytes");
-  encoder.AppendU32(m_die_offset);
+  uint64_t bitfield_storage =
+      uint64_t(m_dwo_num) << k_die_offset_bit_size | m_die_offset |
+      uint64_t(m_dwo_num_valid) << DIERef::k_dwo_num_valid_bit_shift_by |
+      uint64_t(section() == DIERef::Section::DebugTypes)
+          << DIERef::k_dwo_num_valid_bit_shift_by;
+  encoder.AppendU64(bitfield_storage);
 }

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

uint32_t DWARFDebugInfo::FindUnitIndex(DIERef::Section section,
   auto pos = llvm::upper_bound(
       m_units, std::make_pair(section, offset),
       [](const std::pair<DIERef::Section, dw_offset_t> &lhs,
          const DWARFUnitSP &rhs) {
         return lhs < std::make_pair(rhs->GetDebugSection(), rhs->GetOffset());
       });
   uint32_t idx = std::distance(m_units.begin(), pos);
   if (idx == 0)
-    return DW_INVALID_OFFSET;
+    return DW_INVALID_INDEX;
   return idx - 1;
 }
 
 DWARFUnit *DWARFDebugInfo::GetUnitAtOffset(DIERef::Section section,
                                            dw_offset_t cu_offset,
                                            uint32_t *idx_ptr) {
   uint32_t idx = FindUnitIndex(section, cu_offset);
   DWARFUnit *result = GetUnitAtIndex(idx);

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

 //===-- SymbolFileDWARF.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 "SymbolFileDWARF.h"
 
 #include "llvm/DebugInfo/DWARF/DWARFDebugLoc.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Threading.h"
 
+#include "DIERef.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Progress.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/Value.h"
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 |
-         lldb::user_id_t(ref.section() == DIERef::Section::DebugTypes) << 63;
+  lldbassert(ref.dwo_num().value_or(0) <= DIERef::k_dwo_num_mask);
+  return user_id_t(ref.dwo_num().value_or(0)) << DIERef::k_die_offset_bit_size |
+         ref.die_offset() |
+         lldb::user_id_t(ref.dwo_num().has_value())
+             << DIERef::k_dwo_num_valid_bit_shift_by |
+         lldb::user_id_t(ref.section() == DIERef::Section::DebugTypes)
+             << DIERef::k_section_bit_shift_by;
 }
 
 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());
   // 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;
 
   std::optional<uint32_t> dwo_num;
-  bool dwo_valid = uid >> 62 & 1;
+  bool dwo_valid = uid & DIERef::k_dwo_num_valid_bit;
   if (dwo_valid)
-    dwo_num = uid >> 32 & 0x3fffffff;
+    dwo_num = uid >> DW_DIE_OFFSET_MAX_BITSIZE & DIERef::k_dwo_num_mask;
 
   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.
if (pos != m_external_type_modules.end())
     return pos->second;
   else
     return lldb::ModuleSP();
 }
 
 DWARFDIE
 SymbolFileDWARF::GetDIE(const DIERef &die_ref) {
   if (die_ref.dwo_num()) {
-    SymbolFileDWARF *dwarf = *die_ref.dwo_num() == 0x3fffffff
+    SymbolFileDWARF *dwarf = *die_ref.dwo_num() == DIERef::k_dwo_num_mask
                                  ? m_dwp_symfile.get()
                                  : this->DebugInfo()
                                        .GetUnitAtIndex(*die_ref.dwo_num())
                                        ->GetDwoSymbolFile();
     return dwarf->DebugInfo().GetDIE(die_ref);
   }
 
   return DebugInfo().GetDIE(die_ref);
size_t SymbolFileDWARF::ParseBlocksRecursive(Function &func) {
   CompileUnit *comp_unit = func.GetCompileUnit();
   lldbassert(comp_unit);
 
   DWARFUnit *dwarf_cu = GetDWARFCompileUnit(comp_unit);
   if (!dwarf_cu)
     return 0;
 
   size_t functions_added = 0;
-  const dw_offset_t function_die_offset = func.GetID();
+  const dw_offset_t function_die_offset =
+      func.GetID() & DIERef::k_die_offset_mask;
   DWARFDIE function_die =
       dwarf_cu->GetNonSkeletonUnit().GetDIE(function_die_offset);
   if (function_die) {
     ParseBlocksRecursive(*comp_unit, &func.GetBlock(false), function_die,
                          LLDB_INVALID_ADDRESS, 0);
   }
 
   return functions_added;
if (FileSystem::Instance().Exists(dwp_filespec)) {
       DataBufferSP dwp_file_data_sp;
       lldb::offset_t dwp_file_data_offset = 0;
       ObjectFileSP dwp_obj_file = ObjectFile::FindPlugin(
           GetObjectFile()->GetModule(), &dwp_filespec, 0,
           FileSystem::Instance().GetByteSize(dwp_filespec), dwp_file_data_sp,
           dwp_file_data_offset);
       if (!dwp_obj_file)
         return;
-      m_dwp_symfile =
-          std::make_shared<SymbolFileDWARFDwo>(*this, dwp_obj_file, 0x3fffffff);
+      m_dwp_symfile = std::make_shared<SymbolFileDWARFDwo>(
+          *this, dwp_obj_file, DIERef::k_dwo_num_mask);
     }
   });
   return m_dwp_symfile;
 }
 
 llvm::Expected<lldb::TypeSystemSP>
 SymbolFileDWARF::GetTypeSystem(DWARFUnit &unit) {
   return unit.GetSymbolFileDWARF().GetTypeSystemForLanguage(GetLanguage(unit));

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 <optional>
 #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);
+
+  std::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;
 }
 
+namespace {
+uint32_t GetOSOIndexFromUserID(lldb::user_id_t uid) {
+  return static_cast<uint32_t>((uid >> DW_DIE_OFFSET_MAX_BITSIZE) - 1);
+}
+} // namespace
+
+user_id_t
+SymbolFileDWARFDebugMap::GetUID(SymbolFileDWARF::DecodedUID decoded_uid) {
+  return ((static_cast<user_id_t>(decoded_uid.dwarf.GetID()) + 1)
+          << DW_DIE_OFFSET_MAX_BITSIZE) |
+         decoded_uid.ref.die_offset();
+}
+
+std::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;
 
-  std::optional<uint32_t> GetDwoNum() override { return GetID() >> 32; }
+  std::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()) {
     if (const llvm::DWARFUnitIndex::Entry *entry = index.getFromHash(hash)) {
       if (auto *unit_contrib = entry->getContribution())
         return llvm::dyn_cast_or_null<DWARFCompileUnit>(
             DebugInfo().GetUnitAtOffset(DIERef::Section::DebugInfo,
-                                        unit_contrib->getOffset32()));
+                                        unit_contrib->getOffset()));
     }
     return nullptr;
   }
 
   DWARFCompileUnit *cu = FindSingleCompileUnit();
   if (!cu)
     return nullptr;
   std::optional<uint64_t> dwo_id = cu->GetDWOId();

lldb/test/Shell/SymbolFile/DWARF/DW_AT_range-DW_FORM_sec_offset.s

 # DW_AT_ranges can use DW_FORM_sec_offset (instead of DW_FORM_rnglistx).
 # In such case DW_AT_rnglists_base does not need to be present.
 
 # REQUIRES: x86
 
 # RUN: llvm-mc -triple=x86_64-pc-linux -filetype=obj %s > %t
 # RUN: %lldb %t -o "image lookup -v -s lookup_rnglists" \
 # RUN:   -o exit | FileCheck %s
 
 # Failure was the block range 1..2 was not printed plus:
-# error: DW_AT_range-DW_FORM_sec_offset.s.tmp {0x0000003f}: DIE has DW_AT_ranges(0xc) attribute, but range extraction failed (missing or invalid range list table), please file a bug and attach the file at the start of this error message
+# error: DW_AT_range-DW_FORM_sec_offset.s.tmp {0x000000000000003f}: DIE has DW_AT_ranges(0xc) attribute, but range extraction failed (missing or invalid range list table), please file a bug and attach the file at the start of this error message
 
 # CHECK-LABEL: image lookup -v -s lookup_rnglists
 # CHECK:  Function: id = {0x00000029}, name = "rnglists", range = [0x0000000000000000-0x0000000000000003)
 # CHECK:    Blocks: id = {0x00000029}, range = [0x00000000-0x00000003)
 # CHECK-NEXT:       id = {0x0000003f}, range = [0x00000001-0x00000002)
 
 # RUN: llvm-mc -triple=x86_64-pc-linux -filetype=obj \
 # RUN:   --defsym RNGLISTX=0 %s > %t-rnglistx

lldb/unittests/Expression/DWARFExpressionTest.cpp

- Table:
               Form:            DW_FORM_data4
   debug_info:
     - Version:         4
       AddrSize:        4
       Entries:
         - AbbrCode:        0x1
           Values:
             - CStr:           "dwo_unit"
-            - Value:           0x01020304
+            - Value:           0x0120304
         - AbbrCode:        0x0
 )";
 
   // .dwo sections aren't currently supported by dwarfyaml. The dwo_yamldata
   // contents where generated by roundtripping the following yaml through
   // yaml2obj | obj2yaml and renaming the sections. This works because the
   // structure of the .dwo and non-.dwo sections is identical.
   //