[lldb] Improve/fix base address selection in location lists

[labath]

Summary

Lldb support base address selection entries in location lists was broken
for a long time. This wasn't noticed until llvm started producing these
kinds of entries more frequently with r374600.

In r374769, I made a quick patch which added sufficient support for them
to get the test suite to pass. However, I did not fully understand how
this code operates, and so the fix was not complete. Specifically, what
was lacking was the ability to handle modules which were not loaded at
their preferred load address (for instance, due to ASLR).

Now that I better understand how this code works, I've come to the
conclusion that the current setup does not provide enough information
to correctly process these entries. In the current setup the location
lists were parameterized by two addresses:

• the distance of the function start from the start of the compile unit. The purpose of this was to make the location ranges relative to the start of the function.
• the actual address where the function was loaded at. With this the function-start-relative ranges can be translated to actual memory locations.

The reason for the two values, instead of just one (the load bias) is (I
think) MachO, where the debug info in the object files will appear to be
relative to the address zero, but the actual code it refers to
can be moved and reordered by the linker. This means that the location
lists need to be "linked" to reflect the locations in the actual linked
file.

These two bits of information were enough to correctly process location
lists which do not contain base address selection entries (and so all
entries are relative to the CU base). However, they don't work with
them because, in theory two base address can be completely unrelated (as
can happen for instace with hot/cold function splitting, where the
linker can reorder the two pars arbitrarily).

To fix that, I split the first parameter into two:

• the compile unit base address
• the function start address, as is known in the object file

The new algorithm becomes:

• the location lists are processed as they were meant to be processed. The CU base address is used as the initial base address value. Base address selection entries can set a new base.
• the difference between the "file" and "load" function start addresses is used to compute the load bias. This value is added to the final ranges to get the actual memory location.

This algorithm is correct for non-MachO debug info, as there the
location lists correctly describe the code in the final executable, and
the dynamic linker can just move the entire module, not pieces of it. It
will also be correct for MachO if the static linker preserves relative
positions of the various parts of the location lists -- I don't know
whether it actually does that, but judging by the lack of base address
selection support in dsymutil and lldb, this isn't something that has
come up in the past.

I add a test case which simulates the ASLR scenario and demonstrates
that base address selection entries now work correctly here.

[clayborg]

So I am worried by seeing any mention of "load address" and "load bias" in this patch. All information that is extracted from the DWARF should be solely in terms if "file addresses" IMHO, unless I am not understanding something from the new location lists. For mach-o DWARF in .o files, the "file address" will be a file address from the .o file (which is fine), but it will need to be linked into an executable file address before being handed out. We fix up addresses like this for any DW_OP_addr opcodes in location expressions. So typically we would have a virtual SymbolFileDWARF method that SymbolFileDWARFDebugMap would override and this would use the default SymbolFileDWARF::GetLocationList(...) function, and then link up the location list or DWARFExpression prior to handing it out. Is there something I am not understanding here?

[labath]

In D70532#1758907, @clayborg wrote:

So I am worried by seeing any mention of "load address" and "load bias" in this patch. All information that is extracted from the DWARF should be solely in terms if "file addresses" IMHO,

This is still true. The information for which goes into the construction of the DWARFExpression is based on information from the object file alone -- this is the CU base (file) address, and function base (file) address. Essentially, the only difference here is that previously we were passing the difference between these two values, whereas this patch passes the two values separately.

The "load" address goes in only when the expression is evaluated (and so it can be different for each invocation, etc.). This part is not changed at all, though I have renamed the value to better reflect how it is now used in the patch.

Let's say we have a CU whose base address is 0x1000, and a function which starts at 0x1100, and we also have a location list like: (0x142, 0x147) => DW_OP_whatever. Let's say that the module is loaded in memory such that the function now starts at 0x8100.
What happened previously that we would create the DWARFExpression with the "slide" of 0x100. Then, when we wanted to get an actual location we'd pass in 0x8100 as the "load address", and the code would compute
(0x8100 - 0x100 + 0x142, 0x8100 - 0x100 + 0x147) = (0x8142, 0x8147) to get the actual location list range.
This worked fine if you didn't have base address selection entries in the location list. Once you have those, you have a problem -- you know that you need to change the base address somehow, but it's not possible to compute how. If we pass in the "file" address of the function start (0x1100), we can compute the load bias (0x8100 - 0x1100 = 0x7000), and add that to any address coming out of the location list.

For mach-o DWARF in .o files, the "file address" will be a file address from the .o file (which is fine), but it will need to be linked into an executable file address before being handed out. We fix up addresses like this for any DW_OP_addr opcodes in location expressions. So typically we would have a virtual SymbolFileDWARF method that SymbolFileDWARFDebugMap would override and this would use the default SymbolFileDWARF::GetLocationList(...) function, and then link up the location list or DWARFExpression prior to handing it out. Is there something I am not understanding here?

