DWZ 03/11: Separate Offset also into FileOffset

[jankratochvil]

Summary

Offset may represent virtual DW_TAG_partial_unit remapping while FileOffset always represents the file data. Units are ordered:

Offset 0	FileOffset 0 of DWZ file (if exists)
Offset {DWZ file size}	FileOffset 0 of main file
Offset {DWZ file size + main file size}	First remapped DW_TAG_partial_unit

All DWZ patches are also applied in: git clone -b dwz git://git.jankratochvil.net/lldb

[clayborg]

It would be much easier to read this patch if there were no renames from "*offset" to "*file_offset". Can we remove these extra renames where it isn't needed?

source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.h

15

Why is this added here? Doesn't seem to be needed, or it should be moved to .cpp file?

[jankratochvil]

source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.h

15

Yes, a patch split up typo, sorry.

[jankratochvil]

Removed excessive: #include: <mutex>

[clayborg]

Please undo all renaming from offset to file_offset. The "offset" you get from a DIE should always be the absolute .debug_info offset. No need to say file_offset. Patch will be easier to read after spurious renames are removed.

include/lldb/Expression/DWARFExpression.h

221–223

don't rename, revert

source/Expression/DWARFExpression.cpp

92–94

don't rename, revert

source/Plugins/SymbolFile/DWARF/DWARFAttribute.cpp

54

Why is this not just done correctly inside DIEOffsetAtIndex? No need to rename the variable.

56

don't rename.

source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.h

78–97

Not a fan of these names. Can't these just be something like:

dw_offset_t GeCUtRelativeOffset(); // CU relative offset
dw_offset_t GetOffset(); // Always absolute .debug_info offset

ThisCUUniqToFileOffset seems a bit unclear.

[jankratochvil]

Please undo all renaming from offset to file_offset.

I am preparing now a split of this patch for the renaming part + the "real" part, sorry I did not realize it is mostly about the renaming which is not worth your detailed review.

There are two different types of offsets:

UniqOffset	One DIE from a DW_TAG_partial_unit gets two different UniqOffset depending from which DW_TAG_compile_unit it was included
FileOffset	One DIE from a DW_TAG_partial_unit has only one FileOffset - where one can read it from get_debug_info_data()

Most of LLDB works with UniqOffset so I kept the original dw_offset_t offset type+name for it. When LLDB works with FileOffset I call it dw_offset_t file_offset. I really discourage calling these two different offset types the same as it is a bug (although affecting only DWZ files) if there is missing a proper conversion function between these two types.

I found overengineered to make a separate type-safe against accidental exchange wrapper class for the `FileOffset' but I can if you prefer that over a simple renaming of all the variables/parameters.

D40474 introduces DWARFFileOffset which makes it type-safe against accidental exchange with dw_offset_t but that type includes also bool is_dwz whether it is in DWZ Common File or in the main symbol file which makes it excessive for the places where currently I used dw_offset_t file_offset because the file itself is known there.

The "offset" you get from a DIE should always be the absolute .debug_info offset. No need to say file_offset.

We never talk about CU-relative offset. I made remapping in DWARFDebugInfoEntry:

dw_offset_t GetOffset() renamed to	FileOffset-kind dw_offset_t GetFileOffset()
new	UniqOffset-kind dw_offset_t GetOffset(const DWARFCompileUnit *cu)

source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.h

78–97

What should be dw_offset_t GeCUtRelativeOffset(); // CU relative offset?
This patchset never deals with offsets relative to the CU start (and LLDB never uses such offsets, DWARFCompileUnit::ExtractDIEsIfNeeded stores their .debug_info-relative offsets and DWARFFormValue::Reference() also converts everything into .debug_info-relative offsets.

UniqOffset -> FileOffset	DWARFDebugInfo::GetCompileUnit{,ContainingDIEOffset}	slow m_compile_units bisecting
UniqOffset -> FileOffset	DWARFCompileUnit::ThisCUUniqToFileOffset	fast but the CU must match
FileOffset -> UniqOffset	DWARFCompileUnit::ThisCUFileOffsetToUniq	fast, this functionality requires to use matching CU

UniqOffset is in the most simple case without using DWZ the same as FileOffset. If DWZ is used then see the mapping in Summary above.
The methods cannot be called `Get' as they convert their parameter value, they are not getters.

[jankratochvil]

Without FileOffset and the remapping to unique DIE offsets for each DW_TAG_partial_unit inclusion by DW_TAG_imported_unit this patch is no longer needed, as discussed in: https://lists.llvm.org/pipermail/lldb-commits/Week-of-Mon-20180409/040324.html

include/lldb/Expression/DWARFExpression.h

public:
   ///
   /// @param[in] data_offset
   ///     The offset of the location expression in the extractor.
   ///
   /// @param[in] data_length
   ///     The byte length of the location expression.
   //------------------------------------------------------------------
   void CopyOpcodeData(lldb::ModuleSP module_sp, const DataExtractor &data,
-                      lldb::offset_t data_offset, lldb::offset_t data_length);
+                      lldb::offset_t data_file_offset,
+                      lldb::offset_t data_length);
 
   void CopyOpcodeData(const void *data, lldb::offset_t data_length,
                       lldb::ByteOrder byte_order, uint8_t addr_byte_size);
 
   void CopyOpcodeData(uint64_t const_value,
                       lldb::offset_t const_value_byte_size,
                       uint8_t addr_byte_size);
 
   //------------------------------------------------------------------

source/Expression/DWARFExpression.cpp

 bool DWARFExpression::IsValid() const { return m_data.GetByteSize() > 0; }
 
 void DWARFExpression::SetOpcodeData(const DataExtractor &data) {
   m_data = data;
 }
 
 void DWARFExpression::CopyOpcodeData(lldb::ModuleSP module_sp,
                                      const DataExtractor &data,
-                                     lldb::offset_t data_offset,
+                                     lldb::offset_t data_file_offset,
                                      lldb::offset_t data_length) {
-  const uint8_t *bytes = data.PeekData(data_offset, data_length);
+  const uint8_t *bytes = data.PeekData(data_file_offset, data_length);
   if (bytes) {
     m_module_wp = module_sp;
     m_data.SetData(DataBufferSP(new DataBufferHeap(bytes, data_length)));
     m_data.SetByteOrder(data.GetByteOrder());
     m_data.SetAddressByteSize(data.GetAddressByteSize());
   }
 }
 

source/Plugins/SymbolFile/DWARF/DWARFAttribute.cpp

bool DWARFAttributes::RemoveAttribute(dw_attr_t attr) {
   return false;
 }
 
 bool DWARFAttributes::ExtractFormValueAtIndex(
     uint32_t i, DWARFFormValue &form_value) const {
   const DWARFUnit *cu = CompileUnitAtIndex(i);
   form_value.SetCompileUnit(cu);
   form_value.SetForm(FormAtIndex(i));
-  lldb::offset_t offset = DIEOffsetAtIndex(i);
+  lldb::offset_t file_offset = cu->ThisCUUniqToFileOffset(DIEOffsetAtIndex(i));
   return form_value.ExtractValue(
-      cu->GetSymbolFileDWARF()->get_debug_info_data(), &offset);
+      cu->GetSymbolFileDWARF()->get_debug_info_data(), &file_offset);
 }
 
 uint64_t DWARFAttributes::FormValueAsUnsigned(dw_attr_t attr,
                                               uint64_t fail_value) const {
   const uint32_t attr_idx = FindAttributeIndex(attr);
   if (attr_idx != UINT32_MAX)
     return FormValueAsUnsignedAtIndex(attr_idx, fail_value);
   return fail_value;

source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.h

 //===-- DWARFCompileUnit.h --------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SymbolFileDWARF_DWARFCompileUnit_h_
 #define SymbolFileDWARF_DWARFCompileUnit_h_
 
 #include "DWARFUnit.h"
+#include "lldb/Utility/LLDBAssert.h"
 
 class DWARFCompileUnit : public DWARFUnit {
   friend class DWARFUnit;
 
 public:
   static DWARFUnitSP Extract(SymbolFileDWARF *dwarf2Data,
       lldb::offset_t *offset_ptr);
 
public:
   uint32_t GetProducerVersionMinor();
 
   uint32_t GetProducerVersionUpdate();
 
   lldb::LanguageType GetLanguageType();
 
   bool GetIsOptimized();
 
 protected:
   virtual DWARFCompileUnit &Data() override { return *this; }
   virtual const DWARFCompileUnit &Data() const override { return *this; }
 
+  dw_offset_t GetFileOffset() const;
+  dw_offset_t MainCU_FileOffsetToUniqOffset(dw_offset_t file) const {
+    return file;
+  }
+  dw_offset_t GetNextCompileUnitFileOffset() const {
+    return ThisCUUniqToFileOffset(GetNextCompileUnitOffset() - 1) + 1;
+  }
+
   SymbolFileDWARF *m_dwarf2Data;
   std::unique_ptr<SymbolFileDWARFDwo> m_dwo_symbol_file;
   const DWARFAbbreviationDeclarationSet *m_abbrevs;
   void *m_user_data = nullptr;
   DWARFDebugInfoEntry::collection
       m_die_array; // The compile unit debug information entry item
   std::unique_ptr<DWARFDebugAranges> m_func_aranges_ap; // A table similar to
                                                         // the .debug_aranges
                                                         // table, but this one
                                                         // points to the exact
                                                         // DW_TAG_subprogram
                                                         // DIEs
   dw_addr_t m_base_addr = 0;
   dw_offset_t m_length;
   uint16_t m_version;
   uint8_t m_addr_size;

source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp

 using namespace std;
 
 extern int g_verbose;
 
 DWARFCompileUnit::DWARFCompileUnit(SymbolFileDWARF *dwarf2Data)
     : m_dwarf2Data(dwarf2Data) {}
 
 DWARFUnitSP DWARFCompileUnit::Extract(SymbolFileDWARF *dwarf2Data,
-    lldb::offset_t *offset_ptr) {
+    lldb::offset_t *file_offset_ptr) {
   // std::make_shared would require the ctor to be public.
   std::shared_ptr<DWARFCompileUnit> cu_sp(new DWARFCompileUnit(dwarf2Data));
   // Out of memory?
   if (cu_sp.get() == NULL)
     return nullptr;
 
   const DWARFDataExtractor &debug_info = dwarf2Data->get_debug_info_data();
 
-  cu_sp->m_offset = *offset_ptr;
+  cu_sp->m_offset = *file_offset_ptr;
 
-  if (debug_info.ValidOffset(*offset_ptr)) {
+  if (debug_info.ValidOffset(*file_offset_ptr)) {
     dw_offset_t abbr_offset;
     const DWARFDebugAbbrev *abbr = dwarf2Data->DebugAbbrev();
-    cu_sp->m_length = debug_info.GetDWARFInitialLength(offset_ptr);
+    cu_sp->m_length = debug_info.GetDWARFInitialLength(file_offset_ptr);
     cu_sp->m_is_dwarf64 = debug_info.IsDWARF64();
-    cu_sp->m_version = debug_info.GetU16(offset_ptr);
-    abbr_offset = debug_info.GetDWARFOffset(offset_ptr);
-    cu_sp->m_addr_size = debug_info.GetU8(offset_ptr);
+    cu_sp->m_version = debug_info.GetU16(file_offset_ptr);
+    abbr_offset = debug_info.GetDWARFOffset(file_offset_ptr);
+    cu_sp->m_addr_size = debug_info.GetU8(file_offset_ptr);
 
     bool length_OK =
-        debug_info.ValidOffset(cu_sp->GetNextCompileUnitOffset() - 1);
+        debug_info.ValidOffset(cu_sp->GetNextCompileUnitFileOffset() - 1);
     bool version_OK = SymbolFileDWARF::SupportedVersion(cu_sp->m_version);
     bool abbr_offset_OK =
         dwarf2Data->get_debug_abbrev_data().ValidOffset(abbr_offset);
     bool addr_size_OK = (cu_sp->m_addr_size == 4) || (cu_sp->m_addr_size == 8);
 
     if (length_OK && version_OK && addr_size_OK && abbr_offset_OK &&
         abbr != NULL) {
       cu_sp->m_abbrevs = abbr->GetAbbreviationDeclarationSet(abbr_offset);
       return cu_sp;
     }
 
     // reset the offset to where we tried to parse from if anything went wrong
-    *offset_ptr = cu_sp->m_offset;
+    *file_offset_ptr = cu_sp->m_offset;
   }
 
   return nullptr;
 }
 
 void DWARFCompileUnit::ClearDIEs(bool keep_compile_unit_die) {
   if (m_die_array.size() > 1) {
     // std::vectors never get any smaller when resized to a smaller size,
size_t DWARFCompileUnit::ExtractDIEsIfNeeded(bool cu_die_only) {
   static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
   Timer scoped_timer(
       func_cat,
       "%8.8x: DWARFCompileUnit::ExtractDIEsIfNeeded( cu_die_only = %i )",
       m_offset, cu_die_only);
 
   // Set the offset to that of the first DIE and calculate the start of the
   // next compilation unit header.
-  lldb::offset_t offset = GetFirstDIEOffset();
+  lldb::offset_t file_offset = ThisCUUniqToFileOffset(GetFirstDIEOffset());
   lldb::offset_t next_cu_offset = GetNextCompileUnitOffset();
 
   DWARFDebugInfoEntry die;
   // Keep a flat array of the DIE for binary lookup by DIE offset
   if (!cu_die_only) {
     Log *log(
         LogChannelDWARF::GetLogIfAny(DWARF_LOG_DEBUG_INFO | DWARF_LOG_LOOKUPS));
     if (log) {
const DWARFDataExtractor &debug_info_data =
       m_dwarf2Data->get_debug_info_data();
   std::vector<uint32_t> die_index_stack;
   die_index_stack.reserve(32);
   die_index_stack.push_back(0);
   bool prev_die_had_children = false;
   DWARFFormValue::FixedFormSizes fixed_form_sizes =
       DWARFFormValue::GetFixedFormSizesForAddressSize(GetAddressByteSize(),
                                                       m_is_dwarf64);
-  while (offset < next_cu_offset &&
-         die.FastExtract(debug_info_data, this, fixed_form_sizes, &offset)) {
+  while (ThisCUFileOffsetToUniq_nocheck(file_offset) < next_cu_offset &&
+         die.FastExtract(debug_info_data, this, fixed_form_sizes, &file_offset))
+      {
     //        if (log)
     //            log->Printf("0x%8.8x: %*.*s%s%s",
     //                        die.GetOffset(),
     //                        depth * 2, depth * 2, "",
     //                        DW_TAG_value_to_name (die.Tag()),
     //                        die.HasChildren() ? " *" : "");
 
     const bool null_die = die.IsNULL();
if (null_die) {
       }
       prev_die_had_children = die_has_children;
     }
   }
 
   // Give a little bit of info if we encounter corrupt DWARF (our offset
   // should always terminate at or before the start of the next compilation
   // unit header).
-  if (offset > next_cu_offset) {
+  if (ThisCUFileOffsetToUniq_nocheck(file_offset) > next_cu_offset) {
     m_dwarf2Data->GetObjectFile()->GetModule()->ReportWarning(
         "DWARF compile unit extends beyond its bounds cu 0x%8.8x at "
-        "0x%8.8" PRIx64 "\n",
-        GetOffset(), offset);
+        "0x%8.8" PRIx32 "\n",
+        GetOffset(), ThisCUFileOffsetToUniq(file_offset));
   }
 
   // Since std::vector objects will double their size, we really need to
   // make a new array with the perfect size so we don't end up wasting
   // space. So here we copy and swap to make sure we don't have any extra
   // memory taken up.
 
   if (m_die_array.size() < m_die_array.capacity()) {
bool DWARFCompileUnit::GetIsOptimized() {
   }
   if (m_is_optimized == eLazyBoolYes) {
     return true;
   } else {
     return false;
   }
 }
 
+dw_offset_t DWARFCompileUnit::GetFileOffset() const {
+  return GetOffset();
+}
+
 TypeSystem *DWARFCompileUnit::GetTypeSystem() {
   if (m_dwarf2Data)
     return m_dwarf2Data->GetTypeSystemForLanguage(GetLanguageType());
   else
     return nullptr;
 }
 
 void DWARFCompileUnit::SetUserData(void *d) {

source/Plugins/SymbolFile/DWARF/DWARFDIE.cpp

 #include "DWARFDeclContext.h"
 #include "DWARFFormValue.h"
 #include "SymbolFileDWARF.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/TypeSystem.h"
+#include "lldb/Utility/LLDBAssert.h"
 
 using namespace lldb_private;
 
 DIERef DWARFDIE::GetDIERef() const {
   if (!IsValid())
     return DIERef();
 
   dw_offset_t cu_offset = m_cu->GetOffset();
   if (m_cu->GetBaseObjOffset() != DW_INVALID_OFFSET)
     cu_offset = m_cu->GetBaseObjOffset();
-  return DIERef(cu_offset, m_die->GetOffset());
+  return DIERef(cu_offset, m_die->GetOffset(m_cu));
 }
 
 dw_tag_t DWARFDIE::Tag() const {
   if (m_die)
     return m_die->Tag();
   else
     return 0;
 }

 DWARFDIE::LookupDeepestBlock(lldb::addr_t file_addr) const {
   if (IsValid()) {
     SymbolFileDWARF *dwarf = GetDWARF();
     DWARFUnit *cu = GetCU();
     DWARFDebugInfoEntry *function_die = nullptr;
     DWARFDebugInfoEntry *block_die = nullptr;
     if (m_die->LookupAddress(file_addr, dwarf, cu, &function_die, &block_die)) {
       if (block_die && block_die != function_die) {
-        if (cu->ContainsDIEOffset(block_die->GetOffset()))
+        if (cu->ContainsDIEOffset(block_die->GetOffset(cu)))
           return DWARFDIE(cu, block_die);
         else
           return DWARFDIE(dwarf->DebugInfo()->GetCompileUnit(
-                              DIERef(cu->GetOffset(), block_die->GetOffset())),
+                          DIERef(cu->GetOffset(), block_die->GetOffset(cu))),
                           block_die);
       }
     }
 #if 0
     cu->GetSymbolFileDWARF()->GetObjectFile()->GetModule()->ReportError(
        "CU 0x%8.8" PRIx32 " LookupDeepestBlock fail for addr 0x%16.16" PRIx64,
        cu->GetOffset(), file_addr);
 #endif

 DWARFDIE::GetParentDeclContextDIE() const {
   if (IsValid())
     return m_die->GetParentDeclContextDIE(GetDWARF(), m_cu);
   else
     return DWARFDIE();
 }
 
 dw_offset_t DWARFDIE::GetOffset() const {
-  if (IsValid())
-    return m_die->GetOffset();
-  else
+  if (IsValid()) {
+    lldbassert(m_cu);
+    return m_die->GetOffset(m_cu);
+  } else
     return DW_INVALID_OFFSET;
 }
 
 dw_offset_t DWARFDIE::GetCompileUnitRelativeOffset() const {
-  if (IsValid())
-    return m_die->GetOffset() - m_cu->GetOffset();
-  else
+  if (IsValid()) {
+    return m_die->GetOffset(m_cu) - m_cu->GetOffset();
+  } else
     return DW_INVALID_OFFSET;
 }
 
 SymbolFileDWARF *DWARFDIE::GetDWARF() const {
   if (m_cu)
     return m_cu->GetSymbolFileDWARF();
   else
     return nullptr;

source/Plugins/SymbolFile/DWARF/DWARFDebugAranges.h

 public:
   typedef RangeToDIE::Entry Range;
   typedef std::vector<RangeToDIE::Entry> RangeColl;
 
   DWARFDebugAranges();
 
   void Clear() { m_aranges.Clear(); }
 
-  bool Extract(const lldb_private::DWARFDataExtractor &debug_aranges_data);
+  bool Extract(const lldb_private::DWARFDataExtractor &debug_aranges_data,
+      dw_offset_t dwz_offset);
 
   bool Generate(SymbolFileDWARF *dwarf2Data);
 
   // Use append range multiple times and then call sort
   void AppendRange(dw_offset_t cu_offset, dw_addr_t low_pc, dw_addr_t high_pc);
 
   void Sort(bool minimize);
 

source/Plugins/SymbolFile/DWARF/DWARFDebugAranges.cpp

void operator()(const DWARFDebugArangeSet &set) {
     count += set.NumDescriptors();
   }
   uint32_t &count;
 };
 
 //----------------------------------------------------------------------
 // Extract
 //----------------------------------------------------------------------
-bool DWARFDebugAranges::Extract(const DWARFDataExtractor &debug_aranges_data) {
+bool DWARFDebugAranges::Extract(
+    const DWARFDataExtractor &debug_aranges_data, dw_offset_t dwz_offset) {
   if (debug_aranges_data.ValidOffset(0)) {
     lldb::offset_t offset = 0;
 
     DWARFDebugArangeSet set;
     Range range;
     while (set.Extract(debug_aranges_data, &offset)) {
       const uint32_t num_descriptors = set.NumDescriptors();
       if (num_descriptors > 0) {
-        const dw_offset_t cu_offset = set.GetCompileUnitDIEOffset();
+        const dw_offset_t cu_file_offset = set.GetCompileUnitDIEOffset();
+
+        const dw_offset_t cu_offset = cu_file_offset + dwz_offset;
 
         for (uint32_t i = 0; i < num_descriptors; ++i) {
           const DWARFDebugArangeSet::Descriptor &descriptor =
               set.GetDescriptorRef(i);
           m_aranges.Append(RangeToDIE::Entry(descriptor.address,
                                              descriptor.length, cu_offset));
         }
       }

source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.h

 //===-- DWARFDebugInfo.h ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SymbolFileDWARF_DWARFDebugInfo_h_
 #define SymbolFileDWARF_DWARFDebugInfo_h_
 
 #include <map>
 #include <vector>
 
 #include "DWARFUnit.h"
 #include "DWARFDIE.h"
 #include "SymbolFileDWARF.h"
 #include "lldb/Core/STLUtils.h"
 #include "lldb/lldb-private.h"
 
 typedef std::multimap<const char *, dw_offset_t, CStringCompareFunctionObject>
     CStringToDIEMap;
 typedef CStringToDIEMap::iterator CStringToDIEMapIter;
 typedef CStringToDIEMap::const_iterator CStringToDIEMapConstIter;
 
 class DWARFDebugInfo {
 public:
   typedef dw_offset_t (*Callback)(SymbolFileDWARF *dwarf2Data,
                                   DWARFUnit *cu,
                                   DWARFDebugInfoEntry *die,
-                                  const dw_offset_t next_offset,
+                                  const dw_offset_t next_file_offset,
                                   const uint32_t depth, void *userData);
 
   DWARFDebugInfo();
   void SetDwarfData(SymbolFileDWARF *dwarf2Data);
 
   size_t GetNumCompileUnits();
   bool ContainsCompileUnit(const DWARFUnit *cu) const;
   DWARFUnit *GetCompileUnitAtIndex(uint32_t idx);

source/Plugins/SymbolFile/DWARF/DWARFDebugInfo.cpp

if (m_cu_aranges_ap.get() == NULL && m_dwarf2Data) {
     const DWARFDataExtractor &debug_aranges_data =
         m_dwarf2Data->get_debug_aranges_data();
     if (debug_aranges_data.GetByteSize() > 0) {
       if (log)
         log->Printf(
             "DWARFDebugInfo::GetCompileUnitAranges() for \"%s\" from "
             ".debug_aranges",
             m_dwarf2Data->GetObjectFile()->GetFileSpec().GetPath().c_str());
-      m_cu_aranges_ap->Extract(debug_aranges_data);
+      dw_offset_t dwz_offset = 0;
+      m_cu_aranges_ap->Extract(debug_aranges_data, dwz_offset);
     }
 
     // Make a list of all CUs represented by the arange data in the file.
     std::set<dw_offset_t> cus_with_data;
     for (size_t n = 0; n < m_cu_aranges_ap.get()->GetNumRanges(); n++) {
       dw_offset_t offset = m_cu_aranges_ap.get()->OffsetAtIndex(n);
       if (offset != DW_INVALID_OFFSET)
         cus_with_data.insert(offset);
if (m_cu_aranges_ap.get() == NULL && m_dwarf2Data) {
     m_cu_aranges_ap->Sort(minimize);
   }
   return *m_cu_aranges_ap.get();
 }
 
 void DWARFDebugInfo::ParseCompileUnitHeadersIfNeeded() {
   if (m_compile_units.empty()) {
     if (m_dwarf2Data != NULL) {
-      lldb::offset_t offset = 0;
+      lldb::offset_t file_offset = 0;
       DWARFUnitSP cu_sp;
-      while ((cu_sp = DWARFCompileUnit::Extract(m_dwarf2Data, &offset))) {
+      while ((cu_sp = DWARFCompileUnit::Extract(m_dwarf2Data, &file_offset))) {
         m_compile_units.push_back(cu_sp);
 
-        offset = cu_sp->GetNextCompileUnitOffset();
+        file_offset = cu_sp->GetNextCompileUnitFileOffset();
       }
     }
   }
 }
 
 size_t DWARFDebugInfo::GetNumCompileUnits() {
   ParseCompileUnitHeadersIfNeeded();
   return m_compile_units.size();

 // supplied callback function each time a compile unit header, or debug
 // information entry is successfully parsed. This function can be used
 // for different tasks such as parsing the file contents into a
 // structured data, dumping, verifying and much more.
 //----------------------------------------------------------------------
 void DWARFDebugInfo::Parse(SymbolFileDWARF *dwarf2Data, Callback callback,
                            void *userData) {
   if (dwarf2Data) {
-    lldb::offset_t offset = 0;
+    lldb::offset_t file_offset = 0;
     uint32_t depth = 0;
     DWARFDebugInfoEntry die;
 
     DWARFUnitSP cu;
-    while ((cu = DWARFCompileUnit::Extract(dwarf2Data, &offset))) {
-      const dw_offset_t next_cu_offset = cu->GetNextCompileUnitOffset();
+    while ((cu = DWARFCompileUnit::Extract(dwarf2Data, &file_offset))) {
+      const dw_offset_t next_cu_file_offset =
+          cu->GetNextCompileUnitFileOffset();
 
       depth = 0;
       // Call the callback function with no DIE pointer for the compile unit
-      // and get the offset that we are to continue to parse from
-      offset = callback(dwarf2Data, cu.get(), NULL, offset, depth, userData);
+      // and get the file_offset that we are to continue to parse from
+      file_offset =
+          callback(dwarf2Data, cu.get(), NULL, file_offset, depth, userData);
 
       // Make sure we are within our compile unit
-      if (offset < next_cu_offset) {
-        // We are in our compile unit, parse starting at the offset
+      if (file_offset < next_cu_file_offset) {
+        // We are in our compile unit, parse starting at the file_offset
         // we were told to parse
         bool done = false;
-        while (!done && die.Extract(dwarf2Data, cu.get(), &offset)) {
+        while (!done && die.Extract(dwarf2Data, cu.get(), &file_offset)) {
           // Call the callback function with DIE pointer that falls within the
           // compile unit
-          offset =
-              callback(dwarf2Data, cu.get(), &die, offset, depth, userData);
+          file_offset = callback(
+              dwarf2Data, cu.get(), &die, file_offset, depth, userData);
+
+          // Missing DWZ support: DW_TAG_imported_unit
 
           if (die.IsNULL()) {
             if (depth)
               --depth;
             else
               done = true; // We are done with this compile unit!
           } else if (die.HasChildren())
             ++depth;
         }
       }
 
-      // Make sure the offset returned is valid, and if not stop parsing.
+      // Make sure the file_offset returned is valid, and if not stop parsing.
       // Returning DW_INVALID_OFFSET from this callback is a good way to end
       // all parsing
-      if (!dwarf2Data->get_debug_info_data().ValidOffset(offset))
+      if (!dwarf2Data->get_debug_info_data().ValidOffset(file_offset))
         break;
 
       // Make sure we start on a proper
-      offset = next_cu_offset;
+      file_offset = next_cu_file_offset;
     }
   }
 }
 
 typedef struct DumpInfo {
   DumpInfo(Stream *init_strm, uint32_t off, uint32_t depth)
-      : strm(init_strm), die_offset(off), recurse_depth(depth),
+      : strm(init_strm), die_file_offset(off), recurse_depth(depth),
         found_depth(UINT32_MAX), found_die(false), ancestors() {}
   Stream *strm;
-  const uint32_t die_offset;
+  const uint32_t die_file_offset;
   const uint32_t recurse_depth;
   uint32_t found_depth;
   bool found_die;
   std::vector<DWARFDebugInfoEntry> ancestors;
 
   DISALLOW_COPY_AND_ASSIGN(DumpInfo);
 } DumpInfo;
 
 //----------------------------------------------------------------------
 // DumpCallback
 //
 // A callback function for the static DWARFDebugInfo::Parse() function
 // that gets called each time a compile unit header or debug information
 // entry is successfully parsed.
 //
 // This function dump DWARF information and obey recurse depth and
 // whether a single DIE is to be dumped (or all of the data).
 //----------------------------------------------------------------------
 static dw_offset_t DumpCallback(SymbolFileDWARF *dwarf2Data,
                                 DWARFUnit *cu, DWARFDebugInfoEntry *die,
-                                const dw_offset_t next_offset,
+                                const dw_offset_t next_file_offset,
                                 const uint32_t curr_depth, void *userData) {
   DumpInfo *dumpInfo = (DumpInfo *)userData;
   Stream *s = dumpInfo->strm;
   bool show_parents =
       s->GetFlags().Test(DWARFDebugInfo::eDumpFlag_ShowAncestors);
 
   if (die) {
     // Are we dumping everything?
-    if (dumpInfo->die_offset == DW_INVALID_OFFSET) {
+    if (dumpInfo->die_file_offset == DW_INVALID_OFFSET) {
       // Yes we are dumping everything. Obey our recurse level though
       if (curr_depth < dumpInfo->recurse_depth)
         die->Dump(dwarf2Data, cu, *s, 0);
     } else {
       // We are dumping a specific DIE entry by offset
-      if (dumpInfo->die_offset == die->GetOffset()) {
+      if (dumpInfo->die_file_offset == die->GetFileOffset()) {
         // We found the DIE we were looking for, dump it!
         if (show_parents) {
           s->SetIndentLevel(0);
           const uint32_t num_ancestors = dumpInfo->ancestors.size();
           if (num_ancestors > 0) {
             for (uint32_t i = 0; i < num_ancestors - 1; ++i) {
               dumpInfo->ancestors[i].Dump(dwarf2Data, cu, *s, 0);
               s->IndentMore();
if (dumpInfo->die_file_offset == DW_INVALID_OFFSET) {
           return DW_INVALID_OFFSET;
 
         // We have already found our DIE and are printing it's children. Obey
         // our recurse depth and return an invalid offset if we get done
         // dumping all of the children
         if (dumpInfo->recurse_depth == UINT32_MAX ||
             curr_depth <= dumpInfo->found_depth + dumpInfo->recurse_depth)
           die->Dump(dwarf2Data, cu, *s, 0);
-      } else if (dumpInfo->die_offset > die->GetOffset()) {
+      } else if (dumpInfo->die_file_offset > die->GetFileOffset()) {
         if (show_parents)
           dumpInfo->ancestors.back() = *die;
       }
     }
 
     // Keep up with our indent level
     if (die->IsNULL()) {
       if (show_parents)
if (die) {
     }
   } else {
     if (cu == NULL)
       s->PutCString("NULL - cu");
     // We have a compile unit, reset our indent level to zero just in case
     s->SetIndentLevel(0);
 
     // See if we are dumping everything?
-    if (dumpInfo->die_offset == DW_INVALID_OFFSET) {
+    if (dumpInfo->die_file_offset == DW_INVALID_OFFSET) {
       // We are dumping everything
       if (cu) {
         cu->Dump(s);
         return cu->GetFirstDIEOffset(); // Return true to parse all DIEs in this
                                         // Compile Unit
       } else {
         return DW_INVALID_OFFSET;
       }
     } else {
       if (show_parents) {
         dumpInfo->ancestors.clear();
         dumpInfo->ancestors.resize(1);
       }
 
       // We are dumping only a single DIE possibly with it's children and
       // we must find it's compile unit before we can dump it properly
-      if (cu && dumpInfo->die_offset < cu->GetFirstDIEOffset()) {
+      if (cu && dumpInfo->die_file_offset
+          < cu->ThisCUUniqToFileOffset(cu->GetFirstDIEOffset())) {
         // Not found, maybe the DIE offset provided wasn't correct?
         //  *ostrm_ptr << "DIE at offset " << HEX32 << dumpInfo->die_offset << "
         //  was not found." << endl;
         return DW_INVALID_OFFSET;
       } else {
         // See if the DIE is in this compile unit?
-        if (cu && dumpInfo->die_offset < cu->GetNextCompileUnitOffset()) {
-          return next_offset;
+        if (cu && dumpInfo->die_file_offset
+            < cu->GetNextCompileUnitFileOffset()) {
+          return next_file_offset;
           //  // We found our compile unit that contains our DIE, just skip to
           //  dumping the requested DIE...
           //  return dumpInfo->die_offset;
         } else {
           // Skip to the next compile unit as the DIE isn't in the current one!
           if (cu) {
             return cu->GetNextCompileUnitOffset();
           } else {
             return DW_INVALID_OFFSET;
           }
         }
       }
     }
   }
 
   // Just return the current offset to parse the next CU or DIE entry
-  return next_offset;
+  return next_file_offset;
 }
 
 //----------------------------------------------------------------------
 // Dump
 //
 // Dump the information in the .debug_info section to the specified
 // ostream. If die_offset is valid, a single DIE will be dumped. If the
 // die_offset is invalid, all the DWARF information will be dumped. Both

source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.h

public:
   typedef collection::iterator iterator;
   typedef collection::const_iterator const_iterator;
 
   typedef std::vector<dw_offset_t> offset_collection;
   typedef offset_collection::iterator offset_collection_iterator;
   typedef offset_collection::const_iterator offset_collection_const_iterator;
 
   DWARFDebugInfoEntry()
-      : m_offset(DW_INVALID_OFFSET), m_parent_idx(0), m_sibling_idx(0),
+      : m_file_offset(DW_INVALID_OFFSET), m_parent_idx(0), m_sibling_idx(0),
         m_empty_children(false), m_abbr_idx(0), m_has_children(false),
         m_tag(0) {}
 
   void BuildAddressRangeTable(SymbolFileDWARF *dwarf2Data,
                               const DWARFUnit *cu,
                               DWARFDebugAranges *debug_aranges) const;
 
   void BuildFunctionAddressRangeTable(SymbolFileDWARF *dwarf2Data,
                                       const DWARFUnit *cu,
                                       DWARFDebugAranges *debug_aranges) const;
 
   bool FastExtract(const lldb_private::DWARFDataExtractor &debug_info_data,
                    const DWARFUnit *cu,
                    const DWARFFormValue::FixedFormSizes &fixed_form_sizes,
-                   lldb::offset_t *offset_ptr);
+                   lldb::offset_t *file_offset_ptr);
 
   bool Extract(SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
-               lldb::offset_t *offset_ptr);
+               lldb::offset_t *file_offset_ptr);
 
   bool LookupAddress(const dw_addr_t address, SymbolFileDWARF *dwarf2Data,
                      const DWARFUnit *cu,
                      DWARFDebugInfoEntry **function_die,
                      DWARFDebugInfoEntry **block_die);
 
   size_t GetAttributes(const DWARFUnit *cu,
                        DWARFFormValue::FixedFormSizes fixed_form_sizes,
public:
 
   void DumpAncestry(SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
                     const DWARFDebugInfoEntry *oldest, lldb_private::Stream &s,
                     uint32_t recurse_depth) const;
 
   static void
   DumpAttribute(SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
                 const lldb_private::DWARFDataExtractor &debug_info_data,
-                lldb::offset_t *offset_ptr, lldb_private::Stream &s,
+                lldb::offset_t *file_offset_ptr, lldb_private::Stream &s,
                 dw_attr_t attr, dw_form_t form);
   // This one dumps the comp unit name, objfile name and die offset for this die
   // so the stream S.
   void DumpLocation(SymbolFileDWARF *dwarf2Data, DWARFUnit *cu,
                     lldb_private::Stream &s) const;
 
   bool
   GetDIENamesAndRanges(SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
                        const char *&name, const char *&mangled,
                        DWARFRangeList &rangeList, int &decl_file,
                        int &decl_line, int &decl_column, int &call_file,
                        int &call_line, int &call_column,
                        lldb_private::DWARFExpression *frame_base = NULL) const;
 
   const DWARFAbbreviationDeclaration *
   GetAbbreviationDeclarationPtr(SymbolFileDWARF *dwarf2Data,
                                 const DWARFUnit *cu,
-                                lldb::offset_t &offset) const;
+                                lldb::offset_t &file_offset) const;
 
   dw_tag_t Tag() const { return m_tag; }
 
   bool IsNULL() const { return m_abbr_idx == 0; }
 
-  dw_offset_t GetOffset() const { return m_offset; }
+  dw_offset_t GetFileOffset() const { return m_file_offset; }
+
+  dw_offset_t GetOffset(const DWARFUnit *cu) const;
 
   bool HasChildren() const { return m_has_children; }
 
   void SetHasChildren(bool b) { m_has_children = b; }
 
   // We know we are kept in a vector of contiguous entries, so we know
   // our parent will be some index behind "this".
   DWARFDebugInfoEntry *GetParent() {
public:
   void SetEmptyChildren(bool b) { m_empty_children = b; }
 
   static void
   DumpDIECollection(lldb_private::Stream &strm,
                     DWARFDebugInfoEntry::collection &die_collection);
 
 protected:
   dw_offset_t
-      m_offset; // Offset within the .debug_info of the start of this entry
+      m_file_offset; // Offset within the .debug_info of the start of this entry
   uint32_t m_parent_idx; // How many to subtract from "this" to get the parent.
                          // If zero this die has no parent
   uint32_t m_sibling_idx : 31, // How many to add to "this" to get the sibling.
       m_empty_children : 1;    // If a DIE says it had children, yet it just
                                // contained a NULL tag, this will be set.
   uint32_t m_abbr_idx : DIE_ABBR_IDX_BITSIZE,
                         m_has_children : 1, // Set to 1 if this DIE has children
                         m_tag : 16; // A copy of the DW_TAG value so we don't
                                     // have to go through the compile unit
                                     // abbrev table
 };
 
 #endif // SymbolFileDWARF_DWARFDebugInfoEntry_h_

source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp

 
 using namespace lldb_private;
 using namespace std;
 extern int g_verbose;
 
 bool DWARFDebugInfoEntry::FastExtract(
     const DWARFDataExtractor &debug_info_data, const DWARFUnit *cu,
     const DWARFFormValue::FixedFormSizes &fixed_form_sizes,
-    lldb::offset_t *offset_ptr) {
-  m_offset = *offset_ptr;
+    lldb::offset_t *file_offset_ptr) {
+  m_file_offset = *file_offset_ptr;
   m_parent_idx = 0;
   m_sibling_idx = 0;
   m_empty_children = false;
-  const uint64_t abbr_idx = debug_info_data.GetULEB128(offset_ptr);
+  const uint64_t abbr_idx = debug_info_data.GetULEB128(file_offset_ptr);
   assert(abbr_idx < (1 << DIE_ABBR_IDX_BITSIZE));
   m_abbr_idx = abbr_idx;
 
   // assert (fixed_form_sizes);  // For best performance this should be
   // specified!
 
   if (m_abbr_idx) {
-    lldb::offset_t offset = *offset_ptr;
+    lldb::offset_t file_offset = *file_offset_ptr;
 
     const DWARFAbbreviationDeclaration *abbrevDecl =
         cu->GetAbbreviations()->GetAbbreviationDeclaration(m_abbr_idx);
 
     if (abbrevDecl == NULL) {
       cu->GetSymbolFileDWARF()->GetObjectFile()->GetModule()->ReportError(
           "{0x%8.8x}: invalid abbreviation code %u, please file a bug and "
           "attach the file at the start of this error message",
-          m_offset, (unsigned)abbr_idx);
+          m_file_offset, (unsigned)abbr_idx);
       // WE can't parse anymore if the DWARF is borked...
-      *offset_ptr = UINT32_MAX;
+      *file_offset_ptr = UINT32_MAX;
       return false;
     }
     m_tag = abbrevDecl->Tag();
     m_has_children = abbrevDecl->HasChildren();
     // Skip all data in the .debug_info for the attributes
     const uint32_t numAttributes = abbrevDecl->NumAttributes();
     uint32_t i;
     dw_form_t form;
     for (i = 0; i < numAttributes; ++i) {
       form = abbrevDecl->GetFormByIndexUnchecked(i);
 
       const uint8_t fixed_skip_size = fixed_form_sizes.GetSize(form);
       if (fixed_skip_size)
-        offset += fixed_skip_size;
+        file_offset += fixed_skip_size;
       else {
         bool form_is_indirect = false;
         do {
           form_is_indirect = false;
           uint32_t form_size = 0;
           switch (form) {
           // Blocks if inlined data that have a length field and the data bytes
           // inlined in the .debug_info
           case DW_FORM_exprloc:
           case DW_FORM_block:
-            form_size = debug_info_data.GetULEB128(&offset);
+            form_size = debug_info_data.GetULEB128(&file_offset);
             break;
           case DW_FORM_block1:
-            form_size = debug_info_data.GetU8_unchecked(&offset);
+            form_size = debug_info_data.GetU8_unchecked(&file_offset);
             break;
           case DW_FORM_block2:
-            form_size = debug_info_data.GetU16_unchecked(&offset);
+            form_size = debug_info_data.GetU16_unchecked(&file_offset);
             break;
           case DW_FORM_block4:
-            form_size = debug_info_data.GetU32_unchecked(&offset);
+            form_size = debug_info_data.GetU32_unchecked(&file_offset);
             break;
 
           // Inlined NULL terminated C-strings
           case DW_FORM_string:
-            debug_info_data.GetCStr(&offset);
+            debug_info_data.GetCStr(&file_offset);
             break;
 
           // Compile unit address sized values
           case DW_FORM_addr:
             form_size = cu->GetAddressByteSize();
             break;
           case DW_FORM_ref_addr:
             if (cu->GetVersion() <= 2)
for (i = 0; i < numAttributes; ++i) {
             break;
 
           // signed or unsigned LEB 128 values
           case DW_FORM_sdata:
           case DW_FORM_udata:
           case DW_FORM_ref_udata:
           case DW_FORM_GNU_addr_index:
           case DW_FORM_GNU_str_index:
-            debug_info_data.Skip_LEB128(&offset);
+            debug_info_data.Skip_LEB128(&file_offset);
             break;
 
           case DW_FORM_indirect:
             form_is_indirect = true;
-            form = debug_info_data.GetULEB128(&offset);
+            form = debug_info_data.GetULEB128(&file_offset);
             break;
 
           case DW_FORM_strp:
           case DW_FORM_sec_offset:
             if (cu->IsDWARF64())
-              debug_info_data.GetU64(&offset);
+              debug_info_data.GetU64(&file_offset);
             else
-              debug_info_data.GetU32(&offset);
+              debug_info_data.GetU32(&file_offset);
             break;
 
           default:
-            *offset_ptr = m_offset;
+            *file_offset_ptr = m_file_offset;
             return false;
           }
-          offset += form_size;
+          file_offset += form_size;
 
         } while (form_is_indirect);
       }
     }
-    *offset_ptr = offset;
+    *file_offset_ptr = file_offset;
     return true;
   } else {
     m_tag = 0;
     m_has_children = false;
     return true; // NULL debug tag entry
   }
 
   return false;
 }
 
 //----------------------------------------------------------------------
 // Extract
 //
 // Extract a debug info entry for a given compile unit from the
 // .debug_info and .debug_abbrev data within the SymbolFileDWARF class
 // starting at the given offset
 //----------------------------------------------------------------------
 bool DWARFDebugInfoEntry::Extract(SymbolFileDWARF *dwarf2Data,
                                   const DWARFUnit *cu,
-                                  lldb::offset_t *offset_ptr) {
+                                  lldb::offset_t *file_offset_ptr) {
   const DWARFDataExtractor &debug_info_data = dwarf2Data->get_debug_info_data();
   //    const DWARFDataExtractor& debug_str_data =
   //    dwarf2Data->get_debug_str_data();
   const uint32_t cu_end_offset = cu->GetNextCompileUnitOffset();
-  lldb::offset_t offset = *offset_ptr;
-  //  if (offset >= cu_end_offset)
+  lldb::offset_t file_offset = *file_offset_ptr;
+  //  if (cu->ThisCUFileOffsetToUniq(file_offset) >= cu_end_offset)
   //      Log::Status("DIE at offset 0x%8.8x is beyond the end of the current
   //      compile unit (0x%8.8x)", m_offset, cu_end_offset);
-  if ((offset < cu_end_offset) && debug_info_data.ValidOffset(offset)) {
-    m_offset = offset;
+  if ((cu->ThisCUFileOffsetToUniq(file_offset) < cu_end_offset)
+      && debug_info_data.ValidOffset(file_offset)) {
+    m_file_offset = file_offset;
 
-    const uint64_t abbr_idx = debug_info_data.GetULEB128(&offset);
+    const uint64_t abbr_idx = debug_info_data.GetULEB128(&file_offset);
     assert(abbr_idx < (1 << DIE_ABBR_IDX_BITSIZE));
     m_abbr_idx = abbr_idx;
     if (abbr_idx) {
       const DWARFAbbreviationDeclaration *abbrevDecl =
           cu->GetAbbreviations()->GetAbbreviationDeclaration(abbr_idx);
 
       if (abbrevDecl) {
         m_tag = abbrevDecl->Tag();
if (abbr_idx) {
         dw_attr_t attr;
         dw_form_t form;
         for (i = 0; i < numAttributes; ++i) {
           abbrevDecl->GetAttrAndFormByIndexUnchecked(i, attr, form);
 
           if (isCompileUnitTag &&
               ((attr == DW_AT_entry_pc) || (attr == DW_AT_low_pc))) {
             DWARFFormValue form_value(cu, form);
-            if (form_value.ExtractValue(debug_info_data, &offset)) {
+            if (form_value.ExtractValue(debug_info_data, &file_offset)) {
               if (attr == DW_AT_low_pc || attr == DW_AT_entry_pc)
                 const_cast<DWARFUnit *>(cu)->SetBaseAddress(
                     form_value.Address());
             }
           } else {
             bool form_is_indirect = false;
             do {
               form_is_indirect = false;
               uint32_t form_size = 0;
               switch (form) {
               // Blocks if inlined data that have a length field and the data
               // bytes
               // inlined in the .debug_info
               case DW_FORM_exprloc:
               case DW_FORM_block:
-                form_size = debug_info_data.GetULEB128(&offset);
+                form_size = debug_info_data.GetULEB128(&file_offset);
                 break;
               case DW_FORM_block1:
-                form_size = debug_info_data.GetU8(&offset);
+                form_size = debug_info_data.GetU8(&file_offset);
                 break;
               case DW_FORM_block2:
-                form_size = debug_info_data.GetU16(&offset);
+                form_size = debug_info_data.GetU16(&file_offset);
                 break;
               case DW_FORM_block4:
-                form_size = debug_info_data.GetU32(&offset);
+                form_size = debug_info_data.GetU32(&file_offset);
                 break;
 
               // Inlined NULL terminated C-strings
               case DW_FORM_string:
-                debug_info_data.GetCStr(&offset);
+                debug_info_data.GetCStr(&file_offset);
                 break;
 
               // Compile unit address sized values
               case DW_FORM_addr:
                 form_size = cu->GetAddressByteSize();
                 break;
               case DW_FORM_ref_addr:
                 if (cu->GetVersion() <= 2)
if (abbr_idx) {
                 break;
 
               // signed or unsigned LEB 128 values
               case DW_FORM_sdata:
               case DW_FORM_udata:
               case DW_FORM_ref_udata:
               case DW_FORM_GNU_addr_index:
               case DW_FORM_GNU_str_index:
-                debug_info_data.Skip_LEB128(&offset);
+                debug_info_data.Skip_LEB128(&file_offset);
                 break;
 
               case DW_FORM_indirect:
-                form = debug_info_data.GetULEB128(&offset);
+                form = debug_info_data.GetULEB128(&file_offset);
                 form_is_indirect = true;
                 break;
 
               case DW_FORM_strp:
               case DW_FORM_sec_offset:
                 if (cu->IsDWARF64())
-                  debug_info_data.GetU64(&offset);
+                  debug_info_data.GetU64(&file_offset);
                 else
-                  debug_info_data.GetU32(&offset);
+                  debug_info_data.GetU32(&file_offset);
                 break;
 
               default:
-                *offset_ptr = offset;
+                *file_offset_ptr = file_offset;
                 return false;
               }
 
-              offset += form_size;
+              file_offset += form_size;
             } while (form_is_indirect);
           }
         }
-        *offset_ptr = offset;
+        *file_offset_ptr = file_offset;
         return true;
       }
     } else {
       m_tag = 0;
       m_has_children = false;
-      *offset_ptr = offset;
+      *file_offset_ptr = file_offset;
       return true; // NULL debug tag entry
     }
   }
 
   return false;
 }
 
 //----------------------------------------------------------------------
return GetDIENamesAndRanges(
         ranges, decl_file, decl_line, decl_column, call_file, call_line,
         call_column, frame_base);
 
   dw_addr_t lo_pc = LLDB_INVALID_ADDRESS;
   dw_addr_t hi_pc = LLDB_INVALID_ADDRESS;
   std::vector<DIERef> die_refs;
   bool set_frame_base_loclist_addr = false;
 
-  lldb::offset_t offset;
+  lldb::offset_t file_offset;
   const DWARFAbbreviationDeclaration *abbrevDecl =
-      GetAbbreviationDeclarationPtr(dwarf2Data, cu, offset);
+      GetAbbreviationDeclarationPtr(dwarf2Data, cu, file_offset);
 
   lldb::ModuleSP module = dwarf2Data->GetObjectFile()->GetModule();
 
   if (abbrevDecl) {
     const DWARFDataExtractor &debug_info_data =
         dwarf2Data->get_debug_info_data();
 
-    if (!debug_info_data.ValidOffset(offset))
+    if (!debug_info_data.ValidOffset(file_offset))
       return false;
 
     const uint32_t numAttributes = abbrevDecl->NumAttributes();
     uint32_t i;
     dw_attr_t attr;
     dw_form_t form;
     bool do_offset = false;
 
     for (i = 0; i < numAttributes; ++i) {
       abbrevDecl->GetAttrAndFormByIndexUnchecked(i, attr, form);
       DWARFFormValue form_value(cu, form);
-      if (form_value.ExtractValue(debug_info_data, &offset)) {
+      if (form_value.ExtractValue(debug_info_data, &file_offset)) {
         switch (attr) {
         case DW_AT_low_pc:
           lo_pc = form_value.Address();
 
           if (do_offset)
             hi_pc += lo_pc;
           do_offset = false;
           break;
for (i = 0; i < numAttributes; ++i) {
             // compile unit. We add the compile unit base address to make
             // sure all the addresses are properly fixed up.
             ranges.Slide(cu->GetBaseAddress());
           } else {
             cu->GetSymbolFileDWARF()->GetObjectFile()->GetModule()->ReportError(
                 "{0x%8.8x}: DIE has DW_AT_ranges(0x%" PRIx64
                 ") attribute yet DWARF has no .debug_ranges, please file a bug "
                 "and attach the file at the start of this error message",
-                m_offset, form_value.Unsigned());
+                m_file_offset, form_value.Unsigned());
           }
         } break;
 
         case DW_AT_name:
           if (name == NULL)
             name = form_value.AsCString();
           break;
 

 //
 // Dumps a debug information entry and all of it's attributes to the
 // specified stream.
 //----------------------------------------------------------------------
 void DWARFDebugInfoEntry::Dump(SymbolFileDWARF *dwarf2Data,
                                const DWARFUnit *cu, Stream &s,
                                uint32_t recurse_depth) const {
   const DWARFDataExtractor &debug_info_data = dwarf2Data->get_debug_info_data();
-  lldb::offset_t offset = m_offset;
+  lldb::offset_t file_offset = m_file_offset;
 
-  if (debug_info_data.ValidOffset(offset)) {
-    dw_uleb128_t abbrCode = debug_info_data.GetULEB128(&offset);
+  if (debug_info_data.ValidOffset(file_offset)) {
+    dw_uleb128_t abbrCode = debug_info_data.GetULEB128(&file_offset);
 
-    s.Printf("\n0x%8.8x: ", m_offset);
+    s.Printf("\n0x%8.8x: ", m_file_offset);
     s.Indent();
     if (abbrCode != m_abbr_idx) {
       s.Printf("error: DWARF has been modified\n");
     } else if (abbrCode) {
       const DWARFAbbreviationDeclaration *abbrevDecl =
           cu->GetAbbreviations()->GetAbbreviationDeclaration(abbrCode);
 
       if (abbrevDecl) {
         s.PutCString(DW_TAG_value_to_name(abbrevDecl->Tag()));
         s.Printf(" [%u] %c\n", abbrCode, abbrevDecl->HasChildren() ? '*' : ' ');
 
         // Dump all data in the .debug_info for the attributes
         const uint32_t numAttributes = abbrevDecl->NumAttributes();
         uint32_t i;
         dw_attr_t attr;
         dw_form_t form;
         for (i = 0; i < numAttributes; ++i) {
           abbrevDecl->GetAttrAndFormByIndexUnchecked(i, attr, form);
 
-          DumpAttribute(dwarf2Data, cu, debug_info_data, &offset, s, attr,
+          DumpAttribute(dwarf2Data, cu, debug_info_data, &file_offset, s, attr,
                         form);
         }
 
         const DWARFDebugInfoEntry *child = GetFirstChild();
         if (recurse_depth > 0 && child) {
           s.IndentMore();
 
           while (child) {
if (cu_die)
     cu_name = cu_die.GetName();
   const char *obj_file_name = NULL;
   ObjectFile *obj_file = dwarf2Data->GetObjectFile();
   if (obj_file)
     obj_file_name =
         obj_file->GetFileSpec().GetFilename().AsCString("<Unknown>");
   const char *die_name = GetName(dwarf2Data, cu);
   s.Printf("0x%8.8x/0x%8.8x: %-30s (from %s in %s)", cu->GetOffset(),
-           GetOffset(), die_name ? die_name : "", cu_name ? cu_name : "<NULL>",
+           GetFileOffset(), die_name ? die_name : "",
+           cu_name ? cu_name : "<NULL>",
            obj_file_name ? obj_file_name : "<NULL>");
 }
 
 //----------------------------------------------------------------------
 // DumpAttribute
 //
 // Dumps a debug information entry attribute along with it's form. Any
 // special display of attributes is done (disassemble location lists,
 // show enumeration values for attributes, etc).
 //----------------------------------------------------------------------
 void DWARFDebugInfoEntry::DumpAttribute(
     SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
-    const DWARFDataExtractor &debug_info_data, lldb::offset_t *offset_ptr,
+    const DWARFDataExtractor &debug_info_data, lldb::offset_t *file_offset_ptr,
     Stream &s, dw_attr_t attr, dw_form_t form) {
   bool show_form = s.GetFlags().Test(DWARFDebugInfo::eDumpFlag_ShowForm);
 
   s.Printf("            ");
   s.Indent(DW_AT_value_to_name(attr));
 
   if (show_form) {
     s.Printf("[%s", DW_FORM_value_to_name(form));
   }
 
   DWARFFormValue form_value(cu, form);
 
-  if (!form_value.ExtractValue(debug_info_data, offset_ptr))
+  if (!form_value.ExtractValue(debug_info_data, file_offset_ptr))
     return;
 
   if (show_form) {
     if (form == DW_FORM_indirect) {
       s.Printf(" [%s]", DW_FORM_value_to_name(form_value.Form()));
     }
 
     s.PutCString("] ");
case DW_AT_encoding:
     break;
 
   case DW_AT_frame_base:
   case DW_AT_location:
   case DW_AT_data_member_location: {
     const uint8_t *blockData = form_value.BlockData();
     if (blockData) {
       // Location description is inlined in data in the form value
-      DWARFDataExtractor locationData(debug_info_data,
-                                      (*offset_ptr) - form_value.Unsigned(),
-                                      form_value.Unsigned());
+      DWARFDataExtractor locationData(
+          debug_info_data, (*file_offset_ptr) - form_value.Unsigned(),
       DWARFExpression::PrintDWARFExpression(
           s, locationData, DWARFUnit::GetAddressByteSize(cu), 4, false);
     } else {
       // We have a location list offset as the value that is
       // the offset into the .debug_loc section that describes
       // the value over it's lifetime
       uint64_t debug_loc_offset = form_value.Unsigned();
       if (dwarf2Data) {

 // the results. Any duplicate attributes will have the first instance
 // take precedence (this can happen for declaration attributes).
 //----------------------------------------------------------------------
 size_t DWARFDebugInfoEntry::GetAttributes(
     const DWARFUnit *cu, DWARFFormValue::FixedFormSizes fixed_form_sizes,
     DWARFAttributes &attributes, uint32_t curr_depth) const {
   SymbolFileDWARF *dwarf2Data = nullptr;
   const DWARFAbbreviationDeclaration *abbrevDecl = nullptr;
-  lldb::offset_t offset = 0;
+  lldb::offset_t file_offset = 0;
   if (cu) {
     if (m_tag != DW_TAG_compile_unit) {
       SymbolFileDWARFDwo *dwo_symbol_file = cu->GetDwoSymbolFile();
       if (dwo_symbol_file)
         return GetAttributes(dwo_symbol_file->GetCompileUnit(),
                              fixed_form_sizes, attributes, curr_depth);
     }
 
     dwarf2Data = cu->GetSymbolFileDWARF();
-    abbrevDecl = GetAbbreviationDeclarationPtr(dwarf2Data, cu, offset);
+    abbrevDecl = GetAbbreviationDeclarationPtr(dwarf2Data, cu, file_offset);
   }
 
   if (abbrevDecl) {
     const DWARFDataExtractor &debug_info_data =
         dwarf2Data->get_debug_info_data();
 
     if (fixed_form_sizes.Empty())
       fixed_form_sizes = DWARFFormValue::GetFixedFormSizesForAddressSize(
for (i = 0; i < num_attributes; ++i) {
         if (curr_depth > 0) {
           // This attribute doesn't make sense when combined with
           // the DIE that references this DIE. We know a DIE is
           // referencing this DIE because curr_depth is not zero
           break;
         }
         LLVM_FALLTHROUGH;
       default:
-        attributes.Append(cu, offset, attr, form);
+        attributes.Append(
+            cu, cu->ThisCUFileOffsetToUniq(file_offset), attr, form);
         break;
       }
 
       if ((attr == DW_AT_specification) || (attr == DW_AT_abstract_origin)) {
         DWARFFormValue form_value(cu, form);
-        if (form_value.ExtractValue(debug_info_data, &offset)) {
+        if (form_value.ExtractValue(debug_info_data, &file_offset)) {
           dw_offset_t die_offset = form_value.Reference();
           DWARFDIE spec_die =
               const_cast<DWARFUnit *>(cu)->GetDIE(die_offset);
           if (spec_die)
             spec_die.GetAttributes(attributes, curr_depth + 1);
         }
       } else {
         const uint8_t fixed_skip_size = fixed_form_sizes.GetSize(form);
         if (fixed_skip_size)
-          offset += fixed_skip_size;
+          file_offset += fixed_skip_size;
         else
-          DWARFFormValue::SkipValue(form, debug_info_data, &offset, cu);
+          DWARFFormValue::SkipValue(form, debug_info_data, &file_offset, cu);
       }
     }
   } else {
     attributes.Clear();
   }
   return attributes.Size();
 }
 
dw_offset_t DWARFDebugInfoEntry::GetAttributeValue(
     dw_offset_t *end_attr_offset_ptr,
     bool check_specification_or_abstract_origin) const {
   SymbolFileDWARFDwo *dwo_symbol_file = cu->GetDwoSymbolFile();
   if (dwo_symbol_file && m_tag != DW_TAG_compile_unit)
     return GetAttributeValue(dwo_symbol_file, dwo_symbol_file->GetCompileUnit(),
                              attr, form_value, end_attr_offset_ptr,
                              check_specification_or_abstract_origin);
 
-  lldb::offset_t offset;
+  lldb::offset_t file_offset;
   const DWARFAbbreviationDeclaration *abbrevDecl =
-      GetAbbreviationDeclarationPtr(dwarf2Data, cu, offset);
+      GetAbbreviationDeclarationPtr(dwarf2Data, cu, file_offset);
 
   if (abbrevDecl) {
     uint32_t attr_idx = abbrevDecl->FindAttributeIndex(attr);
 
     if (attr_idx != DW_INVALID_INDEX) {
       const DWARFDataExtractor &debug_info_data =
           dwarf2Data->get_debug_info_data();
 
       uint32_t idx = 0;
       while (idx < attr_idx)
         DWARFFormValue::SkipValue(abbrevDecl->GetFormByIndex(idx++),
-                                  debug_info_data, &offset, cu);
+                                  debug_info_data, &file_offset, cu);
 
-      const dw_offset_t attr_offset = offset;
+      const dw_offset_t attr_offset = file_offset;
       form_value.SetCompileUnit(cu);
       form_value.SetForm(abbrevDecl->GetFormByIndex(idx));
-      if (form_value.ExtractValue(debug_info_data, &offset)) {
+      if (form_value.ExtractValue(debug_info_data, &file_offset)) {
         if (end_attr_offset_ptr)
-          *end_attr_offset_ptr = offset;
+          *end_attr_offset_ptr = file_offset;
         return attr_offset;
       }
     }
   }
 
   if (check_specification_or_abstract_origin) {
     if (GetAttributeValue(dwarf2Data, cu, DW_AT_specification, form_value)) {
       DWARFDIE die =
bool DWARFDebugInfoEntry::AppendTypeName(SymbolFileDWARF *dwarf2Data,
                                          const dw_offset_t die_offset,
                                          Stream &s) {
   if (dwarf2Data == NULL) {
     s.PutCString("NULL");
     return false;
   }
 
   DWARFDebugInfoEntry die;
-  lldb::offset_t offset = die_offset;
-  if (die.Extract(dwarf2Data, cu, &offset)) {
+  lldb::offset_t file_offset = cu->ThisCUUniqToFileOffset(die_offset);
+  if (die.Extract(dwarf2Data, cu, &file_offset)) {
     if (die.IsNULL()) {
       s.PutCString("NULL");
       return true;
     } else {
       const char *name = die.GetPubname(dwarf2Data, cu);
       if (name)
         s.PutCString(name);
       else {
         bool result = true;
         const DWARFAbbreviationDeclaration *abbrevDecl =
-            die.GetAbbreviationDeclarationPtr(dwarf2Data, cu, offset);
+            die.GetAbbreviationDeclarationPtr(dwarf2Data, cu, file_offset);
 
         if (abbrevDecl == NULL)
           return false;
 
         switch (abbrevDecl->Tag()) {
         case DW_TAG_array_type:
           break; // print out a "[]" after printing the full type of the element
                  // below
void DWARFDebugInfoEntry::BuildFunctionAddressRangeTable(
   if (m_tag) {
     if (m_tag == DW_TAG_subprogram) {
       dw_addr_t lo_pc = LLDB_INVALID_ADDRESS;
       dw_addr_t hi_pc = LLDB_INVALID_ADDRESS;
       if (GetAttributeAddressRange(dwarf2Data, cu, lo_pc, hi_pc,
                                    LLDB_INVALID_ADDRESS)) {
         //  printf("BuildAddressRangeTable() 0x%8.8x: [0x%16.16" PRIx64 " -
         //  0x%16.16" PRIx64 ")\n", m_offset, lo_pc, hi_pc); // DEBUG ONLY
-        debug_aranges->AppendRange(GetOffset(), lo_pc, hi_pc);
+        debug_aranges->AppendRange(GetOffset(cu), lo_pc, hi_pc);
       }
     }
 
     const DWARFDebugInfoEntry *child = GetFirstChild();
     while (child) {
       child->BuildFunctionAddressRangeTable(dwarf2Data, cu, debug_aranges);
       child = child->GetSibling();
     }
if (m_tag) {
     }
   }
   return found_address;
 }
 
 const DWARFAbbreviationDeclaration *
 DWARFDebugInfoEntry::GetAbbreviationDeclarationPtr(
     SymbolFileDWARF *dwarf2Data, const DWARFUnit *cu,
-    lldb::offset_t &offset) const {
+    lldb::offset_t &file_offset) const {
   if (dwarf2Data) {
-    offset = GetOffset();
+    file_offset = GetFileOffset();
 
     const DWARFAbbreviationDeclarationSet *abbrev_set = cu->GetAbbreviations();
     if (abbrev_set) {
       const DWARFAbbreviationDeclaration *abbrev_decl =
           abbrev_set->GetAbbreviationDeclaration(m_abbr_idx);
       if (abbrev_decl) {
         // Make sure the abbreviation code still matches. If it doesn't and
         // the DWARF data was mmap'ed, the backing file might have been modified
         // which is bad news.
         const uint64_t abbrev_code =
-            dwarf2Data->get_debug_info_data().GetULEB128(&offset);
+            dwarf2Data->get_debug_info_data().GetULEB128(&file_offset);
 
         if (abbrev_decl->Code() == abbrev_code)
           return abbrev_decl;
 
         dwarf2Data->GetObjectFile()->GetModule()->ReportErrorIfModifyDetected(
             "0x%8.8x: the DWARF debug information has been modified (abbrev "
             "code was %u, and is now %u)",
-            GetOffset(), (uint32_t)abbrev_decl->Code(), (uint32_t)abbrev_code);
+            GetFileOffset(), (uint32_t)abbrev_decl->Code(),
+            (uint32_t)abbrev_code);
       }
     }
   }
-  offset = DW_INVALID_OFFSET;
+  file_offset = DW_INVALID_OFFSET;
   return NULL;
 }
 
 bool DWARFDebugInfoEntry::OffsetLessThan(const DWARFDebugInfoEntry &a,
                                          const DWARFDebugInfoEntry &b) {
-  return a.GetOffset() < b.GetOffset();
+  return a.GetFileOffset() < b.GetFileOffset();
 }
 
 void DWARFDebugInfoEntry::DumpDIECollection(
     Stream &strm, DWARFDebugInfoEntry::collection &die_collection) {
   DWARFDebugInfoEntry::const_iterator pos;
   DWARFDebugInfoEntry::const_iterator end = die_collection.end();
   strm.PutCString("\noffset    parent   sibling  child\n");
   strm.PutCString("--------  -------- -------- --------\n");
   for (pos = die_collection.begin(); pos != end; ++pos) {
     const DWARFDebugInfoEntry &die_ref = *pos;
     const DWARFDebugInfoEntry *p = die_ref.GetParent();
     const DWARFDebugInfoEntry *s = die_ref.GetSibling();
     const DWARFDebugInfoEntry *c = die_ref.GetFirstChild();
-    strm.Printf("%.8x: %.8x %.8x %.8x 0x%4.4x %s%s\n", die_ref.GetOffset(),
-                p ? p->GetOffset() : 0, s ? s->GetOffset() : 0,
-                c ? c->GetOffset() : 0, die_ref.Tag(),
+    strm.Printf("%.8x: %.8x %.8x %.8x 0x%4.4x %s%s\n", die_ref.GetFileOffset(),
+                p ? p->GetFileOffset() : 0, s ? s->GetFileOffset() : 0,
+                c ? c->GetFileOffset() : 0, die_ref.Tag(),
                 DW_TAG_value_to_name(die_ref.Tag()),
                 die_ref.HasChildren() ? " *" : "");
   }
 }
+
+dw_offset_t DWARFDebugInfoEntry::GetOffset(const DWARFUnit *cu) const {
+  return cu->ThisCUFileOffsetToUniq(m_file_offset);
+}

source/Plugins/SymbolFile/DWARF/DWARFFormValue.h

public:
   DWARFFormValue(const DWARFUnit *cu, dw_form_t form);
   const DWARFUnit *GetCompileUnit() const { return m_cu; }
   void SetCompileUnit(const DWARFUnit *cu) { m_cu = cu; }
   dw_form_t Form() const { return m_form; }
   void SetForm(dw_form_t form) { m_form = form; }
   const ValueType &Value() const { return m_value; }
   void Dump(lldb_private::Stream &s) const;
   bool ExtractValue(const lldb_private::DWARFDataExtractor &data,
-                    lldb::offset_t *offset_ptr);
+                    lldb::offset_t *file_offset_ptr);
   const uint8_t *BlockData() const;
+  uint64_t ReferenceInFile() const;
   uint64_t Reference() const;
   uint64_t Reference(dw_offset_t offset) const;
   bool Boolean() const { return m_value.value.uval != 0; }
   uint64_t Unsigned() const { return m_value.value.uval; }
   void SetUnsigned(uint64_t uval) { m_value.value.uval = uval; }
   int64_t Signed() const { return m_value.value.sval; }
   void SetSigned(int64_t sval) { m_value.value.sval = sval; }
   const char *AsCString() const;
   dw_addr_t Address() const;
   bool IsValid() const { return m_form != 0; }
   bool SkipValue(const lldb_private::DWARFDataExtractor &debug_info_data,
-                 lldb::offset_t *offset_ptr) const;
+                 lldb::offset_t *file_offset_ptr) const;
   static bool SkipValue(const dw_form_t form,
                         const lldb_private::DWARFDataExtractor &debug_info_data,
-                        lldb::offset_t *offset_ptr, const DWARFUnit *cu);
+                        lldb::offset_t *file_offset_ptr, const DWARFUnit *cu);
   static bool IsBlockForm(const dw_form_t form);
   static bool IsDataForm(const dw_form_t form);
   static FixedFormSizes GetFixedFormSizesForAddressSize(uint8_t addr_size,
                                                         bool is_dwarf64);
   static int Compare(const DWARFFormValue &a, const DWARFFormValue &b);
   void Clear();
   static bool FormIsSupported(dw_form_t form);
 
 protected:
   const DWARFUnit *m_cu;        // Compile unit for this form
   dw_form_t m_form;             // Form for this value
   ValueType m_value;            // Contains all data for the form
 };
 
 #endif // SymbolFileDWARF_DWARFFormValue_h_

source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp

 
 void DWARFFormValue::Clear() {
   m_cu = nullptr;
   m_form = 0;
   memset(&m_value, 0, sizeof(m_value));
 }
 
 bool DWARFFormValue::ExtractValue(const DWARFDataExtractor &data,
-                                  lldb::offset_t *offset_ptr) {
+                                  lldb::offset_t *file_offset_ptr) {
   bool indirect = false;
   bool is_block = false;
   m_value.data = NULL;
   uint8_t ref_addr_size;
   // Read the value for the form into value and follow and DW_FORM_indirect
   // instances we run into
   do {
     indirect = false;
     switch (m_form) {
     case DW_FORM_addr:
       assert(m_cu);
       m_value.value.uval = data.GetMaxU64(
-          offset_ptr, DWARFUnit::GetAddressByteSize(m_cu));
+          file_offset_ptr, DWARFUnit::GetAddressByteSize(m_cu));
       break;
     case DW_FORM_block2:
-      m_value.value.uval = data.GetU16(offset_ptr);
+      m_value.value.uval = data.GetU16(file_offset_ptr);
       is_block = true;
       break;
     case DW_FORM_block4:
-      m_value.value.uval = data.GetU32(offset_ptr);
+      m_value.value.uval = data.GetU32(file_offset_ptr);
       is_block = true;
       break;
     case DW_FORM_data2:
-      m_value.value.uval = data.GetU16(offset_ptr);
+      m_value.value.uval = data.GetU16(file_offset_ptr);
       break;
     case DW_FORM_data4:
-      m_value.value.uval = data.GetU32(offset_ptr);
+      m_value.value.uval = data.GetU32(file_offset_ptr);
       break;
     case DW_FORM_data8:
-      m_value.value.uval = data.GetU64(offset_ptr);
+      m_value.value.uval = data.GetU64(file_offset_ptr);
       break;
     case DW_FORM_string:
-      m_value.value.cstr = data.GetCStr(offset_ptr);
+      m_value.value.cstr = data.GetCStr(file_offset_ptr);
       break;
     case DW_FORM_exprloc:
     case DW_FORM_block:
-      m_value.value.uval = data.GetULEB128(offset_ptr);
+      m_value.value.uval = data.GetULEB128(file_offset_ptr);
       is_block = true;
       break;
     case DW_FORM_block1:
-      m_value.value.uval = data.GetU8(offset_ptr);
+      m_value.value.uval = data.GetU8(file_offset_ptr);
       is_block = true;
       break;
     case DW_FORM_data1:
-      m_value.value.uval = data.GetU8(offset_ptr);
+      m_value.value.uval = data.GetU8(file_offset_ptr);
       break;
     case DW_FORM_flag:
-      m_value.value.uval = data.GetU8(offset_ptr);
+      m_value.value.uval = data.GetU8(file_offset_ptr);
       break;
     case DW_FORM_sdata:
-      m_value.value.sval = data.GetSLEB128(offset_ptr);
+      m_value.value.sval = data.GetSLEB128(file_offset_ptr);
       break;
     case DW_FORM_strp:
       assert(m_cu);
       m_value.value.uval =
-          data.GetMaxU64(offset_ptr, DWARFUnit::IsDWARF64(m_cu) ? 8 : 4);
+          data.GetMaxU64(file_offset_ptr, DWARFUnit::IsDWARF64(m_cu) ? 8 : 4);
       break;
     //  case DW_FORM_APPLE_db_str:
     case DW_FORM_udata:
-      m_value.value.uval = data.GetULEB128(offset_ptr);
+      m_value.value.uval = data.GetULEB128(file_offset_ptr);
       break;
     case DW_FORM_ref_addr:
       assert(m_cu);
       ref_addr_size = 4;
       if (m_cu->GetVersion() <= 2)
         ref_addr_size = m_cu->GetAddressByteSize();
       else
         ref_addr_size = m_cu->IsDWARF64() ? 8 : 4;
-      m_value.value.uval = data.GetMaxU64(offset_ptr, ref_addr_size);
+      m_value.value.uval = data.GetMaxU64(file_offset_ptr, ref_addr_size);
       break;
     case DW_FORM_ref1:
-      m_value.value.uval = data.GetU8(offset_ptr);
+      m_value.value.uval = data.GetU8(file_offset_ptr);
       break;
     case DW_FORM_ref2:
-      m_value.value.uval = data.GetU16(offset_ptr);
+      m_value.value.uval = data.GetU16(file_offset_ptr);
       break;
     case DW_FORM_ref4:
-      m_value.value.uval = data.GetU32(offset_ptr);
+      m_value.value.uval = data.GetU32(file_offset_ptr);
       break;
     case DW_FORM_ref8:
-      m_value.value.uval = data.GetU64(offset_ptr);
+      m_value.value.uval = data.GetU64(file_offset_ptr);
       break;
     case DW_FORM_ref_udata:
-      m_value.value.uval = data.GetULEB128(offset_ptr);
+      m_value.value.uval = data.GetULEB128(file_offset_ptr);
       break;
     case DW_FORM_indirect:
-      m_form = data.GetULEB128(offset_ptr);
+      m_form = data.GetULEB128(file_offset_ptr);
       indirect = true;
       break;
 
     case DW_FORM_sec_offset:
       assert(m_cu);
       m_value.value.uval =
-          data.GetMaxU64(offset_ptr, DWARFUnit::IsDWARF64(m_cu) ? 8 : 4);
+          data.GetMaxU64(file_offset_ptr, DWARFUnit::IsDWARF64(m_cu) ? 8 : 4);
       break;
     case DW_FORM_flag_present:
       m_value.value.uval = 1;
       break;
     case DW_FORM_ref_sig8:
-      m_value.value.uval = data.GetU64(offset_ptr);
+      m_value.value.uval = data.GetU64(file_offset_ptr);
       break;
     case DW_FORM_GNU_str_index:
-      m_value.value.uval = data.GetULEB128(offset_ptr);
+      m_value.value.uval = data.GetULEB128(file_offset_ptr);
       break;
     case DW_FORM_GNU_addr_index:
-      m_value.value.uval = data.GetULEB128(offset_ptr);
+      m_value.value.uval = data.GetULEB128(file_offset_ptr);
       break;
     default:
       return false;
       break;
     }
   } while (indirect);
 
   if (is_block) {
-    m_value.data = data.PeekData(*offset_ptr, m_value.value.uval);
+    m_value.data = data.PeekData(*file_offset_ptr, m_value.value.uval);
     if (m_value.data != NULL) {
-      *offset_ptr += m_value.value.uval;
+      *file_offset_ptr += m_value.value.uval;
     }
   }
 
   return true;
 }
 
 bool DWARFFormValue::SkipValue(const DWARFDataExtractor &debug_info_data,
-                               lldb::offset_t *offset_ptr) const {
-  return DWARFFormValue::SkipValue(m_form, debug_info_data, offset_ptr, m_cu);
+                               lldb::offset_t *file_offset_ptr) const {
+  return DWARFFormValue::SkipValue(
+      m_form, debug_info_data, file_offset_ptr, m_cu);
 }
 
 bool DWARFFormValue::SkipValue(dw_form_t form,
                                const DWARFDataExtractor &debug_info_data,
-                               lldb::offset_t *offset_ptr,
+                               lldb::offset_t *file_offset_ptr,
                                const DWARFUnit *cu) {
   uint8_t ref_addr_size;
   switch (form) {
   // Blocks if inlined data that have a length field and the data bytes
   // inlined in the .debug_info
   case DW_FORM_exprloc:
   case DW_FORM_block: {
-    dw_uleb128_t size = debug_info_data.GetULEB128(offset_ptr);
-    *offset_ptr += size;
+    dw_uleb128_t size = debug_info_data.GetULEB128(file_offset_ptr);
+    *file_offset_ptr += size;
   }
     return true;
   case DW_FORM_block1: {
-    dw_uleb128_t size = debug_info_data.GetU8(offset_ptr);
-    *offset_ptr += size;
+    dw_uleb128_t size = debug_info_data.GetU8(file_offset_ptr);
+    *file_offset_ptr += size;
   }
     return true;
   case DW_FORM_block2: {
-    dw_uleb128_t size = debug_info_data.GetU16(offset_ptr);
-    *offset_ptr += size;
+    dw_uleb128_t size = debug_info_data.GetU16(file_offset_ptr);
+    *file_offset_ptr += size;
   }
     return true;
   case DW_FORM_block4: {
-    dw_uleb128_t size = debug_info_data.GetU32(offset_ptr);
-    *offset_ptr += size;
+    dw_uleb128_t size = debug_info_data.GetU32(file_offset_ptr);
+    *file_offset_ptr += size;
   }
     return true;
 
   // Inlined NULL terminated C-strings
   case DW_FORM_string:
-    debug_info_data.GetCStr(offset_ptr);
+    debug_info_data.GetCStr(file_offset_ptr);
     return true;
 
   // Compile unit address sized values
   case DW_FORM_addr:
-    *offset_ptr += DWARFUnit::GetAddressByteSize(cu);
+    *file_offset_ptr += DWARFUnit::GetAddressByteSize(cu);
     return true;
 
   case DW_FORM_ref_addr:
     ref_addr_size = 4;
     assert(cu); // CU must be valid for DW_FORM_ref_addr objects or we will get
                 // this wrong
     if (cu->GetVersion() <= 2)
       ref_addr_size = cu->GetAddressByteSize();
     else
       ref_addr_size = cu->IsDWARF64() ? 8 : 4;
-    *offset_ptr += ref_addr_size;
+    *file_offset_ptr += ref_addr_size;
     return true;
 
   // 0 bytes values (implied from DW_FORM)
   case DW_FORM_flag_present:
     return true;
 
   // 1 byte values
   case DW_FORM_data1:
   case DW_FORM_flag:
   case DW_FORM_ref1:
-    *offset_ptr += 1;
+    *file_offset_ptr += 1;
     return true;
 
   // 2 byte values
   case DW_FORM_data2:
   case DW_FORM_ref2:
-    *offset_ptr += 2;
+    *file_offset_ptr += 2;
     return true;
 
   // 32 bit for DWARF 32, 64 for DWARF 64
   case DW_FORM_sec_offset:
   case DW_FORM_strp:
     assert(cu);
-    *offset_ptr += (cu->IsDWARF64() ? 8 : 4);
+    *file_offset_ptr += (cu->IsDWARF64() ? 8 : 4);
     return true;
 
   // 4 byte values
   case DW_FORM_data4:
   case DW_FORM_ref4:
-    *offset_ptr += 4;
+    *file_offset_ptr += 4;
     return true;
 
   // 8 byte values
   case DW_FORM_data8:
   case DW_FORM_ref8:
   case DW_FORM_ref_sig8:
-    *offset_ptr += 8;
+    *file_offset_ptr += 8;
     return true;
 
   // signed or unsigned LEB 128 values
   case DW_FORM_sdata:
   case DW_FORM_udata:
   case DW_FORM_ref_udata:
   case DW_FORM_GNU_addr_index:
   case DW_FORM_GNU_str_index:
-    debug_info_data.Skip_LEB128(offset_ptr);
+    debug_info_data.Skip_LEB128(file_offset_ptr);
     return true;
 
   case DW_FORM_indirect: {
-    dw_form_t indirect_form = debug_info_data.GetULEB128(offset_ptr);
-    return DWARFFormValue::SkipValue(indirect_form, debug_info_data, offset_ptr,
-                                     cu);
+    dw_form_t indirect_form = debug_info_data.GetULEB128(file_offset_ptr);
+    return DWARFFormValue::SkipValue(indirect_form, debug_info_data,
+        file_offset_ptr, cu);
   }
 
   default:
     break;
   }
   return false;
 }
 
if (!symbol_file)
     return 0;
 
   uint32_t index_size = m_cu->GetAddressByteSize();
   dw_offset_t addr_base = m_cu->GetAddrBase();
   lldb::offset_t offset = addr_base + m_value.value.uval * index_size;
   return symbol_file->get_debug_addr_data().GetMaxU64(&offset, index_size);
 }
 
-uint64_t DWARFFormValue::Reference() const {
-  uint64_t die_offset = m_value.value.uval;
+uint64_t DWARFFormValue::ReferenceInFile() const {
+  uint64_t die_file_offset = m_value.value.uval;
   switch (m_form) {
   case DW_FORM_ref1:
   case DW_FORM_ref2:
   case DW_FORM_ref4:
   case DW_FORM_ref8:
   case DW_FORM_ref_udata:
     assert(m_cu); // CU must be valid for DW_FORM_ref forms that are compile
                   // unit relative or we will get this wrong
-    die_offset += m_cu->GetOffset();
+    die_file_offset += m_cu->GetFileOffset();
     break;
 
   default:
     break;
   }
 
-  return die_offset;
+  return die_file_offset;
+}
+
+uint64_t DWARFFormValue::Reference() const {
+  uint64_t file = ReferenceInFile();
+  return m_cu->FileOffsetToUniqOffset(file);
 }
 
 uint64_t DWARFFormValue::Reference(dw_offset_t base_offset) const {
   uint64_t die_offset = m_value.value.uval;
   switch (m_form) {
   case DW_FORM_ref1:
   case DW_FORM_ref2:
   case DW_FORM_ref4:

source/Plugins/SymbolFile/DWARF/DWARFUnit.h

 //===-- DWARFUnit.h ---------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef SymbolFileDWARF_DWARFUnit_h_
 #define SymbolFileDWARF_DWARFUnit_h_
 
 #include "DWARFDIE.h"
 #include "DWARFDebugInfoEntry.h"
 #include "lldb/lldb-enumerations.h"
+#include "lldb/Utility/LLDBAssert.h"
 
 class DWARFUnit;
 class DWARFCompileUnit;
 class NameToDIE;
 class SymbolFileDWARF;
 class SymbolFileDWARFDwo;
 
 typedef std::shared_ptr<DWARFUnit> DWARFUnitSP;
public:
   bool IsDWARF64() const;
 
   bool GetIsOptimized();
 
   SymbolFileDWARFDwo *GetDwoSymbolFile() const;
 
   dw_offset_t GetBaseObjOffset() const;
 
+  dw_offset_t GetFileOffset() const;
+
+  dw_offset_t ThisCUFileOffsetToUniq_nocheck(dw_offset_t file) const {
+    return file + (GetOffset() - GetFileOffset());
+  }
+  dw_offset_t ThisCUFileOffsetToUniq(dw_offset_t file) const {
+    dw_offset_t uniq = ThisCUFileOffsetToUniq_nocheck(file);
+    lldbassert(ContainsDIEOffset(uniq));
+    return uniq;
+  }
+  dw_offset_t FileOffsetToUniqOffset(dw_offset_t file) const;
+  dw_offset_t ThisCUUniqToFileOffset(dw_offset_t uniq) const;
+  bool ContainsFileOffset(dw_offset_t file) const {
+    return ContainsDIEOffset(ThisCUFileOffsetToUniq_nocheck(file));
+  }
+  dw_offset_t GetNextCompileUnitFileOffset() const;
+
 protected:
   virtual DWARFCompileUnit &Data() = 0;
   virtual const DWARFCompileUnit &Data() const = 0;
 
   DWARFUnit();
 
   static void
   IndexPrivate(DWARFUnit *dwarf_cu, const lldb::LanguageType cu_language,

source/Plugins/SymbolFile/DWARF/DWARFUnit.cpp

DWARFDIE DWARFUnit::DIE() {
   return Data().DIE();
 }
 
 bool DWARFUnit::HasDIEsParsed() const { return Data().m_die_array.size() > 1; }
 
 //----------------------------------------------------------------------
 // Compare function DWARFDebugAranges::Range structures
 //----------------------------------------------------------------------
-static bool CompareDIEOffset(const DWARFDebugInfoEntry &die,
-                             const dw_offset_t die_offset) {
-  return die.GetOffset() < die_offset;
+static bool CompareDIEFileOffset(const DWARFDebugInfoEntry &die,
+                                 const dw_offset_t die_file_offset) {
+  return die.GetFileOffset() < die_file_offset;
 }
 
 //----------------------------------------------------------------------
 // GetDIE()
 //
 // Get the DIE (Debug Information Entry) with the specified offset by
 // first checking if the DIE is contained within this compile unit and
 // grabbing the DIE from this compile unit. Otherwise we grab the DIE
 // from the DWARF file.
 //----------------------------------------------------------------------
 DWARFDIE
 DWARFUnit::GetDIE(dw_offset_t die_offset) {
   if (die_offset != DW_INVALID_OFFSET) {
     if (GetDwoSymbolFile())
       return GetDwoSymbolFile()->GetCompileUnit()->GetDIE(die_offset);
 
     if (ContainsDIEOffset(die_offset)) {
       ExtractDIEsIfNeeded(false);
+      dw_offset_t die_file_offset = ThisCUUniqToFileOffset(die_offset);
       DWARFDebugInfoEntry::iterator end = Data().m_die_array.end();
       DWARFDebugInfoEntry::iterator pos = lower_bound(
-          Data().m_die_array.begin(), end, die_offset, CompareDIEOffset);
+          Data().m_die_array.begin(), end, die_file_offset,
+          CompareDIEFileOffset);
       if (pos != end) {
-        if (die_offset == (*pos).GetOffset())
+        if (die_file_offset == (*pos).GetFileOffset())
           return DWARFDIE(this, &(*pos));
       }
     } else {
       // Don't specify the compile unit offset as we don't know it because the
       // DIE belongs to
       // a different compile unit in the same symbol file.
       return Data().m_dwarf2Data->DebugInfo()->GetDIEForDIEOffset(die_offset);
     }

 SymbolFileDWARFDwo *DWARFUnit::GetDwoSymbolFile() const {
   return Data().m_dwo_symbol_file.get();
 }
 
 dw_offset_t DWARFUnit::GetBaseObjOffset() const {
   return Data().m_base_obj_offset;
 }
 
+dw_offset_t DWARFUnit::GetFileOffset() const {
+  return Data().GetFileOffset();
+}
+
+dw_offset_t DWARFUnit::FileOffsetToUniqOffset(dw_offset_t file) const {
+  return static_cast<const DWARFCompileUnit *>(this)
+      ->MainCU_FileOffsetToUniqOffset(file);
+}
+
+dw_offset_t DWARFUnit::ThisCUUniqToFileOffset(dw_offset_t uniq) const {
+  lldbassert(Data().m_length == 0 || ContainsDIEOffset(uniq));
+  return uniq - (GetOffset() - GetFileOffset());
+}
+
+dw_offset_t DWARFUnit::GetNextCompileUnitFileOffset() const {
+  lldbassert(&Data() == this);
+  return Data().GetNextCompileUnitFileOffset();
+}
+
 const DWARFDebugInfoEntry *DWARFUnit::GetCompileUnitDIEPtrOnly() {
   return Data().GetCompileUnitDIEPtrOnly();
 }
 
 const DWARFDebugInfoEntry *DWARFUnit::DIEPtr() {
   return Data().DIEPtr();
 }
 
case DW_TAG_subprogram:
           if (objc_method.IsValid(true)) {
             ConstString objc_class_name_with_category(
                 objc_method.GetClassNameWithCategory());
             ConstString objc_selector_name(objc_method.GetSelector());
             ConstString objc_fullname_no_category_name(
                 objc_method.GetFullNameWithoutCategory(true));
             ConstString objc_class_name_no_category(objc_method.GetClassName());
             func_fullnames.Insert(ConstString(name),
-                                  DIERef(cu_offset, die.GetOffset()));
+                                  DIERef(cu_offset, die.GetOffset(dwarf_cu)));
             if (objc_class_name_with_category)
               objc_class_selectors.Insert(objc_class_name_with_category,
-                                          DIERef(cu_offset, die.GetOffset()));
+                  DIERef(cu_offset, die.GetOffset(dwarf_cu)));
             if (objc_class_name_no_category &&
                 objc_class_name_no_category != objc_class_name_with_category)
               objc_class_selectors.Insert(objc_class_name_no_category,
-                                          DIERef(cu_offset, die.GetOffset()));
+                  DIERef(cu_offset, die.GetOffset(dwarf_cu)));
             if (objc_selector_name)
               func_selectors.Insert(objc_selector_name,
-                                    DIERef(cu_offset, die.GetOffset()));
+                                    DIERef(cu_offset, die.GetOffset(dwarf_cu)));
             if (objc_fullname_no_category_name)
               func_fullnames.Insert(objc_fullname_no_category_name,
-                                    DIERef(cu_offset, die.GetOffset()));
+                                    DIERef(cu_offset, die.GetOffset(dwarf_cu)));
           }
           // If we have a mangled name, then the DW_AT_name attribute
           // is usually the method name without the class or any parameters
           const DWARFDebugInfoEntry *parent = die.GetParent();
           bool is_method = false;
           if (parent) {
             dw_tag_t parent_tag = parent->Tag();
             if (parent_tag == DW_TAG_class_type ||
                 parent_tag == DW_TAG_structure_type) {
               is_method = true;
             } else {
               if (specification_die_form.IsValid()) {
                 DWARFDIE specification_die =
                     dwarf_cu->GetSymbolFileDWARF()->DebugInfo()->GetDIE(
                         DIERef(specification_die_form));
                 if (specification_die.GetParent().IsStructOrClass())
                   is_method = true;
               }
             }
           }
 
           if (is_method)
             func_methods.Insert(ConstString(name),
-                                DIERef(cu_offset, die.GetOffset()));
+                                DIERef(cu_offset, die.GetOffset(dwarf_cu)));
           else
             func_basenames.Insert(ConstString(name),
-                                  DIERef(cu_offset, die.GetOffset()));
+                                  DIERef(cu_offset, die.GetOffset(dwarf_cu)));
 
           if (!is_method && !mangled_cstr && !objc_method.IsValid(true))
             func_fullnames.Insert(ConstString(name),
-                                  DIERef(cu_offset, die.GetOffset()));
+                                  DIERef(cu_offset, die.GetOffset(dwarf_cu)));
         }
         if (mangled_cstr) {
           // Make sure our mangled name isn't the same string table entry
           // as our name. If it starts with '_', then it is ok, else compare
           // the string to make sure it isn't the same and we don't end up
           // with duplicate entries
           if (name && name != mangled_cstr &&
               ((mangled_cstr[0] == '_') ||
                (::strcmp(name, mangled_cstr) != 0))) {
             Mangled mangled(ConstString(mangled_cstr), true);
             func_fullnames.Insert(mangled.GetMangledName(),
-                                  DIERef(cu_offset, die.GetOffset()));
+                                  DIERef(cu_offset, die.GetOffset(dwarf_cu)));
             ConstString demangled = mangled.GetDemangledName(cu_language);
             if (demangled)
               func_fullnames.Insert(demangled,
-                                    DIERef(cu_offset, die.GetOffset()));
+                                    DIERef(cu_offset, die.GetOffset(dwarf_cu)));
           }
         }
       }
       break;
 
     case DW_TAG_inlined_subroutine:
       if (has_address) {
         if (name)
           func_basenames.Insert(ConstString(name),
-                                DIERef(cu_offset, die.GetOffset()));
+                                DIERef(cu_offset, die.GetOffset(dwarf_cu)));
         if (mangled_cstr) {
           // Make sure our mangled name isn't the same string table entry
           // as our name. If it starts with '_', then it is ok, else compare
           // the string to make sure it isn't the same and we don't end up
           // with duplicate entries
           if (name && name != mangled_cstr &&
               ((mangled_cstr[0] == '_') ||
                (::strcmp(name, mangled_cstr) != 0))) {
             Mangled mangled(ConstString(mangled_cstr), true);
             func_fullnames.Insert(mangled.GetMangledName(),
-                                  DIERef(cu_offset, die.GetOffset()));
+                                  DIERef(cu_offset, die.GetOffset(dwarf_cu)));
             ConstString demangled = mangled.GetDemangledName(cu_language);
             if (demangled)
               func_fullnames.Insert(demangled,
-                                    DIERef(cu_offset, die.GetOffset()));
+                                    DIERef(cu_offset, die.GetOffset(dwarf_cu)));
           }
         } else
           func_fullnames.Insert(ConstString(name),
-                                DIERef(cu_offset, die.GetOffset()));
+                                DIERef(cu_offset, die.GetOffset(dwarf_cu)));
       }
       break;
 
     case DW_TAG_array_type:
     case DW_TAG_base_type:
     case DW_TAG_class_type:
     case DW_TAG_constant:
     case DW_TAG_enumeration_type:
     case DW_TAG_string_type:
     case DW_TAG_structure_type:
     case DW_TAG_subroutine_type:
     case DW_TAG_typedef:
     case DW_TAG_union_type:
     case DW_TAG_unspecified_type:
       if (name && !is_declaration)
-        types.Insert(ConstString(name), DIERef(cu_offset, die.GetOffset()));
+        types.Insert(ConstString(name),
+            DIERef(cu_offset, die.GetOffset(dwarf_cu)));
       if (mangled_cstr && !is_declaration)
         types.Insert(ConstString(mangled_cstr),
-                     DIERef(cu_offset, die.GetOffset()));
+                     DIERef(cu_offset, die.GetOffset(dwarf_cu)));
       break;
 
     case DW_TAG_namespace:
       if (name)
         namespaces.Insert(ConstString(name),
-                          DIERef(cu_offset, die.GetOffset()));
+                          DIERef(cu_offset, die.GetOffset(dwarf_cu)));
       break;
 
     case DW_TAG_variable:
       if (name && has_location_or_const_value && is_global_or_static_variable) {
-        globals.Insert(ConstString(name), DIERef(cu_offset, die.GetOffset()));
+        globals.Insert(ConstString(name),
+            DIERef(cu_offset, die.GetOffset(dwarf_cu)));
         // Be sure to include variables by their mangled and demangled
         // names if they have any since a variable can have a basename
         // "i", a mangled named "_ZN12_GLOBAL__N_11iE" and a demangled
         // mangled name "(anonymous namespace)::i"...
 
         // Make sure our mangled name isn't the same string table entry
         // as our name. If it starts with '_', then it is ok, else compare
         // the string to make sure it isn't the same and we don't end up
         // with duplicate entries
         if (mangled_cstr && name != mangled_cstr &&
             ((mangled_cstr[0] == '_') || (::strcmp(name, mangled_cstr) != 0))) {
           Mangled mangled(ConstString(mangled_cstr), true);
           globals.Insert(mangled.GetMangledName(),
-                         DIERef(cu_offset, die.GetOffset()));
+                         DIERef(cu_offset, die.GetOffset(dwarf_cu)));
           ConstString demangled = mangled.GetDemangledName(cu_language);
           if (demangled)
-            globals.Insert(demangled, DIERef(cu_offset, die.GetOffset()));
+            globals.Insert(demangled,
+                DIERef(cu_offset, die.GetOffset(dwarf_cu)));
         }
       }
       break;
 
     default:
       continue;
     }
   }
 }

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

if (num_attributes > 0) {
                 location.CopyOpcodeData(module, debug_info_data, block_offset,
                                         block_length);
               } else if (DWARFFormValue::IsDataForm(form_value.Form())) {
                 // Retrieve the value as a data expression.
                 DWARFFormValue::FixedFormSizes fixed_form_sizes =
                     DWARFFormValue::GetFixedFormSizesForAddressSize(
                         attributes.CompileUnitAtIndex(i)->GetAddressByteSize(),
                         attributes.CompileUnitAtIndex(i)->IsDWARF64());
-                uint32_t data_offset = attributes.DIEOffsetAtIndex(i);
+                uint32_t data_file_offset = die.GetCU()
+                    ->ThisCUUniqToFileOffset(attributes.DIEOffsetAtIndex(i));
                 uint32_t data_length =
                     fixed_form_sizes.GetSize(form_value.Form());
                 if (data_length == 0) {
                   const uint8_t *data_pointer = form_value.BlockData();
                   if (data_pointer) {
                     form_value.Unsigned();
                   } else if (DWARFFormValue::IsDataForm(form_value.Form())) {
                     // we need to get the byte size of the type later after we
                     // create the variable
                     const_value = form_value;
                   }
                 } else
-                  location.CopyOpcodeData(module, debug_info_data, data_offset,
-                                          data_length);
+                  location.CopyOpcodeData(module, debug_info_data,
+                      data_file_offset, data_length);
               } else {
                 // Retrieve the value as a string expression.
                 if (form_value.Form() == DW_FORM_strp) {
                   DWARFFormValue::FixedFormSizes fixed_form_sizes =
                       DWARFFormValue::GetFixedFormSizesForAddressSize(
                           attributes.CompileUnitAtIndex(i)
                               ->GetAddressByteSize(),
                           attributes.CompileUnitAtIndex(i)->IsDWARF64());
-                  uint32_t data_offset = attributes.DIEOffsetAtIndex(i);
+                  uint32_t data_file_offset = die.GetCU()
+                      ->ThisCUUniqToFileOffset(attributes.DIEOffsetAtIndex(i));
                   uint32_t data_length =
                       fixed_form_sizes.GetSize(form_value.Form());
-                  location.CopyOpcodeData(module, debug_info_data, data_offset,
-                                          data_length);
+                  location.CopyOpcodeData(module, debug_info_data,
+                      data_file_offset, data_length);
                 } else {
                   const char *str = form_value.AsCString();
                   uint32_t string_offset =
                       str - (const char *)debug_info_data.GetDataStart();
                   uint32_t string_length = strlen(str) + 1;
                   location.CopyOpcodeData(module, debug_info_data,
                                           string_offset, string_length);
                 }