The process you're describing is indeed used elsewhere (line tables for instance). It's not possible to use it here, because the location lists are parsed very late -- basically until you actually start to evaluate the expression, the location list is just a blob of bytes, so the relocation needs to happen at a later stage. I'm not sure why something similar wasn't done here too (I suspect it has something to do with DWARFExpression living separately from the rest of the DWARF plugin code), but changing that here seems complicated (particularly as I don't know all the details of mach-o linker stuff).

[clayborg]

In D70532#1758962, @labath wrote:

In D70532#1758907, @clayborg wrote:

So I am worried by seeing any mention of "load address" and "load bias" in this patch. All information that is extracted from the DWARF should be solely in terms if "file addresses" IMHO,

This is still true. The information for which goes into the construction of the DWARFExpression is based on information from the object file alone -- this is the CU base (file) address, and function base (file) address. Essentially, the only difference here is that previously we were passing the difference between these two values, whereas this patch passes the two values separately.

Gotcha.

The "load" address goes in only when the expression is evaluated (and so it can be different for each invocation, etc.). This part is not changed at all, though I have renamed the value to better reflect how it is now used in the patch.

Let's say we have a CU whose base address is 0x1000, and a function which starts at 0x1100, and we also have a location list like: (0x142, 0x147) => DW_OP_whatever. Let's say that the module is loaded in memory such that the function now starts at 0x8100.
What happened previously that we would create the DWARFExpression with the "slide" of 0x100. Then, when we wanted to get an actual location we'd pass in 0x8100 as the "load address", and the code would compute
(0x8100 - 0x100 + 0x142, 0x8100 - 0x100 + 0x147) = (0x8142, 0x8147) to get the actual location list range.
This worked fine if you didn't have base address selection entries in the location list. Once you have those, you have a problem -- you know that you need to change the base address somehow, but it's not possible to compute how. If we pass in the "file" address of the function start (0x1100), we can compute the load bias (0x8100 - 0x1100 = 0x7000), and add that to any address coming out of the location list.

Thanks for explaining.

For mach-o DWARF in .o files, the "file address" will be a file address from the .o file (which is fine), but it will need to be linked into an executable file address before being handed out. We fix up addresses like this for any DW_OP_addr opcodes in location expressions. So typically we would have a virtual SymbolFileDWARF method that SymbolFileDWARFDebugMap would override and this would use the default SymbolFileDWARF::GetLocationList(...) function, and then link up the location list or DWARFExpression prior to handing it out. Is there something I am not understanding here?

The process you're describing is indeed used elsewhere (line tables for instance). It's not possible to use it here, because the location lists are parsed very late -- basically until you actually start to evaluate the expression, the location list is just a blob of bytes, so the relocation needs to happen at a later stage. I'm not sure why something similar wasn't done here too (I suspect it has something to do with DWARFExpression living separately from the rest of the DWARF plugin code), but changing that here seems complicated (particularly as I don't know all the details of mach-o linker stuff).

Sounds good.

lldb/include/lldb/Expression/DWARFExpression.h

88–90

Is this a "file address"? Maybe clarify here in the comment, or rename variable appropriately?

141–150

Maybe change name to "cu_file_addr"?

144

Maybe change name to "func_file_addr"?

148

Rename from "SetLocationListSlide" to "SetLocationListAddresses"? Slide doesn't seem relevant anymore

163

Maybe change name to "func_file_addr"?

225–226

Maybe change name to "func_file_addr"?

260

Maybe change name to "func_file_addr"?

[labath]

lldb/include/lldb/Expression/DWARFExpression.h

88–90

No, this is an actual load address. The file address is only used in SetLocationListSlide/SetLocationListAddresses which then stores it in the object itself. All other functions take a load address, since that is intentionally not stored anywhere.

(Technically this doesn't have to be a load address -- it can be whatever the type of address you want. If you pass in a file address here (like some dumping code does), then it will still work, just the addresses coming out of the location list will be file addresses...)

[labath]

Rename to {cu,func}_{file,load}_addr as appropriate.

[labath]

Greg, what do you make of this version?

[clayborg]

Sorry for the delay, lgtm

lldb/include/lldb/Expression/DWARFExpression.h

public:
   /// Return true if the location expression contains data
   bool IsValid() const;
 
   /// Return true if a location list was provided
   bool IsLocationList() const;
 
   /// Search for a load address in the location list
   ///
-  /// \param[in] process
-  ///     The process to use when resolving the load address
+  /// \param[in] func_load_addr
+  ///     The actual address of the function containing this location list.
   ///
   /// \param[in] addr
   ///     The address to resolve
   ///
   /// \return
   ///     True if IsLocationList() is true and the address was found;
   ///     false otherwise.
   //    bool
   //    LocationListContainsLoadAddress (Process* process, const Address &addr)
   //    const;
   //
-  bool LocationListContainsAddress(lldb::addr_t loclist_base_addr,
+  bool LocationListContainsAddress(lldb::addr_t func_load_addr,
                                    lldb::addr_t addr) const;
 
   /// If a location is not a location list, return true if the location
   /// contains a DW_OP_addr () opcode in the stream that matches \a file_addr.
   /// If file_addr is LLDB_INVALID_ADDRESS, the this function will return true
   /// if the variable there is any DW_OP_addr in a location that (yet still is
   /// NOT a location list). This helps us detect if a variable is a global or
   /// static variable since there is no other indication from DWARF debug
public:
 
   bool LinkThreadLocalStorage(
       lldb::ModuleSP new_module_sp,
       std::function<lldb::addr_t(lldb::addr_t file_addr)> const
           &link_address_callback);
 
   /// Tells the expression that it refers to a location list.
   ///
-  /// \param[in] slide
-  ///     This value should be a slide that is applied to any values
-  ///     in the location list data so the values become zero based
-  ///     offsets into the object that owns the location list. We need
-  ///     to make location lists relative to the objects that own them
-  ///     so we can relink addresses on the fly.
-  void SetLocationListSlide(lldb::addr_t slide);
+  /// \param[in] cu_file_addr
+  ///     The base address to use for interpreting relative location list
+  ///     entries.
+  /// \param[in] func_file_addr
+  ///     The file address of the function containing this location list. This
+  ///     address will be used to relocate the location list on the fly (in
+  ///     conjuction with the func_load_addr arguments).
+  void SetLocationListAddresses(lldb::addr_t cu_file_addr,
+                                lldb::addr_t func_file_addr);
 
   /// Return the call-frame-info style register kind
   int GetRegisterKind();
 
   /// Set the call-frame-info style register kind
   ///
   /// \param[in] reg_kind
   ///     The register kind.
   void SetRegisterKind(lldb::RegisterKind reg_kind);
 
   /// Wrapper for the static evaluate function that accepts an
   /// ExecutionContextScope instead of an ExecutionContext and uses member
   /// variables to populate many operands
-  bool Evaluate(ExecutionContextScope *exe_scope,
-                lldb::addr_t loclist_base_load_addr,
+  bool Evaluate(ExecutionContextScope *exe_scope, lldb::addr_t func_load_addr,
                 const Value *initial_value_ptr, const Value *object_address_ptr,
                 Value &result, Status *error_ptr) const;
 
   /// Wrapper for the static evaluate function that uses member variables to
   /// populate many operands
   bool Evaluate(ExecutionContext *exe_ctx, RegisterContext *reg_ctx,
                 lldb::addr_t loclist_base_load_addr,
                 const Value *initial_value_ptr, const Value *object_address_ptr,
static bool Evaluate(ExecutionContext *exe_ctx, RegisterContext *reg_ctx,
                        const Value *object_address_ptr, Value &result,
                        Status *error_ptr);
 
   bool GetExpressionData(DataExtractor &data) const {
     data = m_data;
     return data.GetByteSize() > 0;
   }
 
   bool DumpLocationForAddress(Stream *s, lldb::DescriptionLevel level,
-                              lldb::addr_t loclist_base_load_addr,
-                              lldb::addr_t address, ABI *abi);
+                              lldb::addr_t func_load_addr, lldb::addr_t address,
+                              ABI *abi);
 
   static bool PrintDWARFExpression(Stream &s, const DataExtractor &data,
                                    int address_size, int dwarf_ref_size,
                                    bool location_expression);
 
   static void PrintDWARFLocationList(Stream &s, const DWARFUnit *cu,
                                      const DataExtractor &debug_loc_data,
                                      lldb::offset_t offset);
private:
   ///     The level of detail to use in pretty-printing.
   ///
   /// \param[in] abi
   ///     An optional ABI plug-in that can be used to resolve register
   ///     names.
   void DumpLocation(Stream *s, lldb::offset_t offset, lldb::offset_t length,
                     lldb::DescriptionLevel level, ABI *abi) const;
 
-  bool GetLocation(lldb::addr_t base_addr, lldb::addr_t pc,
+  bool GetLocation(lldb::addr_t func_load_addr, lldb::addr_t pc,
                    lldb::offset_t &offset, lldb::offset_t &len);
 
   static bool AddressRangeForLocationListEntry(
       const DWARFUnit *dwarf_cu, const DataExtractor &debug_loc_data,
       lldb::offset_t *offset_ptr, lldb::addr_t &low_pc, lldb::addr_t &high_pc);
 
   bool GetOpAndEndOffsets(StackFrame &frame, lldb::offset_t &op_offset,
                           lldb::offset_t &end_offset);
 
+  void RelocateLowHighPC(lldb::addr_t base_address, lldb::addr_t func_load_addr,
+                         lldb::addr_t &low_pc, lldb::addr_t &high_pc) const;
+
   /// Module which defined this expression.
   lldb::ModuleWP m_module_wp;
 
   /// A data extractor capable of reading opcode bytes
   DataExtractor m_data;
 
   /// The DWARF compile unit this expression belongs to. It is used to evaluate
   /// values indexing into the .debug_addr section (e.g. DW_OP_GNU_addr_index,
   /// DW_OP_GNU_const_index)
   const DWARFUnit *m_dwarf_cu;
 
   /// One of the defines that starts with LLDB_REGKIND_
   lldb::RegisterKind m_reg_kind;
 
-  /// A value used to slide the location list offsets so that m_c they are
-  /// relative to the object that owns the location list (the function for
-  /// frame base and variable location lists)
-  lldb::addr_t m_loclist_slide;
+  struct LoclistAddresses {
+    lldb::addr_t cu_file_addr;
+    lldb::addr_t func_file_addr;
+  };
+  llvm::Optional<LoclistAddresses> m_loclist_addresses;
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_DWARFExpression_h_

lldb/source/Expression/DWARFExpression.cpp

return dwarf_cu->GetSymbolFileDWARF()
       .GetDWARFContext()
       .getOrLoadAddrData()
       .GetMaxU64(&offset, index_size);
 }
 
 // DWARFExpression constructor
 DWARFExpression::DWARFExpression()
     : m_module_wp(), m_data(), m_dwarf_cu(nullptr),
-      m_reg_kind(eRegisterKindDWARF), m_loclist_slide(LLDB_INVALID_ADDRESS) {}
+      m_reg_kind(eRegisterKindDWARF) {}
 
 DWARFExpression::DWARFExpression(lldb::ModuleSP module_sp,
                                  const DataExtractor &data,
                                  const DWARFUnit *dwarf_cu)
     : m_module_wp(), m_data(data), m_dwarf_cu(dwarf_cu),
-      m_reg_kind(eRegisterKindDWARF), m_loclist_slide(LLDB_INVALID_ADDRESS) {
+      m_reg_kind(eRegisterKindDWARF) {
   if (module_sp)
     m_module_wp = module_sp;
 }
 
 // Destructor
 DWARFExpression::~DWARFExpression() {}
 
 bool DWARFExpression::IsValid() const { return m_data.GetByteSize() > 0; }
void DWARFExpression::DumpLocation(Stream *s, lldb::offset_t offset,
                                    lldb::DescriptionLevel level,
                                    ABI *abi) const {
   llvm::DWARFExpression(DataExtractor(m_data, offset, length).GetAsLLVM(),
                         llvm::dwarf::DWARF_VERSION, m_data.GetAddressByteSize())
       .print(s->AsRawOstream(), abi ? &abi->GetMCRegisterInfo() : nullptr,
              nullptr);
 }
 
-void DWARFExpression::SetLocationListSlide(addr_t slide) {
-  m_loclist_slide = slide;
+void DWARFExpression::SetLocationListAddresses(addr_t cu_file_addr,
+                                               addr_t func_file_addr) {
+  m_loclist_addresses = LoclistAddresses{cu_file_addr, func_file_addr};
 }
 
 int DWARFExpression::GetRegisterKind() { return m_reg_kind; }
 
 void DWARFExpression::SetRegisterKind(RegisterKind reg_kind) {
   m_reg_kind = reg_kind;
 }
 
 bool DWARFExpression::IsLocationList() const {
-  return m_loclist_slide != LLDB_INVALID_ADDRESS;
+  return bool(m_loclist_addresses);
 }
 
 void DWARFExpression::GetDescription(Stream *s, lldb::DescriptionLevel level,
                                      addr_t location_list_base_addr,
                                      ABI *abi) const {
   if (IsLocationList()) {
     // We have a location list
     lldb::offset_t offset = 0;
bool DWARFExpression::LinkThreadLocalStorage(
   // expression is evaluated it can resolve the file address to a load address
   // and read the
   // TLS data
   m_module_wp = new_module_sp;
   m_data.SetData(heap_data_sp);
   return true;
 }
 
-bool DWARFExpression::LocationListContainsAddress(
-    lldb::addr_t loclist_base_addr, lldb::addr_t addr) const {
-  if (addr == LLDB_INVALID_ADDRESS)
+bool DWARFExpression::LocationListContainsAddress(addr_t func_load_addr,
+                                                  lldb::addr_t addr) const {
+  if (func_load_addr == LLDB_INVALID_ADDRESS || addr == LLDB_INVALID_ADDRESS)
     return false;
 
-  if (IsLocationList()) {
-    lldb::offset_t offset = 0;
-
-    if (loclist_base_addr == LLDB_INVALID_ADDRESS)
-      return false;
+  if (!IsLocationList())
 
-    while (m_data.ValidOffset(offset)) {
-      // We need to figure out what the value is for the location.
-      addr_t lo_pc = LLDB_INVALID_ADDRESS;
-      addr_t hi_pc = LLDB_INVALID_ADDRESS;
-      if (!AddressRangeForLocationListEntry(m_dwarf_cu, m_data, &offset, lo_pc,
-                                            hi_pc))
-        break;
+  lldb::offset_t offset = 0;
+  lldb::addr_t base_address = m_loclist_addresses->cu_file_addr;
 
-      if (lo_pc == 0 && hi_pc == 0)
-        break;
 
-      if ((m_data.GetAddressByteSize() == 4 && (lo_pc == UINT32_MAX)) ||
-          (m_data.GetAddressByteSize() == 8 && (lo_pc == UINT64_MAX))) {
-        loclist_base_addr = hi_pc + m_loclist_slide;
-        continue;
-      }
-      lo_pc += loclist_base_addr - m_loclist_slide;
-      hi_pc += loclist_base_addr - m_loclist_slide;
+      base_address = hi_pc;
+    RelocateLowHighPC(base_address, func_load_addr, lo_pc, hi_pc);
 
-      if (lo_pc <= addr && addr < hi_pc)
-        return true;
 
-      offset += m_data.GetU16(&offset);
-    }
-  }
   return false;
 }
 
-bool DWARFExpression::GetLocation(addr_t base_addr, addr_t pc,
+bool DWARFExpression::GetLocation(addr_t func_load_addr, addr_t pc,
                                   lldb::offset_t &offset,
                                   lldb::offset_t &length) {
   offset = 0;
   if (!IsLocationList()) {
     length = m_data.GetByteSize();
     return true;
   }
 
-  if (base_addr != LLDB_INVALID_ADDRESS && pc != LLDB_INVALID_ADDRESS) {
-    addr_t curr_base_addr = base_addr;
-
+  if (func_load_addr != LLDB_INVALID_ADDRESS && pc != LLDB_INVALID_ADDRESS) {
+    addr_t base_address = m_loclist_addresses->cu_file_addr;
     while (m_data.ValidOffset(offset)) {
       // We need to figure out what the value is for the location.
       addr_t lo_pc = LLDB_INVALID_ADDRESS;
       addr_t hi_pc = LLDB_INVALID_ADDRESS;
       if (!AddressRangeForLocationListEntry(m_dwarf_cu, m_data, &offset, lo_pc,
                                             hi_pc))
         break;
 
       if (lo_pc == 0 && hi_pc == 0)
         break;
 
       if ((m_data.GetAddressByteSize() == 4 && (lo_pc == UINT32_MAX)) ||
           (m_data.GetAddressByteSize() == 8 && (lo_pc == UINT64_MAX))) {
-        curr_base_addr = hi_pc + m_loclist_slide;
+        base_address = hi_pc;
         continue;
       }
 
-      lo_pc += curr_base_addr - m_loclist_slide;
-      hi_pc += curr_base_addr - m_loclist_slide;
-
+      RelocateLowHighPC(base_address, func_load_addr, lo_pc, hi_pc);
       length = m_data.GetU16(&offset);
 
       if (length > 0 && lo_pc <= pc && pc < hi_pc)
         return true;
 
       offset += length;
     }
   }
   offset = LLDB_INVALID_OFFSET;
   length = 0;
   return false;
 }
 
 bool DWARFExpression::DumpLocationForAddress(Stream *s,
                                              lldb::DescriptionLevel level,
-                                             addr_t base_addr, addr_t address,
-                                             ABI *abi) {
+                                             addr_t func_load_addr,
+                                             addr_t address, ABI *abi) {
   lldb::offset_t offset = 0;
   lldb::offset_t length = 0;
 
-  if (GetLocation(base_addr, address, offset, length)) {
+  if (GetLocation(func_load_addr, address, offset, length)) {
     if (length > 0) {
       DumpLocation(s, offset, length, level, abi);
       return true;
     }
   }
   return false;
 }
 
bool DWARFExpression::Evaluate(ExecutionContextScope *exe_scope,
                                Status *error_ptr) const {
   ExecutionContext exe_ctx(exe_scope);
   return Evaluate(&exe_ctx, nullptr, loclist_base_load_addr, initial_value_ptr,
                   object_address_ptr, result, error_ptr);
 }
 
 bool DWARFExpression::Evaluate(ExecutionContext *exe_ctx,
                                RegisterContext *reg_ctx,
-                               lldb::addr_t loclist_base_load_addr,
+                               lldb::addr_t func_load_addr,
                                const Value *initial_value_ptr,
                                const Value *object_address_ptr, Value &result,
                                Status *error_ptr) const {
   ModuleSP module_sp = m_module_wp.lock();
 
   if (IsLocationList()) {
     lldb::offset_t offset = 0;
     addr_t pc;
     StackFrame *frame = nullptr;
     if (reg_ctx)
       pc = reg_ctx->GetPC();
     else {
       frame = exe_ctx->GetFramePtr();
       if (!frame)
         return false;
       RegisterContextSP reg_ctx_sp = frame->GetRegisterContext();
       if (!reg_ctx_sp)
         return false;
       pc = reg_ctx_sp->GetPC();
     }
 
-    if (loclist_base_load_addr != LLDB_INVALID_ADDRESS) {
+    if (func_load_addr != LLDB_INVALID_ADDRESS) {
       if (pc == LLDB_INVALID_ADDRESS) {
         if (error_ptr)
           error_ptr->SetErrorString("Invalid PC in frame.");
         return false;
       }
 
-      addr_t curr_loclist_base_load_addr = loclist_base_load_addr;
-
+      addr_t base_address = m_loclist_addresses->cu_file_addr;
       while (m_data.ValidOffset(offset)) {
         // We need to figure out what the value is for the location.
         addr_t lo_pc = LLDB_INVALID_ADDRESS;
         addr_t hi_pc = LLDB_INVALID_ADDRESS;
         if (!AddressRangeForLocationListEntry(m_dwarf_cu, m_data, &offset,
                                               lo_pc, hi_pc))
           break;
 
         if (lo_pc == 0 && hi_pc == 0)
           break;
 
         if ((m_data.GetAddressByteSize() == 4 &&
              (lo_pc == UINT32_MAX)) ||
             (m_data.GetAddressByteSize() == 8 &&
              (lo_pc == UINT64_MAX))) {
-          curr_loclist_base_load_addr = hi_pc + m_loclist_slide;
+          base_address = hi_pc;
           continue;
         }
-        lo_pc += curr_loclist_base_load_addr - m_loclist_slide;
-        hi_pc += curr_loclist_base_load_addr - m_loclist_slide;
 
+        RelocateLowHighPC(base_address, func_load_addr, lo_pc, hi_pc);
         uint16_t length = m_data.GetU16(&offset);
 
         if (length > 0 && lo_pc <= pc && pc < hi_pc) {
           return DWARFExpression::Evaluate(
               exe_ctx, reg_ctx, module_sp,
               DataExtractor(m_data, offset, length), m_dwarf_cu, m_reg_kind,
               initial_value_ptr, object_address_ptr, result, error_ptr);
         }
if (opcodes_length == 0) {
     return false;
   }
 
   op_offset = opcodes_offset;
   end_offset = opcodes_offset + opcodes_length;
   return true;
 }
 
+void DWARFExpression::RelocateLowHighPC(addr_t base_address,
+                                        addr_t func_load_addr, addr_t &low_pc,
+                                        addr_t &high_pc) const {
+  // How this works:
+  // base_address is the current base address, as known in the file. low_pc and
+  // high_pc are relative to that. First, we relocate the base address by
+  // applying the load bias (the difference between an address in the file and
+  // the actual address in memory). Then we relocate low_pc and high_pc based on
+  // that.
+  base_address += func_load_addr - m_loclist_addresses->func_file_addr;
+  low_pc += base_address;
+  high_pc += base_address;
+}
+
 bool DWARFExpression::MatchesOperand(StackFrame &frame,
                                      const Instruction::Operand &operand) {
   using namespace OperandMatchers;
 
   lldb::offset_t op_offset;
   lldb::offset_t end_offset;
   if (!GetOpAndEndOffsets(frame, op_offset, end_offset)) {
     return false;

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

for (uint32_t i = 0; i < numAttributes; ++i) {
             } else {
               DataExtractor data = dwarf.DebugLocData();
               const dw_offset_t offset = form_value.Unsigned();
               if (data.ValidOffset(offset)) {
                 data = DataExtractor(data, offset, data.GetByteSize() - offset);
                 *frame_base = DWARFExpression(module, data, cu);
                 if (lo_pc != LLDB_INVALID_ADDRESS) {
                   assert(lo_pc >= cu->GetBaseAddress());
-                  frame_base->SetLocationListSlide(lo_pc -
-                                                   cu->GetBaseAddress());
+                  frame_base->SetLocationListAddresses(cu->GetBaseAddress(),
+                                                       lo_pc);
                 } else {
                   set_frame_base_loclist_addr = true;
                 }
               }
             }
           }
           break;
 
if (lo_pc != LLDB_INVALID_ADDRESS) {
       else
         ranges.Append(DWARFRangeList::Entry(lo_pc, 0));
     }
   }
 
   if (set_frame_base_loclist_addr) {
     dw_addr_t lowest_range_pc = ranges.GetMinRangeBase(0);
     assert(lowest_range_pc >= cu->GetBaseAddress());
-    frame_base->SetLocationListSlide(lowest_range_pc - cu->GetBaseAddress());
+    frame_base->SetLocationListAddresses(cu->GetBaseAddress(), lowest_range_pc);
   }
 
   if (ranges.IsEmpty() || name == nullptr || mangled == nullptr) {
     for (const DWARFDIE &die : dies) {
       if (die) {
         die.GetDIE()->GetDIENamesAndRanges(die.GetCU(), name, mangled, ranges,
                                            decl_file, decl_line, decl_column,
                                            call_file, call_line, call_column);

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

if (num_attributes > 0) {
                   die.GetCU());
             } else {
               DataExtractor data = DebugLocData();
               const dw_offset_t offset = form_value.Unsigned();
               if (data.ValidOffset(offset)) {
                 data = DataExtractor(data, offset, data.GetByteSize() - offset);
                 location = DWARFExpression(module, data, die.GetCU());
                 assert(func_low_pc != LLDB_INVALID_ADDRESS);
-                location.SetLocationListSlide(
-                    func_low_pc -
-                    attributes.CompileUnitAtIndex(i)->GetBaseAddress());
+                location.SetLocationListAddresses(
+                    attributes.CompileUnitAtIndex(i)->GetBaseAddress(),
+                    func_low_pc);
               }
             }
           } break;
           case DW_AT_specification:
             spec_die = form_value.Reference();
             break;
           case DW_AT_start_scope:
             // TODO: Implement this.

lldb/test/Shell/SymbolFile/DWARF/Inputs/debug_loc-aslr.yaml

+--- !minidump
+Streams:         
+  - Type:            ThreadList
+    Threads:         
+      - Thread Id:       0x00003E81
+        Context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
+        Stack:           
+          Start of Memory Range: 0x00007FFCEB34A000
+          Content:         DEAD
+  - Type:            SystemInfo
+    Processor Arch:  AMD64
+    Processor Level: 6
+    Processor Revision: 15876
+    Number of Processors: 40
+    Platform ID:     Linux
+    CSD Version:     'Linux 3.13.0-91-generic'
+    CPU:             
+      Vendor ID:       GenuineIntel
+      Version Info:    0x00000000
+      Feature Info:    0x00000000
+  - Type:            LinuxProcStatus
+    Text:             |
+      Name: linux-x86_64
+      State:  t (tracing stop)
+      Tgid: 29917
+      Ngid: 0
+      Pid:  29917
+      PPid: 29370
+
+...

lldb/test/Shell/SymbolFile/DWARF/debug_loc-aslr.s

+# This test checks the handling of location lists in the case when the module is
+# not loaded at the address at which it was linked (as happens with ASLR for
+# instance).
+
+# REQUIRES: x86
+
+# RUN: yaml2obj %S/Inputs/debug_loc-aslr.yaml >%t.dmp
+# RUN: llvm-mc --triple=x86_64-pc-linux --filetype=obj %s >%t.o
+# RUN: %lldb -c %t.dmp -o "image add %t.o" \
+# RUN:   -o "image load --file %t.o --slide 0x470000" \
+# RUN:   -o "thread info" -o "frame variable" -o exit | FileCheck %s
+
+# CHECK: thread #1: tid = 16001, 0x0000000000470001 {{.*}}`_start
+# CHECK: (int) x = 47
+# CHECK: (int) y = 74
+
+        .text
+        .globl _start
+_start:
+        nop
+        retq
+.Lstart_end:
+
+        .section        .debug_loc,"",@progbits
+# This location list implicitly uses the base address of the compile unit.
+.Ldebug_loc0:
+        .quad   _start-_start
+        .quad   .Lstart_end-_start
+        .short  3                       # Loc expr size
+        .byte   8                       # DW_OP_const1u
+        .byte   47
+        .byte   159                     # DW_OP_stack_value
+        .quad   0
+        .quad   0
+
+# This is an equivalent location list to the first one, but here the base
+# address is set explicitly.
+.Ldebug_loc1:
+        .quad   -1
+        .quad   _start
+        .quad   _start-_start
+        .quad   .Lstart_end-_start
+        .short  3                       # Loc expr size
+        .byte   8                       # DW_OP_const1u
+        .byte   74
+        .byte   159                     # DW_OP_stack_value
+        .quad   0
+        .quad   0
+
+        .section        .debug_abbrev,"",@progbits
+        .byte   1                       # Abbreviation Code
+        .byte   17                      # DW_TAG_compile_unit
+        .byte   1                       # DW_CHILDREN_yes
+        .byte   37                      # DW_AT_producer
+        .byte   8                       # DW_FORM_string
+        .byte   19                      # DW_AT_language
+        .byte   5                       # DW_FORM_data2
+        .byte   17                      # DW_AT_low_pc
+        .byte   1                       # DW_FORM_addr
+        .byte   18                      # DW_AT_high_pc
+        .byte   6                       # DW_FORM_data4
+        .byte   0                       # EOM(1)
+        .byte   0                       # EOM(2)
+        .byte   2                       # Abbreviation Code
+        .byte   46                      # DW_TAG_subprogram
+        .byte   1                       # DW_CHILDREN_yes
+        .byte   17                      # DW_AT_low_pc
+        .byte   1                       # DW_FORM_addr
+        .byte   18                      # DW_AT_high_pc
+        .byte   6                       # DW_FORM_data4
+        .byte   3                       # DW_AT_name
+        .byte   8                       # DW_FORM_string
+        .byte   0                       # EOM(1)
+        .byte   0                       # EOM(2)
+        .byte   4                       # Abbreviation Code
+        .byte   52                      # DW_TAG_variable
+        .byte   0                       # DW_CHILDREN_no
+        .byte   2                       # DW_AT_location
+        .byte   23                      # DW_FORM_sec_offset
+        .byte   3                       # DW_AT_name
+        .byte   8                       # DW_FORM_string
+        .byte   73                      # DW_AT_type
+        .byte   19                      # DW_FORM_ref4
+        .byte   0                       # EOM(1)
+        .byte   0                       # EOM(2)
+        .byte   6                       # Abbreviation Code
+        .byte   36                      # DW_TAG_base_type
+        .byte   0                       # DW_CHILDREN_no
+        .byte   3                       # DW_AT_name
+        .byte   8                       # DW_FORM_string
+        .byte   62                      # DW_AT_encoding
+        .byte   11                      # DW_FORM_data1
+        .byte   11                      # DW_AT_byte_size
+        .byte   11                      # DW_FORM_data1
+        .byte   0                       # EOM(1)
+        .byte   0                       # EOM(2)
+        .byte   0                       # EOM(3)
+        .section        .debug_info,"",@progbits
+.Lcu_begin0:
+        .long   .Ldebug_info_end0-.Ldebug_info_start0 # Length of Unit
+.Ldebug_info_start0:
+        .short  4                       # DWARF version number
+        .long   .debug_abbrev           # Offset Into Abbrev. Section
+        .byte   8                       # Address Size (in bytes)
+        .byte   1                       # Abbrev [1] 0xb:0x6a DW_TAG_compile_unit
+        .asciz  "Hand-written DWARF"    # DW_AT_producer
+        .short  12                      # DW_AT_language
+        .quad   _start                  # DW_AT_low_pc
+        .long   .Lstart_end-_start      # DW_AT_high_pc
+        .byte   2                       # Abbrev [2] 0x2a:0x43 DW_TAG_subprogram
+        .quad   _start                  # DW_AT_low_pc
+        .long   .Lstart_end-_start      # DW_AT_high_pc
+        .asciz  "_start"                # DW_AT_name
+        .byte   4                       # Abbrev [4] 0x52:0xf DW_TAG_variable
+        .long   .Ldebug_loc0            # DW_AT_location
+        .asciz  "x"                     # DW_AT_name
+        .long   .Lint                   # DW_AT_type
+        .byte   4                       # Abbrev [4] 0x52:0xf DW_TAG_variable
+        .long   .Ldebug_loc1            # DW_AT_location
+        .asciz  "y"                     # DW_AT_name
+        .long   .Lint                   # DW_AT_type
+        .byte   0                       # End Of Children Mark
+.Lint:
+        .byte   6                       # Abbrev [6] 0x6d:0x7 DW_TAG_base_type
+        .asciz  "int"                   # DW_AT_name
+        .byte   5                       # DW_AT_encoding
+        .byte   4                       # DW_AT_byte_size
+        .byte   0                       # End Of Children Mark
+.Ldebug_info_end0: