[LLDB][NFC] Decouple dwarf location table from DWARFExpression.

[zequanwu]

Summary

This decouples DWARFExpression such that DWARFExpression only contains the
data of a single dwarf expression, no range info. DWARFExpressionList holds
a RangeDataVector that maps file address ranges into dwarf expressions.

Currently a variable in NativePDB and PDB plugins can only have one dwarf
location to describe its location, because they don't have dwarf location table
that stores the mapping relationship. So, they need to construct a dwarf
location table from code view format which is complicated to have multiple
locations for one variable. This patch makes it easier to add multiple dwarf
expressions without constructing a dwarf location table.

[zequanwu]

Add missing sort.

[JDevlieghere]

Separating the notion of an expression and an expression list seems worthwhile. I did a very high level pass but I'll take a more detailed look tomorrow.

lldb/include/lldb/Expression/DWARFExpressionList.h

2–3

Formatting

23

This should be a Doxygen comment. But more importantly, this doesn't really tell me what the class does. DWARFExpressionList implies it holds a list of expressions so that seems useful to include there.

25

I think we generally put public first, followed by protected and private last.

lldb/test/Shell/SymbolFile/DWARF/x86/dwp.s

22–24

I guess the patch is not NFC is the output changes? Would it be possible to split the functional and non-functional part of this patch into separate patches?

[zequanwu]

Address comments.

lldb/test/Shell/SymbolFile/DWARF/x86/dwp.s

22–24

Originally, lldb-test uses DWARFLocationTable::dumpLocationList to dump the raw range info from dwarf expression, which are not interpreted to be readable range info.
In this case, the raw range info is DW_LLE_startx_length 0x1 0x1 where the first value is address index and second value is range length. Now, it's dumping the readable range info that is interpreted from the raw range info. So, the variable range is within the block range.

Another test case change is debug_loc.s, because we don't accept invalid range info now.

[rnk]

@labath, ping, I see you just got back from vacation and this is a lot of code, but any high level design feedback would be helpful to know if this is the right direction.

llvm/lib/DebugInfo/DWARF/DWARFDebugLoc.cpp

180–181

Did this change cause the presubmit test failure? DebugInfoDWARFTests/DWARFDie::getLocations looks related.

[zequanwu]

llvm/lib/DebugInfo/DWARF/DWARFDebugLoc.cpp

180–181

Yes. If I don't make this change, several existing tests crashed at here due to Expected<T> must be checked before access or destruction. I'm not sure how to fix this.

[zequanwu]

Add missing check for Expected.

[zequanwu]

llvm/lib/DebugInfo/DWARF/DWARFDebugLoc.cpp

180–181

NVM, I missed a checking for expected above. Reverted this part.

[labath]

Overall, I like this. The main thing I am wondering is if it wouldn't be better to (instead of essentially duplicating the DWARFExpression interface in the DWARFExpressionList class) somehow split the process of finding the appropriate expression (for the given PC value or whatever), and the actual evaluation. This would be particularly nice if the arguments can be split in such a way that those that are used for locating the expression are not repeated in the "evaluate" call. Have you considered this?

Also, if I understand correctly, one of the side effects of this patch that the DWARF location list is now parsed more eagerly (when the containing object (e.g. variable) is constructed rather than during evaluation time). I think that's probably fine, but it's definitely worth calling out.

lldb/source/Expression/DWARFExpression.cpp

2581–2584

Could this go into the list class?

lldb/source/Expression/DWARFExpressionList.cpp

112

What would it take to make this class iterable? (i.e. have some begin/end methods instead of this foreach callback.

lldb/test/Shell/SymbolFile/DWARF/x86/debug_loc.s

43

This is probably fine, but it would be nice to at least log the errors somewhere (if we don't do it already).

[zequanwu]

Address comments.

[zequanwu]

The main thing I am wondering is if it wouldn't be better to (instead of essentially duplicating the DWARFExpression interface in the DWARFExpressionList class) somehow split the process of finding the appropriate expression (for the given PC value or whatever), and the actual evaluation. This would be particularly nice if the arguments can be split in such a way that those that are used for locating the expression are not repeated in the "evaluate" call. Have you considered this?

Then we need to duplicate the code that gets expression data and register kind before every call to DWARFExpression::Evaluate, making it less clean.

Also, if I understand correctly, one of the side effects of this patch that the DWARF location list is now parsed more eagerly (when the containing object (e.g. variable) is constructed rather than during evaluation time). I think that's probably fine, but it's definitely worth calling out.

Yes, the dwarf location list now is parsed at the time when parsing variable DIE. It used to be that a dwarf location list will be parsed every time when we try to access a dwarf expression inside.

lldb/source/Expression/DWARFExpression.cpp

2581–2584

This function calls ReadAddressFromDebugAddrSection that is called multiple places in DWARFExpression. If we move it to DWARFExpressionList, we need to duplicate the ReadAddressFromDebugAddrSection.

[labath]

In D125509#3586928, @zequanwu wrote:

The main thing I am wondering is if it wouldn't be better to (instead of essentially duplicating the DWARFExpression interface in the DWARFExpressionList class) somehow split the process of finding the appropriate expression (for the given PC value or whatever), and the actual evaluation. This would be particularly nice if the arguments can be split in such a way that those that are used for locating the expression are not repeated in the "evaluate" call. Have you considered this?

Then we need to duplicate the code that gets expression data and register kind before every call to DWARFExpression::Evaluate, making it less clean.

Ok, fair enough.

I noticed one issue (described inline) but other than that, I think this should be ok.

lldb/include/lldb/Expression/DWARFExpressionList.h

30–32

I believe this is equivalent.

104

false would be more correct here ((a<b) == false && (b<a) == false implies a==b, but a<b && b<a is nonsense)

lldb/source/Expression/DWARFExpression.cpp

2581–2584

Ok. If that's the only problem, then I think we can fix that by moving ReadAddressFromDebugAddrSection to the DWARFUnit class (if it does not contain something like that already). IIUC, this is equivalent to getAddrOffsetSectionItem in llvm DWARFUnit, so I'd give it a similar name.

lldb/source/Expression/DWARFExpressionList.cpp

110

Could we make MatchesOperand const (and ditch the Mutable calls above)?

180

I don't think this is correct.

We should be able to distinguish between a location list that is always valid (i.e., one which is not a location list at all), and a location list which happens to contain a single valid range.

That could probably be achieved by making the range of the always-valid entry be (0, UINT_MAX), but maybe it would be better to have an explicit fallback/default entry for this (one that is used when no ranged entry applies). This is how the default location entries in DWARF5 are supposed to work, although I am not sure if any compiler actually makes use of them.

[zequanwu]

Address comments.

[zequanwu]

lldb/source/Expression/DWARFExpressionList.cpp

180

That could probably be achieved by making the range of the always-valid entry be (0, UINT_MAX)

This looks better to me as it saves one default entry and there is no difference in terms of using DWARFExpressionList APIs.
Added IsAlwaysValidSingleExpr to check if it is an always-valid entry and uses it to distinguish between the two kinds.

[labath]

This isn't turning out as clean as I had hoped it would, but I think it's a step in the right direction. Jonas, do you want to say anything about this?

lldb/include/lldb/Expression/DWARFExpressionList.h

55

calling GetExpressionAtAddress without an address seems weird. Maybe just have a separate GetAlwaysValidExpr getter or something?

[zequanwu]

address comment.

[zequanwu]

Ping.

[dyung]

Hi @zequanwu, your change is causing a test failure in the cross-project-test suite on the PS4 linux bot. Can you take a look and revert if you need time to investigate?

https://lab.llvm.org/buildbot/#/builders/217/builds/7945

aggregate-indirect-arg.cpp: nan/nan (nan) [Command '['/usr/bin/python3.8', '/home/buildbot/buildbot-root/llvm-project/cross-project-tests/debuginfo-tests/dexter/dex/../dexter.py', 'run-debugger-internal-', '/tmp/lit-tmp-cjxevz6m/dexter/tmp5dvb0g5o/tmpod7j5lgc', '--working-directory=/tmp/lit-tmp-cjxevz6m/dexter/tmp5dvb0g5o', '--unittest=off', '--indent-timer-level=3']' returned non-zero exit status 1.]

If you need help debugging the dexter failure, @Orlando might be able to help you.

[zequanwu]

In D125509#3637271, @dyung wrote:

Hi @zequanwu, your change is causing a test failure in the cross-project-test suite on the PS4 linux bot. Can you take a look and revert if you need time to investigate?

https://lab.llvm.org/buildbot/#/builders/217/builds/7945

aggregate-indirect-arg.cpp: nan/nan (nan) [Command '['/usr/bin/python3.8', '/home/buildbot/buildbot-root/llvm-project/cross-project-tests/debuginfo-tests/dexter/dex/../dexter.py', 'run-debugger-internal-', '/tmp/lit-tmp-cjxevz6m/dexter/tmp5dvb0g5o/tmpod7j5lgc', '--working-directory=/tmp/lit-tmp-cjxevz6m/dexter/tmp5dvb0g5o', '--unittest=off', '--indent-timer-level=3']' returned non-zero exit status 1.]

If you need help debugging the dexter failure, @Orlando might be able to help you.

Thanks, it should be fixed by https://reviews.llvm.org/rG562c3467a6738aa89203f72fc1d1343e5baadf3c

[JDevlieghere]

This is breaking a bunch of tests on GreenDragon:

lldb-api.functionalities/location-list-lookup.TestLocationListLookup.py
lldb-api.functionalities/param_entry_vals/basic_entry_values.TestBasicEntryValues.py
lldb-api.functionalities/return-value.TestReturnValue.py
lldb-api.lang/c/const_variables.TestConstVariables.py
lldb-api.lang/c/local_variables.TestLocalVariables.py
lldb-api.lang/c/vla.TestVLA.py
lldb-api.lang/objc/objc-optimized.TestObjcOptimized.py

https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/45155/

[JDevlieghere]

I went ahead and reverted your change to turn the bot green again:

commit e4c5bca597a6f12e8f789a53e862387b9808ff48 (HEAD -> main, origin/main, origin/HEAD)
Author: Jonas Devlieghere <[e-mail]>
Date:   Thu Jul 7 16:28:35 2022 -0700

    Revert "[LLDB][NFC] Decouple dwarf location table from DWARFExpression."

    This reverts commit 227dffd0b6d78154516ace45f6ed28259c7baa48 and its
    follow up 562c3467a6738aa89203f72fc1d1343e5baadf3c because it breaks a
    bunch of tests on GreenDragon:

    https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/45155/

lldb/include/lldb/Expression/DWARFExpression.h

 public:
   DWARFExpression();
 
   /// Constructor
   ///
   /// \param[in] data
   ///     A data extractor configured to read the DWARF location expression's
   ///     bytecode.
-  DWARFExpression(lldb::ModuleSP module, const DataExtractor &data,
-                  const DWARFUnit *dwarf_cu);
+  DWARFExpression(const DataExtractor &data);
 
   /// Destructor
   virtual ~DWARFExpression();
 
-  /// Print the description of the expression to a stream
-  ///
-  /// \param[in] s
-  ///     The stream to print to.
-  ///
-  /// \param[in] level
-  ///     The level of verbosity to use.
-  ///
-  /// \param[in] abi
-  ///     An optional ABI plug-in that can be used to resolve register
-  ///     names.
-  void GetDescription(Stream *s, lldb::DescriptionLevel level, ABI *abi) const;
-
   /// 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] 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 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
   /// info.
   ///
+  /// \param[in] dwarf_cu
+  ///     The dwarf unit this expression belongs to.
+  ///
   /// \param[in] op_addr_idx
   ///     The DW_OP_addr index to retrieve in case there is more than
   ///     one DW_OP_addr opcode in the location byte stream.
   ///
   /// \param[out] error
   ///     If the location stream contains unknown DW_OP opcodes or the
   ///     data is missing, \a error will be set to \b true.
   ///
   /// \return
   ///     LLDB_INVALID_ADDRESS if the location doesn't contain a
   ///     DW_OP_addr for \a op_addr_idx, otherwise a valid file address
-  lldb::addr_t GetLocation_DW_OP_addr(uint32_t op_addr_idx, bool &error) const;
+  lldb::addr_t GetLocation_DW_OP_addr(const DWARFUnit *dwarf_cu,
+                                      uint32_t op_addr_idx, bool &error) const;
 
   bool Update_DW_OP_addr(lldb::addr_t file_addr);
 
   void UpdateValue(uint64_t const_value, lldb::offset_t const_value_byte_size,
                    uint8_t addr_byte_size);
 
-  void SetModule(const lldb::ModuleSP &module) { m_module_wp = module; }
-
   bool ContainsThreadLocalStorage() const;
 
   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] 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();
+  lldb::RegisterKind GetRegisterKind() const;
 
   /// 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 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,
-                Value &result, Status *error_ptr) const;
-
   /// Evaluate a DWARF location expression in a particular context
   ///
   /// \param[in] exe_ctx
   ///     The execution context in which to evaluate the location
   ///     expression.  The location expression may access the target's
   ///     memory, especially if it comes from the expression parser.
   ///
   /// \param[in] opcode_ctx
public:
   static bool Evaluate(ExecutionContext *exe_ctx, RegisterContext *reg_ctx,
                        lldb::ModuleSP opcode_ctx, const DataExtractor &opcodes,
                        const DWARFUnit *dwarf_cu,
                        const lldb::RegisterKind reg_set,
                        const Value *initial_value_ptr,
                        const Value *object_address_ptr, Value &result,
                        Status *error_ptr);
 
+  static bool ParseDWARFLocationList(const DWARFUnit *dwarf_cu,
+                                     const DataExtractor &data,
+                                     DWARFExpressionList *loc_list);
+
   bool GetExpressionData(DataExtractor &data) const {
     data = m_data;
     return data.GetByteSize() > 0;
   }
 
-  bool DumpLocationForAddress(Stream *s, lldb::DescriptionLevel level,
-                              lldb::addr_t func_load_addr, lldb::addr_t address,
-                              ABI *abi);
-
-  bool DumpLocations(Stream *s, lldb::DescriptionLevel level,
-                     lldb::addr_t func_load_addr, lldb::addr_t addr, ABI *abi);
-
-  bool GetLocationExpressions(
-      lldb::addr_t load_function_start,
-      llvm::function_ref<bool(llvm::DWARFLocationExpression)> callback) const;
+  void DumpLocation(Stream *s, lldb::DescriptionLevel level, ABI *abi) const;
 
   bool MatchesOperand(StackFrame &frame, const Instruction::Operand &op);
 
-  llvm::Optional<DataExtractor>
-  GetLocationExpression(lldb::addr_t load_function_start,
-                        lldb::addr_t addr) const;
-
 private:
-  /// Pretty-prints the location expression to a stream
-  ///
-  /// \param[in] s
-  ///     The stream to use for pretty-printing.
-  ///
-  /// \param[in] data
-  ///     The data extractor.
-  ///
-  /// \param[in] level
-  ///     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, const DataExtractor &data,
-                    lldb::DescriptionLevel level, ABI *abi) 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 = nullptr;
-
   /// One of the defines that starts with LLDB_REGKIND_
   lldb::RegisterKind m_reg_kind = lldb::eRegisterKindDWARF;
-
-  struct LoclistAddresses {
-    lldb::addr_t cu_file_addr;
-    lldb::addr_t func_file_addr;
-  };
-  llvm::Optional<LoclistAddresses> m_loclist_addresses;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_EXPRESSION_DWARFEXPRESSION_H

lldb/include/lldb/Expression/DWARFExpressionList.h

+//===-- DWARFExpressionList.h ---------------------------------------*- C++
+//-*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_EXPRESSION_DWARFEXPRESSIONLIST_H
+#define LLDB_EXPRESSION_DWARFEXPRESSIONLIST_H
+
+#include "lldb/Expression/DWARFExpression.h"
+#include "lldb/Utility/RangeMap.h"
+#include "lldb/lldb-private.h"
+#include "llvm/ADT/Optional.h"
+
+class DWARFUnit;
+
+namespace lldb_private {
+
+// It's the interface to get or evaluate a DWARFExpression.
+class DWARFExpressionList {
+private:
+  // RangeDataVector requires a comparator for DWARFExpression, but it doesn't
+  // make sense to do so.
+  struct DWARFExpressionCompare {
+  public:
+    bool operator()(const DWARFExpression &lhs,
+                    const DWARFExpression &rhs) const {
+      return true;
+    }
+  };
+
+  // File address range mapping to single dwarf expression.
+  RangeDataVector<lldb::addr_t, lldb::addr_t, DWARFExpression, 0,
+                  DWARFExpressionCompare>
+      m_exprs;
+
+  /// Module which defined this expression.
+  lldb::ModuleWP m_module_wp;
+
+  /// 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 = nullptr;
+
+  typedef RangeDataVector<lldb::addr_t, lldb::addr_t, DWARFExpression, 0,
+                          DWARFExpressionCompare>::Entry Entry;
+
+  void ForAllLocations(const std::function<bool(const Entry *)> &fn) const;
+
+public:
+  DWARFExpressionList() = default;
+
+  DWARFExpressionList(lldb::ModuleSP module_sp, const DWARFUnit *dwarf_cu)
+      : m_module_wp(), m_dwarf_cu(dwarf_cu) {
+    if (module_sp)
+      m_module_wp = module_sp;
+  }
+
+  DWARFExpressionList(lldb::ModuleSP module_sp, DWARFExpression expr,
+                      const DWARFUnit *dwarf_cu)
+      : DWARFExpressionList(module_sp, dwarf_cu) {
+    AddExpression(0, LLDB_INVALID_ADDRESS, expr);
+  }
+
+  /// Return true if the location expression contains data
+  bool IsValid() const { return !m_exprs.IsEmpty(); }
+
+  void Clear() { m_exprs.Clear(); }
+
+  bool AddExpression(lldb::addr_t base, lldb::addr_t end, DWARFExpression expr);
+
+  /// Only useful when the size is equal to 1.
+  bool GetExpressionData(DataExtractor &data) const;
+
+  /// Sort m_expressions.
+  void FinishExpressions() { m_exprs.Sort(); }
+
+  const DWARFExpression *GetExpressionAtAddress(lldb::addr_t file_addr) const;
+
+  DWARFExpression *GetMutableExpressionAtAddress(lldb::addr_t file_addr);
+
+  size_t GetSize() const { return m_exprs.GetSize(); }
+
+  bool ContainsThreadLocalStorage() const;
+
+  bool LinkThreadLocalStorage(
+      lldb::ModuleSP new_module_sp,
+      std::function<lldb::addr_t(lldb::addr_t file_addr)> const
+          &link_address_callback);
+
+  bool MatchesOperand(StackFrame &frame, const Instruction::Operand &operand);
+
+  /// Dump locations that contains file_addr if it's valid. Otherwise. dump all
+  /// locations.
+  bool DumpLocations(Stream *s, lldb::DescriptionLevel level,
+                     lldb::addr_t file_addr, ABI *abi) const;
+
+  /// Dump all locaitons using DWARFLocationTable::dumpLocationList format.
+  void GetDescription(Stream *s, lldb::DescriptionLevel level, ABI *abi) const;
+
+  /// Search for a load address in the location list
+  ///
+  /// \param[in] file_addr
+  ///     The file 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 ContainsAddress(lldb::addr_t file_addr) const;
+
+  void SetModule(const lldb::ModuleSP &module) { m_module_wp = module; }
+
+  bool Evaluate(ExecutionContext *exe_ctx, RegisterContext *reg_ctx,
+                const Value *initial_value_ptr, const Value *object_address_ptr,
+                Value &result, Status *error_ptr) const;
+};
+} // namespace lldb_private
+
+#endif // LLDB_EXPRESSION_DWARFEXPRESSIONLIST_H
 No newline at end of file

lldb/include/lldb/Symbol/Function.h

 //===-- Function.h ----------------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SYMBOL_FUNCTION_H
 #define LLDB_SYMBOL_FUNCTION_H
 
 #include "lldb/Core/AddressRange.h"
 #include "lldb/Core/Declaration.h"
 #include "lldb/Core/Mangled.h"
-#include "lldb/Expression/DWARFExpression.h"
+#include "lldb/Expression/DWARFExpressionList.h"
 #include "lldb/Symbol/Block.h"
 #include "lldb/Utility/UserID.h"
 #include "llvm/ADT/ArrayRef.h"
 
 #include <mutex>
 
 namespace lldb_private {
 

 
 class Function;
 
 /// \class CallSiteParameter Function.h "lldb/Symbol/Function.h"
 ///
 /// Represent the locations of a parameter at a call site, both in the caller
 /// and in the callee.
 struct CallSiteParameter {
-  DWARFExpression LocationInCallee;
-  DWARFExpression LocationInCaller;
+  DWARFExpressionList LocationInCallee;
+  DWARFExpressionList LocationInCaller;
 };
 
 /// A vector of \c CallSiteParameter.
 using CallSiteParameterArray = llvm::SmallVector<CallSiteParameter, 0>;
 
 /// \class CallEdge Function.h "lldb/Symbol/Function.h"
 ///
 /// Represent a call made within a Function. This can be used to find a path

 
 /// An indirect call site. Used to represent call sites where the address of
 /// the callee is not fixed, e.g. a call to a C++ virtual function (where the
 /// address is loaded out of a vtable), or a call to a function pointer in C.
 class IndirectCallEdge : public CallEdge {
 public:
   /// Construct a call edge using a DWARFExpression to identify the callee, and
   /// a return PC within the calling function to identify a specific call site.
-  IndirectCallEdge(DWARFExpression call_target, AddrType caller_address_type,
+  IndirectCallEdge(DWARFExpressionList call_target, AddrType caller_address_type,
                    lldb::addr_t caller_address, bool is_tail_call,
                    CallSiteParameterArray &&parameters)
       : CallEdge(caller_address_type, caller_address, is_tail_call,
                  std::move(parameters)),
         call_target(std::move(call_target)) {}
 
   Function *GetCallee(ModuleList &images, ExecutionContext &exe_ctx) override;
 
 private:
   // Used to describe an indirect call.
   //
   // Specifies the location of the callee address in the calling frame.
-  DWARFExpression call_target;
+  DWARFExpressionList call_target;
 };
 
 /// \class Function Function.h "lldb/Symbol/Function.h"
 /// A class that describes a function.
 ///
 /// Functions belong to CompileUnit objects (Function::m_comp_unit), have
 /// unique user IDs (Function::UserID), know how to reconstruct their symbol
 /// context (Function::SymbolContextScope), have a specific function type
public:
 
   void GetDescription(Stream *s, lldb::DescriptionLevel level, Target *target);
 
   /// Get accessor for the frame base location.
   ///
   /// \return
   ///     A location expression that describes the function frame
   ///     base.
-  DWARFExpression &GetFrameBaseExpression() { return m_frame_base; }
+  DWARFExpressionList &GetFrameBaseExpression() { return m_frame_base; }
 
   /// Get const accessor for the frame base location.
   ///
   /// \return
   ///     A const compile unit object pointer.
-  const DWARFExpression &GetFrameBaseExpression() const { return m_frame_base; }
+  const DWARFExpressionList &GetFrameBaseExpression() const { return m_frame_base; }
 
   ConstString GetName() const;
 
   ConstString GetNameNoArguments() const;
 
   ConstString GetDisplayName() const;
 
   const Mangled &GetMangled() const { return m_mangled; }
protected:
   Block m_block;
 
   /// The function address range that covers the widest range needed to contain
   /// all blocks
   AddressRange m_range;
 
   /// The frame base expression for variables that are relative to the frame
   /// pointer.
-  DWARFExpression m_frame_base;
+  DWARFExpressionList m_frame_base;
 
   Flags m_flags;
 
   /// Compute the prologue size once and cache it.
   uint32_t m_prologue_byte_size;
 
   /// Exclusive lock that controls read/write access to m_call_edges and
   /// m_call_edges_resolved.

lldb/include/lldb/Symbol/Variable.h

 //===-- Variable.h -----------------------------------------------*- C++-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SYMBOL_VARIABLE_H
 #define LLDB_SYMBOL_VARIABLE_H
 
 #include "lldb/Core/Declaration.h"
 #include "lldb/Core/Mangled.h"
-#include "lldb/Expression/DWARFExpression.h"
+#include "lldb/Expression/DWARFExpressionList.h"
 #include "lldb/Utility/CompletionRequest.h"
 #include "lldb/Utility/RangeMap.h"
 #include "lldb/Utility/UserID.h"
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-private.h"
 #include <memory>
 #include <vector>
 
 namespace lldb_private {
 
 class Variable : public UserID, public std::enable_shared_from_this<Variable> {
 public:
   typedef RangeVector<lldb::addr_t, lldb::addr_t> RangeList;
 
   /// Constructors and Destructors.
   ///
   /// \param mangled The mangled or fully qualified name of the variable.
   Variable(lldb::user_id_t uid, const char *name, const char *mangled,
            const lldb::SymbolFileTypeSP &symfile_type_sp, lldb::ValueType scope,
            SymbolContextScope *owner_scope, const RangeList &scope_range,
-           Declaration *decl, const DWARFExpression &location, bool external,
-           bool artificial, bool location_is_constant_data,
+           Declaration *decl, const DWARFExpressionList &location,
+           bool external, bool artificial, bool location_is_constant_data,
            bool static_member = false);
 
   virtual ~Variable();
 
   void Dump(Stream *s, bool show_context) const;
 
   bool DumpDeclaration(Stream *s, bool show_fullpaths, bool show_module);
 
public:
   const RangeList &GetScopeRange() const { return m_scope_range; }
 
   bool IsExternal() const { return m_external; }
 
   bool IsArtificial() const { return m_artificial; }
 
   bool IsStaticMember() const { return m_static_member; }
 
-  DWARFExpression &LocationExpression() { return m_location; }
+  DWARFExpressionList &LocationExpressionList() { return m_location_list; }
 
-  const DWARFExpression &LocationExpression() const { return m_location; }
+  const DWARFExpressionList &LocationExpressionList() const {
+    return m_location_list;
+  }
 
   // When given invalid address, it dumps all locations. Otherwise it only dumps
   // the location that contains this address.
   bool DumpLocations(Stream *s, const Address &address);
 
   size_t MemorySize() const;
 
   void CalculateSymbolContext(SymbolContext *sc);
protected:
   SymbolContextScope *m_owner_scope;
   /// The list of ranges inside the owner's scope where this variable
   /// is valid.
   RangeList m_scope_range;
   /// Declaration location for this item.
   Declaration m_declaration;
   /// The location of this variable that can be fed to
   /// DWARFExpression::Evaluate().
-  DWARFExpression m_location;
+  DWARFExpressionList m_location_list;
   /// Visible outside the containing compile unit?
   unsigned m_external : 1;
   /// Non-zero if the variable is not explicitly declared in source.
   unsigned m_artificial : 1;
   /// The m_location expression contains the constant variable value
   /// data, not a DWARF location.
   unsigned m_loc_is_const_data : 1;
   /// Non-zero if variable is static member of a class or struct.

lldb/include/lldb/Target/StackFrame.h

public:
   ///   If there is an error determining the CFA address, this may contain a
   ///   string explaining the failure.
   ///
   /// \return
   ///   Returns true if the CFA value was successfully set in value.  Some
   ///   frames may be unable to provide this value; they will return false.
   bool GetFrameBaseValue(Scalar &value, Status *error_ptr);
 
-  /// Get the DWARFExpression corresponding to the Canonical Frame Address.
+  /// Get the DWARFExpressionList corresponding to the Canonical Frame Address.
   ///
   /// Often a register (bp), but sometimes a register + offset.
   ///
   /// \param [out] error_ptr
   ///   If there is an error determining the CFA address, this may contain a
   ///   string explaining the failure.
   ///
   /// \return
   ///   Returns the corresponding DWARF expression, or NULL.
-  DWARFExpression *GetFrameBaseExpression(Status *error_ptr);
+  DWARFExpressionList *GetFrameBaseExpression(Status *error_ptr);
 
   /// Get the current lexical scope block for this StackFrame, if possible.
   ///
   /// If debug information is available for this stack frame, return a pointer
   /// to the innermost lexical Block that the frame is currently executing.
   ///
   /// \return
   ///   A pointer to the current Block.  nullptr is returned if this can

lldb/include/lldb/lldb-forward.h

 class CompilerType;
 class Connection;
 class ConnectionFileDescriptor;
 class ConstString;
 class ConstStringTable;
 class DWARFCallFrameInfo;
 class DWARFDataExtractor;
 class DWARFExpression;
+class DWARFExpressionList;
 class DataBuffer;
 class WritableDataBuffer;
 class DataBufferHeap;
 class DataEncoder;
 class DataExtractor;
 class DataFileCache;
 class Debugger;
 class Declaration;

lldb/source/Core/ValueObjectVariable.cpp

 //===-- ValueObjectVariable.cpp -------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/ValueObjectVariable.h"
 
 #include "lldb/Core/Address.h"
 #include "lldb/Core/AddressRange.h"
 #include "lldb/Core/Declaration.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Value.h"
-#include "lldb/Expression/DWARFExpression.h"
+#include "lldb/Expression/DWARFExpressionList.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/SymbolContextScope.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/Variable.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
lldb::ValueType ValueObjectVariable::GetValueType() const {
   return lldb::eValueTypeInvalid;
 }
 
 bool ValueObjectVariable::UpdateValue() {
   SetValueIsValid(false);
   m_error.Clear();
 
   Variable *variable = m_variable_sp.get();
-  DWARFExpression &expr = variable->LocationExpression();
+  DWARFExpressionList &expr_list = variable->LocationExpressionList();
 
   if (variable->GetLocationIsConstantValueData()) {
     // expr doesn't contain DWARF bytes, it contains the constant variable
     // value bytes themselves...
-    if (expr.GetExpressionData(m_data)) {
-       if (m_data.GetDataStart() && m_data.GetByteSize())
+    if (expr_list.GetExpressionData(m_data)) {
         m_value.SetBytes(m_data.GetDataStart(), m_data.GetByteSize());
       m_value.SetContext(Value::ContextType::Variable, variable);
-    }
-    else
+    } else
       m_error.SetErrorString("empty constant data");
     // constant bytes can't be edited - sorry
     m_resolved_value.SetContext(Value::ContextType::Invalid, nullptr);
   } else {
-    lldb::addr_t loclist_base_load_addr = LLDB_INVALID_ADDRESS;
     ExecutionContext exe_ctx(GetExecutionContextRef());
 
     Target *target = exe_ctx.GetTargetPtr();
     if (target) {
       m_data.SetByteOrder(target->GetArchitecture().GetByteOrder());
       m_data.SetAddressByteSize(target->GetArchitecture().GetAddressByteSize());
     }
 
-    if (expr.IsLocationList()) {
-      SymbolContext sc;
-      variable->CalculateSymbolContext(&sc);
-      if (sc.function)
-        loclist_base_load_addr =
-            sc.function->GetAddressRange().GetBaseAddress().GetLoadAddress(
-                target);
-    }
     Value old_value(m_value);
-    if (expr.Evaluate(&exe_ctx, nullptr, loclist_base_load_addr, nullptr,
-                      nullptr, m_value, &m_error)) {
+    if (expr_list.Evaluate(&exe_ctx, nullptr, nullptr, nullptr, m_value, &m_error)) {
       m_resolved_value = m_value;
       m_value.SetContext(Value::ContextType::Variable, variable);
 
       CompilerType compiler_type = GetCompilerType();
       if (compiler_type.IsValid())
         m_value.SetCompilerType(compiler_type);
 
       Value::ValueType value_type = m_value.GetValueType();
if (expr_list.Evaluate(&exe_ctx, nullptr, nullptr, nullptr, m_value, &m_error)) {
       }
 
       SetValueIsValid(m_error.Success());
     } else {
       // could not find location, won't allow editing
       m_resolved_value.SetContext(Value::ContextType::Invalid, nullptr);
     }
   }
-  
   return m_error.Success();
 }
 
 void ValueObjectVariable::DoUpdateChildrenAddressType(ValueObject &valobj) {
   Value::ValueType value_type = valobj.GetValue().GetValueType();
   ExecutionContext exe_ctx(GetExecutionContextRef());
   Process *process = exe_ctx.GetProcessPtr();
   const bool process_is_alive = process && process->IsAlive();

lldb/source/Expression/CMakeLists.txt

 add_lldb_library(lldbExpression
   DiagnosticManager.cpp
   DWARFExpression.cpp
+  DWARFExpressionList.cpp
   Expression.cpp
   ExpressionVariable.cpp
   FunctionCaller.cpp
   IRExecutionUnit.cpp
   IRInterpreter.cpp
   IRMemoryMap.cpp
   LLVMUserExpression.cpp
   Materializer.cpp

lldb/source/Expression/DWARFExpression.cpp

ReadAddressFromDebugAddrSection(const DWARFUnit *dwarf_cu,
   const DWARFDataExtractor &data =
       dwarf_cu->GetSymbolFileDWARF().GetDWARFContext().getOrLoadAddrData();
   if (data.ValidOffsetForDataOfSize(offset, index_size))
     return data.GetMaxU64_unchecked(&offset, index_size);
   return LLDB_INVALID_ADDRESS;
 }
 
 // DWARFExpression constructor
-DWARFExpression::DWARFExpression() : m_module_wp(), m_data() {}
+DWARFExpression::DWARFExpression() : m_data() {}
 
-DWARFExpression::DWARFExpression(lldb::ModuleSP module_sp,
-                                 const DataExtractor &data,
-                                 const DWARFUnit *dwarf_cu)
-    : m_module_wp(), m_data(data), m_dwarf_cu(dwarf_cu) {
-  if (module_sp)
-    m_module_wp = module_sp;
-}
+DWARFExpression::DWARFExpression(const DataExtractor &data) : m_data(data) {}
 
 // Destructor
 DWARFExpression::~DWARFExpression() = default;
 
 bool DWARFExpression::IsValid() const { return m_data.GetByteSize() > 0; }
 
 void DWARFExpression::UpdateValue(uint64_t const_value,
                                   lldb::offset_t const_value_byte_size,
                                   uint8_t addr_byte_size) {
   if (!const_value_byte_size)
     return;
 
   m_data.SetData(
       DataBufferSP(new DataBufferHeap(&const_value, const_value_byte_size)));
   m_data.SetByteOrder(endian::InlHostByteOrder());
   m_data.SetAddressByteSize(addr_byte_size);
 }
 
-void DWARFExpression::DumpLocation(Stream *s, const DataExtractor &data,
-                                   lldb::DescriptionLevel level,
+void DWARFExpression::DumpLocation(Stream *s, lldb::DescriptionLevel level,
                                    ABI *abi) const {
-  llvm::DWARFExpression(data.GetAsLLVM(), data.GetAddressByteSize())
+  llvm::DWARFExpression(m_data.GetAsLLVM(), m_data.GetAddressByteSize())
       .print(s->AsRawOstream(), llvm::DIDumpOptions(),
              abi ? &abi->GetMCRegisterInfo() : nullptr, nullptr);
 }
 
-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; }
+RegisterKind DWARFExpression::GetRegisterKind() const { return m_reg_kind; }
 
 void DWARFExpression::SetRegisterKind(RegisterKind reg_kind) {
   m_reg_kind = reg_kind;
 }
 
-bool DWARFExpression::IsLocationList() const {
-  return bool(m_loclist_addresses);
-}
-
-namespace {
-/// Implement enough of the DWARFObject interface in order to be able to call
-/// DWARFLocationTable::dumpLocationList. We don't have access to a real
-/// DWARFObject here because DWARFExpression is used in non-DWARF scenarios too.
-class DummyDWARFObject final: public llvm::DWARFObject {
-public:
-  DummyDWARFObject(bool IsLittleEndian) : IsLittleEndian(IsLittleEndian) {}
-
-  bool isLittleEndian() const override { return IsLittleEndian; }
-
-  llvm::Optional<llvm::RelocAddrEntry> find(const llvm::DWARFSection &Sec,
-                                            uint64_t Pos) const override {
-    return llvm::None;
-  }
-private:
-  bool IsLittleEndian;
-};
-}
-
-void DWARFExpression::GetDescription(Stream *s, lldb::DescriptionLevel level,
-                                     ABI *abi) const {
-  if (IsLocationList()) {
-    // We have a location list
-    lldb::offset_t offset = 0;
-    std::unique_ptr<llvm::DWARFLocationTable> loctable_up =
-        m_dwarf_cu->GetLocationTable(m_data);
-
-    llvm::MCRegisterInfo *MRI = abi ? &abi->GetMCRegisterInfo() : nullptr;
-    llvm::DIDumpOptions DumpOpts;
-    DumpOpts.RecoverableErrorHandler = [&](llvm::Error E) {
-      s->AsRawOstream() << "error: " << toString(std::move(E));
-    };
-    loctable_up->dumpLocationList(
-        &offset, s->AsRawOstream(),
-        llvm::object::SectionedAddress{m_loclist_addresses->cu_file_addr}, MRI,
-        DummyDWARFObject(m_data.GetByteOrder() == eByteOrderLittle), nullptr,
-        DumpOpts, s->GetIndentLevel() + 2);
-  } else {
-    // We have a normal location that contains DW_OP location opcodes
-    DumpLocation(s, m_data, level, abi);
-  }
-}
 
 static bool ReadRegisterValueAsScalar(RegisterContext *reg_ctx,
                                       lldb::RegisterKind reg_kind,
                                       uint32_t reg_num, Status *error_ptr,
                                       Value &value) {
   if (reg_ctx == nullptr) {
     if (error_ptr)
       error_ptr->SetErrorString("No register context in frame.\n");
static offset_t GetOpcodeDataSize(const DataExtractor &data,
   }
 
   default:
     break;
   }
   return LLDB_INVALID_OFFSET;
 }
 
-lldb::addr_t DWARFExpression::GetLocation_DW_OP_addr(uint32_t op_addr_idx,
+lldb::addr_t DWARFExpression::GetLocation_DW_OP_addr(const DWARFUnit *dwarf_cu,
+                                                     uint32_t op_addr_idx,
                                                      bool &error) const {
   error = false;
-  if (IsLocationList())
-    return LLDB_INVALID_ADDRESS;
   lldb::offset_t offset = 0;
   uint32_t curr_op_addr_idx = 0;
   while (m_data.ValidOffset(offset)) {
     const uint8_t op = m_data.GetU8(&offset);
 
     if (op == DW_OP_addr) {
       const lldb::addr_t op_file_addr = m_data.GetAddress(&offset);
       if (curr_op_addr_idx == op_addr_idx)
         return op_file_addr;
-      else
-        ++curr_op_addr_idx;
     } else if (op == DW_OP_GNU_addr_index || op == DW_OP_addrx) {
       uint64_t index = m_data.GetULEB128(&offset);
       if (curr_op_addr_idx == op_addr_idx) {
-        if (!m_dwarf_cu) {
+        if (!dwarf_cu) {
           error = true;
           break;
         }
 
-        return ReadAddressFromDebugAddrSection(m_dwarf_cu, index);
-      } else
-        ++curr_op_addr_idx;
+        return ReadAddressFromDebugAddrSection(dwarf_cu, index);
+      }
     } else {
       const offset_t op_arg_size = GetOpcodeDataSize(m_data, offset, op);
       if (op_arg_size == LLDB_INVALID_OFFSET) {
         error = true;
         break;
       }
       offset += op_arg_size;
     }
   }
   return LLDB_INVALID_ADDRESS;
 }
 
 bool DWARFExpression::Update_DW_OP_addr(lldb::addr_t file_addr) {
-  if (IsLocationList())
-    return false;
   lldb::offset_t offset = 0;
   while (m_data.ValidOffset(offset)) {
     const uint8_t op = m_data.GetU8(&offset);
 
     if (op == DW_OP_addr) {
       const uint32_t addr_byte_size = m_data.GetAddressByteSize();
       // We have to make a copy of the data as we don't know if this data is
       // from a read only memory mapped buffer, so we duplicate all of the data
if (op == DW_OP_addr) {
         break;
       offset += op_arg_size;
     }
   }
   return false;
 }
 
 bool DWARFExpression::ContainsThreadLocalStorage() const {
-  // We are assuming for now that any thread local variable will not have a
-  // location list. This has been true for all thread local variables we have
-  // seen so far produced by any compiler.
-  if (IsLocationList())
-    return false;
   lldb::offset_t offset = 0;
   while (m_data.ValidOffset(offset)) {
     const uint8_t op = m_data.GetU8(&offset);
 
     if (op == DW_OP_form_tls_address || op == DW_OP_GNU_push_tls_address)
       return true;
     const offset_t op_arg_size = GetOpcodeDataSize(m_data, offset, op);
     if (op_arg_size == LLDB_INVALID_OFFSET)
       return false;
-    else
-      offset += op_arg_size;
   }
   return false;
 }
 bool DWARFExpression::LinkThreadLocalStorage(
-    lldb::ModuleSP new_module_sp,
     std::function<lldb::addr_t(lldb::addr_t file_addr)> const
         &link_address_callback) {
-  // We are assuming for now that any thread local variable will not have a
-  // location list. This has been true for all thread local variables we have
-  // seen so far produced by any compiler.
-  if (IsLocationList())
-    return false;
-
   const uint32_t addr_byte_size = m_data.GetAddressByteSize();
   // We have to make a copy of the data as we don't know if this data is from a
   // read only memory mapped buffer, so we duplicate all of the data first,
   // then modify it, and if all goes well, we then replace the data for this
   // expression.
-
   // Make en encoder that contains a copy of the location expression data so we
   // can write the address into the buffer using the correct byte order.
   DataEncoder encoder(m_data.GetDataStart(), m_data.GetByteSize(),
                       m_data.GetByteOrder(), addr_byte_size);
 
   lldb::offset_t offset = 0;
   lldb::offset_t const_offset = 0;
   lldb::addr_t const_value = 0;
if (!decoded_data) {
       const offset_t op_arg_size = GetOpcodeDataSize(m_data, offset, op);
       if (op_arg_size == LLDB_INVALID_OFFSET)
         return false;
       else
         offset += op_arg_size;
     }
   }
 
-  // If we linked the TLS address correctly, update the module so that when the
-  // 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(encoder.GetDataBuffer());
   return true;
 }
 
-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())
-    return false;
-
-  return GetLocationExpression(func_load_addr, addr) != llvm::None;
-}
-
-bool DWARFExpression::DumpLocationForAddress(Stream *s,
-                                             lldb::DescriptionLevel level,
-                                             addr_t func_load_addr,
-                                             addr_t address, ABI *abi) {
-  if (!IsLocationList()) {
-    DumpLocation(s, m_data, level, abi);
-    return true;
-  }
-  if (llvm::Optional<DataExtractor> expr =
-          GetLocationExpression(func_load_addr, address)) {
-    DumpLocation(s, *expr, level, abi);
-    return true;
-  }
-  return false;
-}
-
 static bool Evaluate_DW_OP_entry_value(std::vector<Value> &stack,
                                        ExecutionContext *exe_ctx,
                                        RegisterContext *reg_ctx,
                                        const DataExtractor &opcodes,
                                        lldb::offset_t &opcode_offset,
                                        Status *error_ptr, Log *log) {
   // DW_OP_entry_value(sub-expr) describes the location a variable had upon
   // function entry: this variable location is presumed to be optimized out at
static bool Evaluate_DW_OP_entry_value(std::vector<Value> &stack,
   if (!subexpr_data) {
     LLDB_LOG(log, "Evaluate_DW_OP_entry_value: subexpr could not be read");
     return false;
   }
 
   const CallSiteParameter *matched_param = nullptr;
   for (const CallSiteParameter &param : call_edge->GetCallSiteParameters()) {
     DataExtractor param_subexpr_extractor;
-    if (!param.LocationInCallee.GetExpressionData(param_subexpr_extractor))
+    if (!param.LocationInCallee.GetExpressionAtAddress(0)->GetExpressionData(
+            param_subexpr_extractor))
       continue;
     lldb::offset_t param_subexpr_offset = 0;
     const void *param_subexpr_data =
         param_subexpr_extractor.GetData(&param_subexpr_offset, subexpr_len);
     if (!param_subexpr_data ||
         param_subexpr_extractor.BytesLeft(param_subexpr_offset) != 0)
       continue;
 
if (!matched_param) {
     LLDB_LOG(log,
              "Evaluate_DW_OP_entry_value: no matching call site param found");
     return false;
   }
 
   // TODO: Add support for DW_OP_push_object_address within a DW_OP_entry_value
   // subexpresion whenever llvm does.
   Value result;
-  const DWARFExpression &param_expr = matched_param->LocationInCaller;
+  const DWARFExpressionList &param_expr = matched_param->LocationInCaller;
   if (!param_expr.Evaluate(&parent_exe_ctx,
                            parent_frame->GetRegisterContext().get(),
-                           /*loclist_base_load_addr=*/LLDB_INVALID_ADDRESS,
                            /*initial_value_ptr=*/nullptr,
                            /*object_address_ptr=*/nullptr, result, error_ptr)) {
     LLDB_LOG(log,
              "Evaluate_DW_OP_entry_value: call site param evaluation failed");
     return false;
   }
 
   stack.push_back(result);
   return true;
 }
 
-bool DWARFExpression::Evaluate(ExecutionContextScope *exe_scope,
-                               lldb::addr_t loclist_base_load_addr,
-                               const Value *initial_value_ptr,
-                               const Value *object_address_ptr, Value &result,
-                               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 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()) {
-    Address pc;
-    StackFrame *frame = nullptr;
-    if (!reg_ctx || !reg_ctx->GetPCForSymbolication(pc)) {
-      frame = exe_ctx->GetFramePtr();
-      if (!frame)
-        return false;
-      RegisterContextSP reg_ctx_sp = frame->GetRegisterContext();
-      if (!reg_ctx_sp)
-        return false;
-      reg_ctx_sp->GetPCForSymbolication(pc);
-    }
-
-    if (func_load_addr != LLDB_INVALID_ADDRESS) {
-      if (!pc.IsValid()) {
-        if (error_ptr)
-          error_ptr->SetErrorString("Invalid PC in frame.");
-        return false;
-      }
-
-      Target *target = exe_ctx->GetTargetPtr();
-      if (llvm::Optional<DataExtractor> expr = GetLocationExpression(
-              func_load_addr, pc.GetLoadAddress(target))) {
-        return DWARFExpression::Evaluate(
-            exe_ctx, reg_ctx, module_sp, *expr, m_dwarf_cu, m_reg_kind,
-            initial_value_ptr, object_address_ptr, result, error_ptr);
-      }
-    }
-    if (error_ptr)
-      error_ptr->SetErrorString("variable not available");
-    return false;
-  }
-
-  // Not a location list, just a single expression.
-  return DWARFExpression::Evaluate(exe_ctx, reg_ctx, module_sp, m_data,
-                                   m_dwarf_cu, m_reg_kind, initial_value_ptr,
-                                   object_address_ptr, result, error_ptr);
-}
-
 namespace {
 /// The location description kinds described by the DWARF v5
 /// specification.  Composite locations are handled out-of-band and
 /// thus aren't part of the enum.
 enum LocationDescriptionKind {
   Empty,
   Memory,
   Register,
for (size_t i = 0; i < count; ++i) {
       stack[i].Dump(&new_value);
       LLDB_LOGF(log, "  %s", new_value.GetData());
     }
   }
   result = stack.back();
   return true; // Return true on success
 }
 
-static DataExtractor ToDataExtractor(const llvm::DWARFLocationExpression &loc,
-                                     ByteOrder byte_order, uint32_t addr_size) {
-  auto buffer_sp =
-      std::make_shared<DataBufferHeap>(loc.Expr.data(), loc.Expr.size());
-  return DataExtractor(buffer_sp, byte_order, addr_size);
-}
-
-bool DWARFExpression::DumpLocations(Stream *s, lldb::DescriptionLevel level,
-                                    addr_t load_function_start, addr_t addr,
-                                    ABI *abi) {
-  if (!IsLocationList()) {
-    DumpLocation(s, m_data, level, abi);
-    return true;
-  }
-  bool dump_all = addr == LLDB_INVALID_ADDRESS;
-  llvm::ListSeparator separator;
-  auto callback = [&](llvm::DWARFLocationExpression loc) -> bool {
-    if (loc.Range &&
-        (dump_all || (loc.Range->LowPC <= addr && addr < loc.Range->HighPC))) {
-      uint32_t addr_size = m_data.GetAddressByteSize();
-      DataExtractor data = ToDataExtractor(loc, m_data.GetByteOrder(),
-                                           m_data.GetAddressByteSize());
-      s->AsRawOstream() << separator;
-      s->PutCString("[");
-      s->AsRawOstream() << llvm::format_hex(loc.Range->LowPC,
-                                            2 + 2 * addr_size);
-      s->PutCString(", ");
-      s->AsRawOstream() << llvm::format_hex(loc.Range->HighPC,
-                                            2 + 2 * addr_size);
-      s->PutCString(") -> ");
-      DumpLocation(s, data, level, abi);
-      return dump_all;
-    }
-    return true;
-  };
-  if (!GetLocationExpressions(load_function_start, callback))
-    return false;
-  return true;
-}
-
-bool DWARFExpression::GetLocationExpressions(
-    addr_t load_function_start,
-    llvm::function_ref<bool(llvm::DWARFLocationExpression)> callback) const {
-  if (load_function_start == LLDB_INVALID_ADDRESS)
-    return false;
-
-  Log *log = GetLog(LLDBLog::Expressions);
-
+bool DWARFExpression::ParseDWARFLocationList(
+    const DWARFUnit *dwarf_cu, const DataExtractor &data,
+    DWARFExpressionList *location_list) {
+  location_list->Clear();
   std::unique_ptr<llvm::DWARFLocationTable> loctable_up =
-      m_dwarf_cu->GetLocationTable(m_data);
-
-  uint64_t offset = 0;
+      dwarf_cu->GetLocationTable(data);
   auto lookup_addr =
       [&](uint32_t index) -> llvm::Optional<llvm::object::SectionedAddress> {
-    addr_t address = ReadAddressFromDebugAddrSection(m_dwarf_cu, index);
+    addr_t address = ReadAddressFromDebugAddrSection(dwarf_cu, index);
     if (address == LLDB_INVALID_ADDRESS)
       return llvm::None;
     return llvm::object::SectionedAddress{address};
   };
   auto process_list = [&](llvm::Expected<llvm::DWARFLocationExpression> loc) {
-    if (!loc) {
-      LLDB_LOG_ERROR(log, loc.takeError(), "{0}");
-      return true;
-    }
-    if (loc->Range) {
-      // This relocates low_pc and high_pc by adding the difference between the
-      // function file address, and the actual address it is loaded in memory.
-      addr_t slide = load_function_start - m_loclist_addresses->func_file_addr;
-      loc->Range->LowPC += slide;
-      loc->Range->HighPC += slide;
-    }
-    return callback(*loc);
+    if (!loc)
+      return true;
+    auto buffer_sp =
+        std::make_shared<DataBufferHeap>(loc->Expr.data(), loc->Expr.size());
+    DWARFExpression expr = DWARFExpression(DataExtractor(
+        buffer_sp, data.GetByteOrder(), data.GetAddressByteSize()));
+    location_list->AddExpression(loc->Range->LowPC, loc->Range->HighPC, expr);
   };
   llvm::Error error = loctable_up->visitAbsoluteLocationList(
-      offset, llvm::object::SectionedAddress{m_loclist_addresses->cu_file_addr},
+      0, llvm::object::SectionedAddress{dwarf_cu->GetBaseAddress()},
       lookup_addr, process_list);
+  Log *log = GetLog(LLDBLog::Expressions);
   if (error) {
     LLDB_LOG_ERROR(log, std::move(error), "{0}");
     return false;
   }
   return true;
 }
 
-llvm::Optional<DataExtractor>
-DWARFExpression::GetLocationExpression(addr_t load_function_start,
-                                       addr_t addr) const {
-  llvm::Optional<DataExtractor> data;
-  auto callback = [&](llvm::DWARFLocationExpression loc) {
-    if (loc.Range && loc.Range->LowPC <= addr && addr < loc.Range->HighPC) {
-      data = ToDataExtractor(loc, m_data.GetByteOrder(),
-                             m_data.GetAddressByteSize());
-    }
-    return !data;
-  };
-  GetLocationExpressions(load_function_start, callback);
-  return data;
-}
-
 bool DWARFExpression::MatchesOperand(StackFrame &frame,
                                      const Instruction::Operand &operand) {
   using namespace OperandMatchers;
 
   RegisterContextSP reg_ctx_sp = frame.GetRegisterContext();
   if (!reg_ctx_sp) {
     return false;
   }
 
-  DataExtractor opcodes;
-  if (IsLocationList()) {
-    SymbolContext sc = frame.GetSymbolContext(eSymbolContextFunction);
-    if (!sc.function)
-      return false;
-
-    addr_t load_function_start =
-        sc.function->GetAddressRange().GetBaseAddress().GetFileAddress();
-    if (load_function_start == LLDB_INVALID_ADDRESS)
-      return false;
-
-    addr_t pc = frame.GetFrameCodeAddressForSymbolication().GetLoadAddress(
-        frame.CalculateTarget().get());
-
-    if (llvm::Optional<DataExtractor> expr =
-            GetLocationExpression(load_function_start, pc))
-      opcodes = std::move(*expr);
-    else
-      return false;
-  } else
-    opcodes = m_data;
-
+  DataExtractor opcodes(m_data);
 
   lldb::offset_t op_offset = 0;
   uint8_t opcode = opcodes.GetU8(&op_offset);
 
   if (opcode == DW_OP_fbreg) {
     int64_t offset = opcodes.GetSLEB128(&op_offset);
 
-    DWARFExpression *fb_expr = frame.GetFrameBaseExpression(nullptr);
+    DWARFExpressionList *fb_expr = frame.GetFrameBaseExpression(nullptr);
     if (!fb_expr) {
       return false;
     }
 
     auto recurse = [&frame, fb_expr](const Instruction::Operand &child) {
       return fb_expr->MatchesOperand(frame, child);
     };
 

lldb/source/Expression/DWARFExpressionList.cpp

+//===-- DWARFExpressionList.cpp -------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Expression/DWARFExpressionList.h"
+#include "Plugins/SymbolFile/DWARF/DWARFUnit.h"
+#include "lldb/Symbol/Function.h"
+#include "lldb/Target/RegisterContext.h"
+#include "lldb/Target/StackFrame.h"
+#include "llvm/DebugInfo/DWARF/DWARFDebugLoc.h"
+#include "llvm/DebugInfo/DWARF/DWARFFormValue.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+bool DWARFExpressionList::AddExpression(addr_t base, addr_t end,
+                                        DWARFExpression expr) {
+  if (base >= end)
+    return false;
+  m_exprs.Append({base, end - base, expr});
+  return true;
+}
+
+bool DWARFExpressionList::GetExpressionData(DataExtractor &data) const {
+  if (m_exprs.GetSize() != 1)
+    return false;
+  return m_exprs.Back()->data.GetExpressionData(data);
+}
+
+bool DWARFExpressionList::ContainsAddress(lldb::addr_t file_addr) const {
+  return m_exprs.FindEntryThatContains(file_addr) != nullptr;
+}
+
+const DWARFExpression *
+DWARFExpressionList::GetExpressionAtAddress(lldb::addr_t file_addr) const {
+  uint32_t index = m_exprs.FindEntryIndexThatContains(file_addr);
+  if (index == UINT32_MAX)
+    return nullptr;
+  return &m_exprs.GetEntryAtIndex(index)->data;
+}
+
+DWARFExpression *
+DWARFExpressionList::GetMutableExpressionAtAddress(lldb::addr_t file_addr) {
+  uint32_t index = m_exprs.FindEntryIndexThatContains(file_addr);
+  if (index == UINT32_MAX)
+    return nullptr;
+  return &m_exprs.GetMutableEntryAtIndex(index)->data;
+}
+
+bool DWARFExpressionList::ContainsThreadLocalStorage() const {
+  // We are assuming for now that any thread local variable will not have a
+  // location list. This has been true for all thread local variables we have
+  // seen so far produced by any compiler.
+  if (m_exprs.GetSize() != 1)
+    return false;
+
+  const DWARFExpression &expr = m_exprs.GetEntryRef(0).data;
+  return expr.ContainsThreadLocalStorage();
+}
+
+bool DWARFExpressionList::LinkThreadLocalStorage(
+    lldb::ModuleSP new_module_sp,
+    std::function<lldb::addr_t(lldb::addr_t file_addr)> const
+        &link_address_callback) {
+  // We are assuming for now that any thread local variable will not have a
+  // location list. This has been true for all thread local variables we have
+  // seen so far produced by any compiler.
+  if (m_exprs.GetSize() != 1)
+    return false;
+
+  DWARFExpression &expr = m_exprs.GetEntryRef(0).data;
+  // If we linked the TLS address correctly, update the module so that when the
+  // expression is evaluated it can resolve the file address to a load address
+  // and read the TLS data
+  if (expr.LinkThreadLocalStorage(link_address_callback))
+    m_module_wp = new_module_sp;
+  return true;
+}
+
+bool DWARFExpressionList::MatchesOperand(StackFrame &frame,
+                                         const Instruction::Operand &operand) {
+  RegisterContextSP reg_ctx_sp = frame.GetRegisterContext();
+  if (!reg_ctx_sp) {
+    return false;
+  }
+  DWARFExpression *expr = nullptr;
+  if (m_exprs.GetSize() == 1)
+    expr = &m_exprs.GetMutableEntryAtIndex(0)->data;
+  else {
+    SymbolContext sc = frame.GetSymbolContext(eSymbolContextFunction);
+    if (!sc.function)
+      return false;
+
+    addr_t load_function_start =
+        sc.function->GetAddressRange().GetBaseAddress().GetFileAddress();
+    if (load_function_start == LLDB_INVALID_ADDRESS)
+      return false;
+
+    addr_t pc = frame.GetFrameCodeAddressForSymbolication().GetFileAddress();
+    expr = GetMutableExpressionAtAddress(pc);
+  }
+  if (!expr)
+    return false;
+  return expr->MatchesOperand(frame, operand);
+}
+
+void DWARFExpressionList::ForAllLocations(
+    const std::function<bool(const Entry *)> &fn) const {
+  for (size_t i = 0; i < m_exprs.GetSize(); ++i) {
+    if (!fn(m_exprs.GetEntryAtIndex(i)))
+      break;
+  }
+}
+
+bool DWARFExpressionList::DumpLocations(Stream *s, lldb::DescriptionLevel level,
+                                        lldb::addr_t file_addr,
+                                        ABI *abi) const {
+  llvm::raw_ostream &os = s->AsRawOstream();
+  llvm::ListSeparator separator;
+  ForAllLocations([&](const Entry *entry) {
+    if (file_addr != LLDB_INVALID_ADDRESS &&
+        (file_addr < entry->GetRangeBase() ||
+         file_addr >= entry->GetRangeEnd()))
+      return true;
+    const auto &expr = entry->data;
+    DataExtractor data;
+    expr.GetExpressionData(data);
+    uint32_t addr_size = data.GetAddressByteSize();
+    if (entry->GetRangeEnd() == LLDB_INVALID_ADDRESS) {
+      expr.DumpLocation(s, level, abi);
+      return false;
+    }
+
+    os << separator;
+    os << "[";
+    os << llvm::format_hex(entry->GetRangeBase(), 2 + 2 * addr_size);
+    os << ", ";
+    os << llvm::format_hex(entry->GetRangeEnd(), 2 + 2 * addr_size);
+    os << ") -> ";
+    expr.DumpLocation(s, level, abi);
+    if (file_addr != LLDB_INVALID_ADDRESS)
+      return false;
+    return true;
+  });
+  return true;
+}
+
+void DWARFExpressionList::GetDescription(Stream *s,
+                                         lldb::DescriptionLevel level,
+                                         ABI *abi) const {
+  llvm::raw_ostream &os = s->AsRawOstream();
+  if (m_exprs.GetSize() == 1 &&
+      m_exprs.Back()->GetRangeEnd() == LLDB_INVALID_ADDRESS) {
+    m_exprs.Back()->data.DumpLocation(s, level, abi);
+    return;
+  }
+  os << llvm::format("0x%8.8" PRIx64 ": ", 0);
+  ForAllLocations([&](const Entry *entry) {
+    const auto &expr = entry->data;
+    DataExtractor data;
+    expr.GetExpressionData(data);
+    uint32_t addr_size = data.GetAddressByteSize();
+    os << "\n";
+    os.indent(s->GetIndentLevel() + 2);
+    os << "[";
+    llvm::DWARFFormValue::dumpAddress(os, addr_size, entry->GetRangeBase());
+    os << ", ";
+    llvm::DWARFFormValue::dumpAddress(os, addr_size, entry->GetRangeEnd());
+    os << "): ";
+    expr.DumpLocation(s, level, abi);
+    return true;
+  });
+}
+
+bool DWARFExpressionList::Evaluate(ExecutionContext *exe_ctx,
+                                   RegisterContext *reg_ctx,
+                                   const Value *initial_value_ptr,
+                                   const Value *object_address_ptr,
+                                   Value &result, Status *error_ptr) const {
+  ModuleSP module_sp = m_module_wp.lock();
+  DataExtractor data;
+  RegisterKind reg_kind;
+  DWARFExpression expr;
+  if (m_exprs.GetSize() == 1) {
+    expr = m_exprs.Back()->data;
+  } else {
+    Address pc;
+    StackFrame *frame = nullptr;
+    if (!reg_ctx || !reg_ctx->GetPCForSymbolication(pc)) {
+      if (exe_ctx)
+        frame = exe_ctx->GetFramePtr();
+      if (!frame)
+        return false;
+      RegisterContextSP reg_ctx_sp = frame->GetRegisterContext();
+      if (!reg_ctx_sp)
+        return false;
+      reg_ctx_sp->GetPCForSymbolication(pc);
+    }
+
+    if (!pc.IsValid()) {
+      if (error_ptr)
+        error_ptr->SetErrorString("Invalid PC in frame.");
+      return false;
+    }
+    addr_t addr = pc.GetFileAddress();
+    const auto *entry = m_exprs.FindEntryThatContains(addr);
+    if (!entry)
+      return false;
+    expr = entry->data;
+  }
+  expr.GetExpressionData(data);
+  reg_kind = expr.GetRegisterKind();
+  return DWARFExpression::Evaluate(exe_ctx, reg_ctx, module_sp, data,
+                                   m_dwarf_cu, reg_kind, initial_value_ptr,
+                                   object_address_ptr, result, error_ptr);
+}

lldb/source/Expression/Materializer.cpp

if (m_is_reference) {
           err.SetErrorStringWithFormat(
               "trying to create a temporary region for %s but one exists",
               m_variable_sp->GetName().AsCString());
           return;
         }
 
         if (data.GetByteSize() < m_variable_sp->GetType()->GetByteSize(scope)) {
           if (data.GetByteSize() == 0 &&
-              !m_variable_sp->LocationExpression().IsValid()) {
+              !m_variable_sp->LocationExpressionList().IsValid()) {
             err.SetErrorStringWithFormat("the variable '%s' has no location, "
                                          "it may have been optimized out",
                                          m_variable_sp->GetName().AsCString());
           } else {
             err.SetErrorStringWithFormat(
                 "size of variable %s (%" PRIu64
                 ") is larger than the ValueObject's size (%" PRIu64 ")",
                 m_variable_sp->GetName().AsCString(),

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionDeclMap.cpp

bool ClangExpressionDeclMap::GetVariableValue(VariableSP &var,
   TypeSystemClang *clang_ast = llvm::dyn_cast_or_null<TypeSystemClang>(
       var_type->GetForwardCompilerType().GetTypeSystem());
 
   if (!clang_ast) {
     LLDB_LOG(log, "Skipped a definition because it has no Clang AST");
     return false;
   }
 
-  DWARFExpression &var_location_expr = var->LocationExpression();
+  DWARFExpressionList &var_location_list = var->LocationExpressionList();
 
   Target *target = m_parser_vars->m_exe_ctx.GetTargetPtr();
   Status err;
 
   if (var->GetLocationIsConstantValueData()) {
     DataExtractor const_value_extractor;
-
-    if (var_location_expr.GetExpressionData(const_value_extractor)) {
+    if (var_location_list.GetExpressionData(const_value_extractor)) {
       var_location = Value(const_value_extractor.GetDataStart(),
                            const_value_extractor.GetByteSize());
       var_location.SetValueType(Value::ValueType::HostAddress);
     } else {
       LLDB_LOG(log, "Error evaluating constant variable: {0}", err.AsCString());
       return false;
     }
   }

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

DWARFASTParserClang::ParseFunctionFromDWARF(CompileUnit &comp_unit,
   const char *name = nullptr;
   const char *mangled = nullptr;
   int decl_file = 0;
   int decl_line = 0;
   int decl_column = 0;
   int call_file = 0;
   int call_line = 0;
   int call_column = 0;
-  DWARFExpression frame_base;
+  DWARFExpressionList frame_base;
 
   const dw_tag_t tag = die.Tag();
 
   if (tag != DW_TAG_subprogram)
     return nullptr;
 
   if (die.GetDIENamesAndRanges(name, mangled, func_ranges, decl_file, decl_line,
                                decl_column, call_file, call_line, call_column,

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

public:
   // Getting attribute values from the DIE.
   //
   // GetAttributeValueAsXXX() functions should only be used if you are
   // looking for one or two attributes on a DIE. If you are trying to
   // parse all attributes, use GetAttributes (...) instead
   DWARFDIE
   GetAttributeValueAsReferenceDIE(const dw_attr_t attr) const;
 
-  bool GetDIENamesAndRanges(const char *&name, const char *&mangled,
-                            DWARFRangeList &ranges, int &decl_file,
-                            int &decl_line, int &decl_column, int &call_file,
-                            int &call_line, int &call_column,
-                            lldb_private::DWARFExpression *frame_base) const;
+  bool
+  GetDIENamesAndRanges(const char *&name, const char *&mangled,
+                       DWARFRangeList &ranges, int &decl_file, int &decl_line,
+                       int &decl_column, int &call_file, int &call_line,
+                       int &call_column,
+                       lldb_private::DWARFExpressionList *frame_base) const;
 
   /// The range of all the children of this DIE.
   llvm::iterator_range<child_iterator> children() const;
 };
 
 class DWARFDIE::child_iterator
     : public llvm::iterator_facade_base<DWARFDIE::child_iterator,
                                         std::forward_iterator_tag, DWARFDIE> {

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

if (d.GetParent().IsStructUnionOrClass())
       return true;
   return false;
 }
 
 bool DWARFDIE::GetDIENamesAndRanges(
     const char *&name, const char *&mangled, DWARFRangeList &ranges,
     int &decl_file, int &decl_line, int &decl_column, int &call_file,
     int &call_line, int &call_column,
-    lldb_private::DWARFExpression *frame_base) const {
+    lldb_private::DWARFExpressionList *frame_base) const {
   if (IsValid()) {
     return m_die->GetDIENamesAndRanges(
         GetCU(), name, mangled, ranges, decl_file, decl_line, decl_column,
         call_file, call_line, call_column, frame_base);
   } else
     return false;
 }
 
 llvm::iterator_range<DWARFDIE::child_iterator> DWARFDIE::children() const {
   return llvm::make_range(child_iterator(*this), child_iterator());
 }

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

public:
 
   const char *GetQualifiedName(DWARFUnit *cu, const DWARFAttributes &attributes,
                                std::string &storage) const;
 
   bool GetDIENamesAndRanges(
       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 = nullptr) const;
+      lldb_private::DWARFExpressionList *frame_base = nullptr) const;
 
   const DWARFAbbreviationDeclaration *
   GetAbbreviationDeclarationPtr(const DWARFUnit *cu) const;
 
   lldb::offset_t GetFirstAttributeOffset() const;
 
   dw_tag_t Tag() const { return m_tag; }
 

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

 // GetDIENamesAndRanges
 //
 // Gets the valid address ranges for a given DIE by looking for a
 // DW_AT_low_pc/DW_AT_high_pc pair, DW_AT_entry_pc, or DW_AT_ranges attributes.
 bool DWARFDebugInfoEntry::GetDIENamesAndRanges(
     DWARFUnit *cu, const char *&name, const char *&mangled,
     DWARFRangeList &ranges, int &decl_file, int &decl_line, int &decl_column,
     int &call_file, int &call_line, int &call_column,
-    DWARFExpression *frame_base) const {
+    DWARFExpressionList *frame_base) const {
   dw_addr_t lo_pc = LLDB_INVALID_ADDRESS;
   dw_addr_t hi_pc = LLDB_INVALID_ADDRESS;
   std::vector<DWARFDIE> dies;
-  bool set_frame_base_loclist_addr = false;
 
   const auto *abbrevDecl = GetAbbreviationDeclarationPtr(cu);
 
   SymbolFileDWARF &dwarf = cu->GetSymbolFileDWARF();
   lldb::ModuleSP module = dwarf.GetObjectFile()->GetModule();
 
   if (abbrevDecl) {
     const DWARFDataExtractor &data = cu->GetData();
for (uint32_t i = 0; i < numAttributes; ++i) {
           break;
 
         case DW_AT_frame_base:
           if (frame_base) {
             if (form_value.BlockData()) {
               uint32_t block_offset =
                   form_value.BlockData() - data.GetDataStart();
               uint32_t block_length = form_value.Unsigned();
-              *frame_base = DWARFExpression(
-                  module, DataExtractor(data, block_offset, block_length), cu);
+              *frame_base =
+                  DWARFExpressionList(module,
+                                      DWARFExpression(DataExtractor(
+                                          data, block_offset, block_length)),
+                                      cu);
             } else {
               DataExtractor data = cu->GetLocationData();
               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->SetLocationListAddresses(cu->GetBaseAddress(),
-                                                       lo_pc);
-                } else {
-                  set_frame_base_loclist_addr = true;
-                }
+                DWARFExpression::ParseDWARFLocationList(cu, data, frame_base);
               }
             }
           }
           break;
 
         default:
           break;
         }
       }
     }
   }
 
   if (ranges.IsEmpty()) {
     if (lo_pc != LLDB_INVALID_ADDRESS) {
       if (hi_pc != LLDB_INVALID_ADDRESS && hi_pc > lo_pc)
         ranges.Append(DWARFRangeList::Entry(lo_pc, hi_pc - lo_pc));
       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->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.h

 #include <vector>
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/Support/Threading.h"
 
 #include "lldb/Core/UniqueCStringMap.h"
 #include "lldb/Core/dwarf.h"
+#include "lldb/Expression/DWARFExpressionList.h"
 #include "lldb/Symbol/DebugMacros.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Target/Statistics.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Flags.h"
 #include "lldb/Utility/RangeMap.h"
 #include "lldb/lldb-private.h"

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

 //===-- SymbolFileDWARF.cpp -----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "SymbolFileDWARF.h"
 
 #include "llvm/ADT/Optional.h"
+#include "llvm/DebugInfo/DWARF/DWARFDebugLoc.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Threading.h"
 
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Progress.h"
if (module_sp) {
         CompUnitSP cu_sp = module_sp->GetCompileUnitAtIndex(i);
         if (cu_sp) {
           VariableListSP globals_sp = cu_sp->GetVariableList(true);
           if (globals_sp) {
             const size_t num_globals = globals_sp->GetSize();
             for (size_t g = 0; g < num_globals; ++g) {
               VariableSP var_sp = globals_sp->GetVariableAtIndex(g);
               if (var_sp && !var_sp->GetLocationIsConstantValueData()) {
-                const DWARFExpression &location = var_sp->LocationExpression();
+                const DWARFExpressionList &location =
+                    var_sp->LocationExpressionList();
                 Value location_result;
                 Status error;
-                if (location.Evaluate(nullptr, LLDB_INVALID_ADDRESS, nullptr,
-                                      nullptr, location_result, &error)) {
+                ExecutionContext exe_ctx;
+                if (location.Evaluate(&exe_ctx, nullptr, nullptr, nullptr,
+                                      location_result, &error)) {
                   if (location_result.GetValueType() ==
                       Value::ValueType::FileAddress) {
                     lldb::addr_t file_addr =
                         location_result.GetScalar().ULongLong();
                     lldb::addr_t byte_size = 1;
                     if (var_sp->GetType())
                       byte_size =
                           var_sp->GetType()->GetByteSize(nullptr).getValueOr(0);
if (tag != DW_TAG_variable && tag != DW_TAG_constant &&
     return nullptr;
 
   DWARFAttributes attributes;
   const size_t num_attributes = die.GetAttributes(attributes);
   const char *name = nullptr;
   const char *mangled = nullptr;
   Declaration decl;
   DWARFFormValue type_die_form;
-  DWARFExpression location;
+  DWARFExpressionList location_list(module, DWARFExpression(), die.GetCU());
   bool is_external = false;
   bool is_artificial = false;
   DWARFFormValue const_value_form, location_form;
   Variable::RangeList scope_ranges;
 
   for (size_t i = 0; i < num_attributes; ++i) {
     dw_attr_t attr = attributes.AttributeAtIndex(i);
     DWARFFormValue form_value;
for (size_t i = 0; i < num_attributes; ++i) {
     }
   }
 
   // Prefer DW_AT_location over DW_AT_const_value. Both can be emitted e.g.
   // for static constexpr member variables -- DW_AT_const_value will be
   // present in the class declaration and DW_AT_location in the DIE defining
   // the member.
   bool location_is_const_value_data = false;
-  bool has_explicit_location = false;
+  bool has_explicit_location = location_form.IsValid();
   bool use_type_size_for_value = false;
   if (location_form.IsValid()) {
-    has_explicit_location = true;
     if (DWARFFormValue::IsBlockForm(location_form.Form())) {
       const DWARFDataExtractor &data = die.GetData();
 
       uint32_t block_offset = location_form.BlockData() - data.GetDataStart();
       uint32_t block_length = location_form.Unsigned();
-      location = DWARFExpression(
+      location_list = DWARFExpressionList(
           module, DataExtractor(data, block_offset, block_length), die.GetCU());
     } else {
       DataExtractor data = die.GetCU()->GetLocationData();
       dw_offset_t offset = location_form.Unsigned();
       if (location_form.Form() == DW_FORM_loclistx)
         offset = die.GetCU()->GetLoclistOffset(offset).getValueOr(-1);
       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.SetLocationListAddresses(
-            location_form.GetUnit()->GetBaseAddress(), func_low_pc);
+        const DWARFUnit *dwarf_cu = location_form.GetUnit();
+        DWARFExpression::ParseDWARFLocationList(dwarf_cu, data, &location_list);
       }
     }
   } else if (const_value_form.IsValid()) {
     location_is_const_value_data = true;
     // The constant value will be either a block, a data value or a
     // string.
     const DWARFDataExtractor &debug_info_data = die.GetData();
     if (DWARFFormValue::IsBlockForm(const_value_form.Form())) {
       // Retrieve the value as a block expression.
       uint32_t block_offset =
           const_value_form.BlockData() - debug_info_data.GetDataStart();
       uint32_t block_length = const_value_form.Unsigned();
-      location = DWARFExpression(
+      location_list = DWARFExpressionList(
           module, DataExtractor(debug_info_data, block_offset, block_length),
           die.GetCU());
     } else if (DWARFFormValue::IsDataForm(const_value_form.Form())) {
       // Constant value size does not have to match the size of the
       // variable. We will fetch the size of the type after we create
       // it.
       use_type_size_for_value = true;
     } else if (const char *str = const_value_form.AsCString()) {
       uint32_t string_length = strlen(str) + 1;
-      location = DWARFExpression(
+      location_list = DWARFExpressionList(
           module,
           DataExtractor(str, string_length, die.GetCU()->GetByteOrder(),
                         die.GetCU()->GetAddressByteSize()),
           die.GetCU());
     }
   }
 
   const DWARFDIE parent_context_die = GetDeclContextDIEContainingDIE(die);
else {
     // or static variable, so we have to do a little digging:
     // 1) DW_AT_linkage_name implies static lifetime (but may be missing)
     // 2) An empty DW_AT_location is an (optimized-out) static lifetime var.
     // 3) DW_AT_location containing a DW_OP_addr implies static lifetime.
     // Clang likes to combine small global variables into the same symbol
     // with locations like: DW_OP_addr(0x1000), DW_OP_constu(2), DW_OP_plus
     // so we need to look through the whole expression.
     bool is_static_lifetime =
-        has_explicit_mangled || (has_explicit_location && !location.IsValid());
+        has_explicit_mangled ||
+        (has_explicit_location && !location_list.IsValid());
     // Check if the location has a DW_OP_addr with any address value...
     lldb::addr_t location_DW_OP_addr = LLDB_INVALID_ADDRESS;
     if (!location_is_const_value_data) {
       bool op_error = false;
-      location_DW_OP_addr = location.GetLocation_DW_OP_addr(0, op_error);
+      const DWARFExpression* location = location_list.GetExpressionAtAddress(0);
+      if (location)
+        location_DW_OP_addr = location->GetLocation_DW_OP_addr(
+            location_form.GetUnit(), 0, op_error);
       if (op_error) {
         StreamString strm;
-        location.DumpLocationForAddress(&strm, eDescriptionLevelFull, 0, 0,
-                                        nullptr);
+        location->DumpLocation(&strm, eDescriptionLevelFull, nullptr);
         GetObjectFile()->GetModule()->ReportError(
             "0x%8.8x: %s has an invalid location: %s", die.GetOffset(),
             die.GetTagAsCString(), strm.GetData());
       }
       if (location_DW_OP_addr != LLDB_INVALID_ADDRESS)
         is_static_lifetime = true;
     }
     SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
     if (debug_map_symfile)
       // Set the module of the expression to the linked module
       // instead of the object file so the relocated address can be
       // found there.
-      location.SetModule(debug_map_symfile->GetObjectFile()->GetModule());
+      location_list.SetModule(debug_map_symfile->GetObjectFile()->GetModule());
 
     if (is_static_lifetime) {
       if (is_external)
         scope = eValueTypeVariableGlobal;
       else
         scope = eValueTypeVariableStatic;
 
       if (debug_map_symfile) {
if (is_static_lifetime) {
                   debug_map_symtab->FindFirstSymbolWithNameAndType(
                       const_name, eSymbolTypeData, Symtab::eDebugYes,
                       Symtab::eVisibilityExtern);
               if (exe_symbol) {
                 if (exe_symbol->ValueIsAddress()) {
                   const addr_t exe_file_addr =
                       exe_symbol->GetAddressRef().GetFileAddress();
                   if (exe_file_addr != LLDB_INVALID_ADDRESS) {
-                    if (location.Update_DW_OP_addr(exe_file_addr)) {
+                    DWARFExpression *location =
+                        location_list.GetMutableExpressionAtAddress(0);
+                    if (location->Update_DW_OP_addr(exe_file_addr)) {
                       linked_oso_file_addr = true;
                       symbol_context_scope = exe_symbol;
                     }
                   }
                 }
               }
             }
           }
         }
 
         if (!linked_oso_file_addr) {
           // The DW_OP_addr is not zero, but it contains a .o file address
           // which needs to be linked up correctly.
           const lldb::addr_t exe_file_addr =
               debug_map_symfile->LinkOSOFileAddress(this, location_DW_OP_addr);
           if (exe_file_addr != LLDB_INVALID_ADDRESS) {
             // Update the file address for this variable
-            location.Update_DW_OP_addr(exe_file_addr);
+            DWARFExpression *location =
+                location_list.GetMutableExpressionAtAddress(0);
+            location->Update_DW_OP_addr(exe_file_addr);
           } else {
             // Variable didn't make it into the final executable
             return nullptr;
           }
         }
       }
     } else {
       if (location_is_const_value_data &&
           die.GetDIE()->IsGlobalOrStaticScopeVariable())
         scope = eValueTypeVariableStatic;
       else {
         scope = eValueTypeVariableLocal;
         if (debug_map_symfile) {
           // We need to check for TLS addresses that we need to fixup
-          if (location.ContainsThreadLocalStorage()) {
-            location.LinkThreadLocalStorage(
+          if (location_list.ContainsThreadLocalStorage()) {
+            location_list.LinkThreadLocalStorage(
                 debug_map_symfile->GetObjectFile()->GetModule(),
                 [this, debug_map_symfile](
                     lldb::addr_t unlinked_file_addr) -> lldb::addr_t {
                   return debug_map_symfile->LinkOSOFileAddress(
                       this, unlinked_file_addr);
                 });
             scope = eValueTypeVariableThreadLocal;
           }
if (!symbol_context_scope) {
     // variable that is in a function scope and the function in the symbol
     // context wasn't filled in yet
     return nullptr;
   }
 
   auto type_sp = std::make_shared<SymbolFileType>(
       *this, GetUID(type_die_form.Reference()));
 
-  if (use_type_size_for_value && type_sp->GetType())
-    location.UpdateValue(const_value_form.Unsigned(),
-                         type_sp->GetType()->GetByteSize(nullptr).getValueOr(0),
-                         die.GetCU()->GetAddressByteSize());
+  if (use_type_size_for_value && type_sp->GetType()) {
+    DWARFExpression *location = location_list.GetMutableExpressionAtAddress(0);
+    location->UpdateValue(
+        const_value_form.Unsigned(),
+  }
 
   return std::make_shared<Variable>(
       die.GetID(), name, mangled, type_sp, scope, symbol_context_scope,
-      scope_ranges, &decl, location, is_external, is_artificial,
+      scope_ranges, &decl, location_list, is_external, is_artificial,
       location_is_const_value_data, is_static_member);
 }
 
 DWARFDIE
 SymbolFileDWARF::FindBlockContainingSpecification(
     const DIERef &func_die_ref, dw_offset_t spec_block_die_offset) {
   // Give the concrete function die specified by "func_die_offset", find the
   // concrete block whose DW_AT_specification or DW_AT_abstract_origin points

 static CallSiteParameterArray
 CollectCallSiteParameters(ModuleSP module, DWARFDIE call_site_die) {
   CallSiteParameterArray parameters;
   for (DWARFDIE child : call_site_die.children()) {
     if (child.Tag() != DW_TAG_call_site_parameter &&
         child.Tag() != DW_TAG_GNU_call_site_parameter)
       continue;
 
-    llvm::Optional<DWARFExpression> LocationInCallee;
-    llvm::Optional<DWARFExpression> LocationInCaller;
+    llvm::Optional<DWARFExpressionList> LocationInCallee;
+    llvm::Optional<DWARFExpressionList> LocationInCaller;
 
     DWARFAttributes attributes;
     const size_t num_attributes = child.GetAttributes(attributes);
 
     // Parse the location at index \p attr_index within this call site parameter
     // DIE, or return None on failure.
     auto parse_simple_location =
-        [&](int attr_index) -> llvm::Optional<DWARFExpression> {
+        [&](int attr_index) -> llvm::Optional<DWARFExpressionList> {
       DWARFFormValue form_value;
       if (!attributes.ExtractFormValueAtIndex(attr_index, form_value))
         return {};
       if (!DWARFFormValue::IsBlockForm(form_value.Form()))
         return {};
       auto data = child.GetData();
       uint32_t block_offset = form_value.BlockData() - data.GetDataStart();
       uint32_t block_length = form_value.Unsigned();
-      return DWARFExpression(module,
-                             DataExtractor(data, block_offset, block_length),
-                             child.GetCU());
+      return DWARFExpressionList(
+          module, DataExtractor(data, block_offset, block_length),
     };
 
     for (size_t i = 0; i < num_attributes; ++i) {
       dw_attr_t attr = attributes.AttributeAtIndex(i);
       if (attr == DW_AT_location)
         LocationInCallee = parse_simple_location(i);
       if (attr == DW_AT_call_value || attr == DW_AT_GNU_call_site_value)
         LocationInCaller = parse_simple_location(i);
SymbolFileDWARF::CollectCallEdges(ModuleSP module, DWARFDIE function_die) {
   // For now, assume that all entries are nested directly under the subprogram
   // (this is the kind of DWARF LLVM produces) and parse them eagerly.
   std::vector<std::unique_ptr<CallEdge>> call_edges;
   for (DWARFDIE child : function_die.children()) {
     if (child.Tag() != DW_TAG_call_site && child.Tag() != DW_TAG_GNU_call_site)
       continue;
 
     llvm::Optional<DWARFDIE> call_origin;
-    llvm::Optional<DWARFExpression> call_target;
+    llvm::Optional<DWARFExpressionList> call_target;
     addr_t return_pc = LLDB_INVALID_ADDRESS;
     addr_t call_inst_pc = LLDB_INVALID_ADDRESS;
     addr_t low_pc = LLDB_INVALID_ADDRESS;
     bool tail_call = false;
 
     // Second DW_AT_low_pc may come from DW_TAG_subprogram referenced by
     // DW_TAG_GNU_call_site's DW_AT_abstract_origin overwriting our 'low_pc'.
     // So do not inherit attributes from DW_AT_abstract_origin.
for (size_t i = 0; i < num_attributes; ++i) {
           LLDB_LOG(log,
                    "CollectCallEdges: AT_call_target does not have block form");
           break;
         }
 
         auto data = child.GetData();
         uint32_t block_offset = form_value.BlockData() - data.GetDataStart();
         uint32_t block_length = form_value.Unsigned();
-        call_target = DWARFExpression(
+        call_target = DWARFExpressionList(
             module, DataExtractor(data, block_offset, block_length),
             child.GetCU());
       }
     }
     if (!call_origin && !call_target) {
       LLDB_LOG(log, "CollectCallEdges: call site without any call target");
       continue;
     }

lldb/source/Plugins/SymbolFile/NativePDB/DWARFLocationExpression.cpp

static DWARFExpression MakeLocationExpressionInternal(lldb::ModuleSP module,
   StreamBuffer<32> stream(Stream::eBinary, address_size, byte_order);
 
   if (!writer(stream, register_kind))
     return DWARFExpression();
 
   DataBufferSP buffer =
       std::make_shared<DataBufferHeap>(stream.GetData(), stream.GetSize());
   DataExtractor extractor(buffer, byte_order, address_size, byte_size);
-  DWARFExpression result(module, extractor, nullptr);
+  DWARFExpression result(extractor);
   result.SetRegisterKind(register_kind);
 
   return result;
 }
 
 static DWARFExpression MakeRegisterBasedLocationExpressionInternal(
     llvm::codeview::RegisterId reg, llvm::Optional<int32_t> relative_offset,
     lldb::ModuleSP module) {
DWARFExpression lldb_private::npdb::MakeConstantLocationExpression(
   } else {
     Value.U = constant.getZExtValue();
   }
 
   bytes = llvm::makeArrayRef(reinterpret_cast<const uint8_t *>(&Value), 8)
               .take_front(size);
   buffer->CopyData(bytes.data(), size);
   DataExtractor extractor(buffer, lldb::eByteOrderLittle, address_size);
-  DWARFExpression result(nullptr, extractor, nullptr);
+  DWARFExpression result(extractor);
   return result;
 }
 
 DWARFExpression lldb_private::npdb::MakeEnregisteredLocationExpressionForClass(
     std::map<uint64_t, std::pair<RegisterId, uint32_t>> &members_info,
     lldb::ModuleSP module) {
   return MakeLocationExpressionInternal(
       module, [&](Stream &stream, RegisterKind &register_kind) -> bool {

lldb/source/Plugins/SymbolFile/NativePDB/SymbolFileNativePDB.cpp

VariableSP SymbolFileNativePDB::CreateGlobalVariable(PdbGlobalSymId var_id) {
   Declaration decl;
   PdbTypeSymId tid(ti, false);
   SymbolFileTypeSP type_sp =
       std::make_shared<SymbolFileType>(*this, toOpaqueUid(tid));
   Variable::RangeList ranges;
 
   m_ast->GetOrCreateVariableDecl(var_id);
 
-  DWARFExpression location = MakeGlobalLocationExpression(
-      section, offset, GetObjectFile()->GetModule());
+  ModuleSP module_sp = GetObjectFile()->GetModule();
+  DWARFExpressionList location(
+      module_sp, MakeGlobalLocationExpression(section, offset, module_sp),
+      nullptr);
 
   std::string global_name("::");
   global_name += name;
   bool artificial = false;
   bool location_is_constant_data = false;
   bool static_member = false;
   VariableSP var_sp = std::make_shared<Variable>(
       toOpaqueUid(var_id), name.str().c_str(), global_name.c_str(), type_sp,
SymbolFileNativePDB::CreateConstantSymbol(PdbGlobalSymId var_id,
   global_name += constant.Name;
   PdbTypeSymId tid(constant.Type, false);
   SymbolFileTypeSP type_sp =
       std::make_shared<SymbolFileType>(*this, toOpaqueUid(tid));
 
   Declaration decl;
   Variable::RangeList ranges;
   ModuleSP module = GetObjectFile()->GetModule();
-  DWARFExpression location = MakeConstantLocationExpression(
-      constant.Type, tpi, constant.Value, module);
+  DWARFExpressionList location(module,
+                               MakeConstantLocationExpression(
+                                   constant.Type, tpi, constant.Value, module),
+                               nullptr);
 
   bool external = false;
   bool artificial = false;
   bool location_is_constant_data = true;
   bool static_member = false;
   VariableSP var_sp = std::make_shared<Variable>(
       toOpaqueUid(var_id), constant.Name.str().c_str(), global_name.c_str(),
       type_sp, eValueTypeVariableGlobal, module.get(), ranges, &decl, location,
VariableSP SymbolFileNativePDB::CreateLocalVariable(PdbCompilandSymId scope_id,
   ValueType var_scope =
       is_param ? eValueTypeVariableArgument : eValueTypeVariableLocal;
   bool external = false;
   bool artificial = false;
   bool location_is_constant_data = false;
   bool static_member = false;
   VariableSP var_sp = std::make_shared<Variable>(
       toOpaqueUid(var_id), name.c_str(), name.c_str(), sftype, var_scope,
-      &block, *var_info.ranges, &decl, *var_info.location, external,
+      &block, *var_info.ranges, &decl,
+      DWARFExpressionList(module, *var_info.location, nullptr), external,
       artificial, location_is_constant_data, static_member);
 
   if (!is_param)
     m_ast->GetOrCreateVariableDecl(scope_id, var_id);
 
   m_local_variables[toOpaqueUid(var_id)] = var_sp;
   return var_sp;
 }

lldb/source/Plugins/SymbolFile/PDB/PDBLocationToDWARFExpression.cpp

DWARFExpression ConvertPDBLocationToDWARFExpression(
   }
   default:
     return DWARFExpression();
   }
 
   DataBufferSP buffer =
       std::make_shared<DataBufferHeap>(stream.GetData(), stream.GetSize());
   DataExtractor extractor(buffer, byte_order, address_size, byte_size);
-  DWARFExpression result(module, extractor, nullptr);
+  DWARFExpression result(extractor);
   result.SetRegisterKind(register_kind);
 
   return result;
 }

lldb/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

VariableSP SymbolFilePDB::ParseVariableForPDBData(
   SymbolFileTypeSP type_sp =
       std::make_shared<SymbolFileType>(*this, pdb_data.getTypeId());
 
   auto var_name = pdb_data.getName();
   auto mangled = GetMangledForPDBData(pdb_data);
   auto mangled_cstr = mangled.empty() ? nullptr : mangled.c_str();
 
   bool is_constant;
-  DWARFExpression location = ConvertPDBLocationToDWARFExpression(
-      GetObjectFile()->GetModule(), pdb_data, ranges, is_constant);
+  ModuleSP module_sp = GetObjectFile()->GetModule();
+  DWARFExpressionList location(module_sp,
+                               ConvertPDBLocationToDWARFExpression(
+                                   module_sp, pdb_data, ranges, is_constant),
+                               nullptr);
 
   var_sp = std::make_shared<Variable>(
       var_uid, var_name.c_str(), mangled_cstr, type_sp, scope, context_scope,
       ranges, &decl, location, is_external, is_artificial, is_constant,
       is_static_member);
 
   m_variables.insert(std::make_pair(var_uid, var_sp));
   return var_sp;

lldb/source/Symbol/Function.cpp

 }
 
 Function *IndirectCallEdge::GetCallee(ModuleList &images,
                                       ExecutionContext &exe_ctx) {
   Log *log = GetLog(LLDBLog::Step);
   Status error;
   Value callee_addr_val;
   if (!call_target.Evaluate(&exe_ctx, exe_ctx.GetRegisterContext(),
-                            /*loclist_base_load_addr=*/LLDB_INVALID_ADDRESS,
                             /*initial_value_ptr=*/nullptr,
                             /*object_address_ptr=*/nullptr, callee_addr_val,
                             &error)) {
     LLDB_LOGF(log, "IndirectCallEdge: Could not evaluate expression: %s",
               error.AsCString());
     return nullptr;
   }
 

lldb/source/Symbol/Variable.cpp

 
 using namespace lldb;
 using namespace lldb_private;
 
 Variable::Variable(lldb::user_id_t uid, const char *name, const char *mangled,
                    const lldb::SymbolFileTypeSP &symfile_type_sp,
                    ValueType scope, SymbolContextScope *context,
                    const RangeList &scope_range, Declaration *decl_ptr,
-                   const DWARFExpression &location, bool external,
+                   const DWARFExpressionList &location_list, bool external,
                    bool artificial, bool location_is_constant_data,
                    bool static_member)
     : UserID(uid), m_name(name), m_mangled(ConstString(mangled)),
       m_symfile_type_sp(symfile_type_sp), m_scope(scope),
       m_owner_scope(context), m_scope_range(scope_range),
-      m_declaration(decl_ptr), m_location(location), m_external(external),
+      m_declaration(decl_ptr), m_location_list(location_list), m_external(external),
       m_artificial(artificial), m_loc_is_const_data(location_is_constant_data),
       m_static_member(static_member) {}
 
 Variable::~Variable() = default;
 
 lldb::LanguageType Variable::GetLanguage() const {
   lldb::LanguageType lang = m_mangled.GuessLanguage();
   if (lang != lldb::eLanguageTypeUnknown)
if (show_context && m_owner_scope != nullptr) {
     s->PutCString(", context = ( ");
     m_owner_scope->DumpSymbolContext(s);
     s->PutCString(" )");
   }
 
   bool show_fullpaths = false;
   m_declaration.Dump(s, show_fullpaths);
 
-  if (m_location.IsValid()) {
+  if (m_location_list.IsValid()) {
     s->PutCString(", location = ");
     ABISP abi;
     if (m_owner_scope) {
       ModuleSP module_sp(m_owner_scope->CalculateSymbolContextModule());
       if (module_sp)
         abi = ABI::FindPlugin(ProcessSP(), module_sp->GetArchitecture());
     }
-    m_location.GetDescription(s, lldb::eDescriptionLevelBrief, abi.get());
+    m_location_list.GetDescription(s, lldb::eDescriptionLevelBrief, abi.get());
   }
 
   if (m_external)
     s->PutCString(", external");
 
   if (m_artificial)
     s->PutCString(", artificial");
 
void Variable::CalculateSymbolContext(SymbolContext *sc) {
   if (m_owner_scope) {
     m_owner_scope->CalculateSymbolContext(sc);
     sc->variable = this;
   } else
     sc->Clear(false);
 }
 
 bool Variable::LocationIsValidForFrame(StackFrame *frame) {
-  // Is the variable is described by a single location?
-  if (!m_location.IsLocationList()) {
-    // Yes it is, the location is valid.
-    return true;
-  }
-
-  if (frame) {
-    Function *function =
-        frame->GetSymbolContext(eSymbolContextFunction).function;
-    if (function) {
-      TargetSP target_sp(frame->CalculateTarget());
-
-      addr_t loclist_base_load_addr =
-          function->GetAddressRange().GetBaseAddress().GetLoadAddress(
-              target_sp.get());
-      if (loclist_base_load_addr == LLDB_INVALID_ADDRESS)
-        return false;
-      // It is a location list. We just need to tell if the location list
-      // contains the current address when converted to a load address
-      return m_location.LocationListContainsAddress(
-          loclist_base_load_addr,
-          frame->GetFrameCodeAddress().GetLoadAddress(target_sp.get()));
-    }
-  }
-  return false;
+  return m_location_list.ContainsAddress(
+      frame->GetFrameCodeAddress().GetFileAddress());
 }
 
 bool Variable::LocationIsValidForAddress(const Address &address) {
   // Be sure to resolve the address to section offset prior to calling this
   // function.
   if (address.IsSectionOffset()) {
     // We need to check if the address is valid for both scope range and value
-    // range. 
+    // range.
     // Empty scope range means block range.
     bool valid_in_scope_range =
         GetScopeRange().IsEmpty() || GetScopeRange().FindEntryThatContains(
                                          address.GetFileAddress()) != nullptr;
     if (!valid_in_scope_range)
       return false;
     SymbolContext sc;
     CalculateSymbolContext(&sc);
     if (sc.module_sp == address.GetModule()) {
-      // Is the variable is described by a single location?
-      if (!m_location.IsLocationList()) {
-        // Yes it is, the location is valid.
-        return true;
-      }
-
-      if (sc.function) {
-        addr_t loclist_base_file_addr =
-            sc.function->GetAddressRange().GetBaseAddress().GetFileAddress();
-        if (loclist_base_file_addr == LLDB_INVALID_ADDRESS)
-          return false;
-        // It is a location list. We just need to tell if the location list
-        // contains the current address when converted to a load address
-        return m_location.LocationListContainsAddress(loclist_base_file_addr,
-                                                      address.GetFileAddress());
-      }
+      // Empty location list means we have missing value range info, but it's in
+      // the scope.
+      return m_location_list.GetSize() == 0 ||
+             m_location_list.ContainsAddress(address.GetFileAddress());
     }
   }
   return false;
 }
 
 bool Variable::IsInScope(StackFrame *frame) {
   switch (m_scope) {
   case eValueTypeRegister:
bool Variable::DumpLocations(Stream *s, const Address &address) {
   ABISP abi;
   if (m_owner_scope) {
     ModuleSP module_sp(m_owner_scope->CalculateSymbolContextModule());
     if (module_sp)
       abi = ABI::FindPlugin(ProcessSP(), module_sp->GetArchitecture());
   }
 
   const addr_t file_addr = address.GetFileAddress();
-  if (sc.function) {
-    addr_t loclist_base_file_addr =
-        sc.function->GetAddressRange().GetBaseAddress().GetFileAddress();
-    if (loclist_base_file_addr == LLDB_INVALID_ADDRESS)
-      return false;
-    return m_location.DumpLocations(s, eDescriptionLevelBrief,
-                                    loclist_base_file_addr, file_addr,
+  return m_location_list.DumpLocations(s, eDescriptionLevelBrief, file_addr,
                                        abi.get());
-  }
-  return false;
-}
 
 static void PrivateAutoComplete(
     StackFrame *frame, llvm::StringRef partial_path,
     const llvm::Twine
         &prefix_path, // Anything that has been resolved already will be in here
     const CompilerType &compiler_type, CompletionRequest &request);
 
 static void PrivateAutoCompleteMembers(

lldb/source/Target/RegisterContextUnwind.cpp

 //===-- RegisterContextUnwind.cpp -----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Target/RegisterContextUnwind.h"
 #include "lldb/Core/Address.h"
 #include "lldb/Core/AddressRange.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Value.h"
-#include "lldb/Expression/DWARFExpression.h"
+#include "lldb/Expression/DWARFExpressionList.h"
 #include "lldb/Symbol/ArmUnwindInfo.h"
 #include "lldb/Symbol/CallFrameInfo.h"
 #include "lldb/Symbol/DWARFCallFrameInfo.h"
 #include "lldb/Symbol/FuncUnwinders.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Symbol/SymbolContext.h"
void RegisterContextUnwind::InitializeNonZerothFrame() {
 
   const bool allow_section_end = true;
   m_current_pc.SetLoadAddress(pc, &process->GetTarget(), allow_section_end);
 
   // If we don't have a Module for some reason, we're not going to find
   // symbol/function information - just stick in some reasonable defaults and
   // hope we can unwind past this frame.  If we're above a trap handler,
   // we may be at a bogus address because we jumped through a bogus function
-  // pointer and trapped, so don't force the arch default unwind plan in that 
+  // pointer and trapped, so don't force the arch default unwind plan in that
   // case.
   ModuleSP pc_module_sp(m_current_pc.GetModule());
   if ((!m_current_pc.IsValid() || !pc_module_sp) &&
       above_trap_handler == false) {
     UnwindLogMsg("using architectural default unwind method");
 
     // Test the pc value to see if we know it's in an unmapped/non-executable
     // region of memory.
if (regnum.GetAsKind(unwindplan_registerkind) == LLDB_INVALID_REGNUM) {
       return UnwindLLDB::RegisterSearchResult::eRegisterNotFound;
     }
     // The architecture default unwind plan marks unknown registers as
     // Undefined so that we don't forward them up the stack when a
     // jitted stack frame may have overwritten them.  But when the
     // arch default unwind plan is used as the Fast Unwind Plan, we
     // need to recognize this & switch over to the Full Unwind Plan
     // to see what unwind rule that (more knoweldgeable, probably)
-    // UnwindPlan has.  If the full UnwindPlan says the register 
+    // UnwindPlan has.  If the full UnwindPlan says the register
     // location is Undefined, then it really is.
     if (active_row->GetRegisterInfo(regnum.GetAsKind(unwindplan_registerkind),
                                     unwindplan_regloc) &&
         !unwindplan_regloc.IsUndefined()) {
       UnwindLogMsg(
           "supplying caller's saved %s (%d)'s location using FastUnwindPlan",
           regnum.GetName(), regnum.GetAsKind(eRegisterKindLLDB));
       have_unwindplan_regloc = true;
if (m_full_unwind_plan_sp) {
 
       // If we're fetching the saved pc and this UnwindPlan defines a
       // ReturnAddress register (e.g. lr on arm), look for the return address
       // register number in the UnwindPlan's row.
       if (pc_regnum.IsValid() && pc_regnum == regnum &&
           m_full_unwind_plan_sp->GetReturnAddressRegister() !=
               LLDB_INVALID_REGNUM) {
         // If this is a trap handler frame, we should have access to
-        // the complete register context when the interrupt/async 
+        // the complete register context when the interrupt/async
         // signal was received, we should fetch the actual saved $pc
         // value instead of the Return Address register.
         // If $pc is not available, fall back to the RA reg.
         UnwindPlan::Row::RegisterLocation scratch;
         if (m_frame_type == eTrapHandlerFrame &&
-            active_row->GetRegisterInfo 
+            active_row->GetRegisterInfo
               (pc_regnum.GetAsKind (unwindplan_registerkind), scratch)) {
           UnwindLogMsg("Providing pc register instead of rewriting to "
                        "RA reg because this is a trap handler and there is "
                        "a location for the saved pc register value.");
         } else {
           return_address_reg.init(
               m_thread, m_full_unwind_plan_sp->GetRegisterKind(),
               m_full_unwind_plan_sp->GetReturnAddressRegister());
RegisterContextUnwind::SavedLocationForRegister(
 
   if (unwindplan_regloc.IsDWARFExpression() ||
       unwindplan_regloc.IsAtDWARFExpression()) {
     DataExtractor dwarfdata(unwindplan_regloc.GetDWARFExpressionBytes(),
                             unwindplan_regloc.GetDWARFExpressionLength(),
                             process->GetByteOrder(),
                             process->GetAddressByteSize());
     ModuleSP opcode_ctx;
-    DWARFExpression dwarfexpr(opcode_ctx, dwarfdata, nullptr);
-    dwarfexpr.SetRegisterKind(unwindplan_registerkind);
+    DWARFExpressionList dwarfexpr(opcode_ctx, dwarfdata, nullptr);
+    dwarfexpr.GetMutableExpressionAtAddress(0)->SetRegisterKind(
+        unwindplan_registerkind);
     Value cfa_val = Scalar(m_cfa);
     cfa_val.SetValueType(Value::ValueType::LoadAddress);
     Value result;
     Status error;
-    if (dwarfexpr.Evaluate(&exe_ctx, this, 0, &cfa_val, nullptr, result,
-                           &error)) {
+    if (dwarfexpr.Evaluate(&exe_ctx, this, &cfa_val, nullptr, result, &error)) {
       addr_t val;
       val = result.GetScalar().ULongLong();
       if (unwindplan_regloc.IsDWARFExpression()) {
         regloc.type = UnwindLLDB::RegisterLocation::eRegisterValueInferred;
         regloc.location.inferred_value = val;
         m_registers[regnum.GetAsKind(eRegisterKindLLDB)] = regloc;
         UnwindLogMsg("supplying caller's register %s (%d) via DWARF expression "
                      "(IsDWARFExpression)",
bool RegisterContextUnwind::ReadFrameAddress(
   case UnwindPlan::Row::FAValue::isDWARFExpression: {
     ExecutionContext exe_ctx(m_thread.shared_from_this());
     Process *process = exe_ctx.GetProcessPtr();
     DataExtractor dwarfdata(fa.GetDWARFExpressionBytes(),
                             fa.GetDWARFExpressionLength(),
                             process->GetByteOrder(),
                             process->GetAddressByteSize());
     ModuleSP opcode_ctx;
-    DWARFExpression dwarfexpr(opcode_ctx, dwarfdata, nullptr);
-    dwarfexpr.SetRegisterKind(row_register_kind);
+    DWARFExpressionList dwarfexpr(opcode_ctx, dwarfdata, nullptr);
+    dwarfexpr.GetMutableExpressionAtAddress(0)->SetRegisterKind(
+        row_register_kind);
     Value result;
     Status error;
-    if (dwarfexpr.Evaluate(&exe_ctx, this, 0, nullptr, nullptr, result,
+    if (dwarfexpr.Evaluate(&exe_ctx, this, nullptr, nullptr, result,
                            &error)) {
       address = result.GetScalar().ULongLong();
       if (ABISP abi_sp = m_thread.GetProcess()->GetABI())
         address = abi_sp->FixCodeAddress(address);
 
       UnwindLogMsg("CFA value set by DWARF expression is 0x%" PRIx64,
                    address);
       return true;

lldb/source/Target/StackFrame.cpp

bool StackFrame::GetFrameBaseValue(Scalar &frame_base, Status *error_ptr) {
   if (m_flags.IsClear(GOT_FRAME_BASE)) {
     if (m_sc.function) {
       m_frame_base.Clear();
       m_frame_base_error.Clear();
 
       m_flags.Set(GOT_FRAME_BASE);
       ExecutionContext exe_ctx(shared_from_this());
       Value expr_value;
-      addr_t loclist_base_addr = LLDB_INVALID_ADDRESS;
-      if (m_sc.function->GetFrameBaseExpression().IsLocationList())
-        loclist_base_addr =
-            m_sc.function->GetAddressRange().GetBaseAddress().GetLoadAddress(
-                exe_ctx.GetTargetPtr());
-
       if (!m_sc.function->GetFrameBaseExpression().Evaluate(
-              &exe_ctx, nullptr, loclist_base_addr, nullptr, nullptr,
-              expr_value, &m_frame_base_error)) {
+              &exe_ctx, nullptr, nullptr, nullptr, expr_value,
+              &m_frame_base_error)) {
         // We should really have an error if evaluate returns, but in case we
         // don't, lets set the error to something at least.
         if (m_frame_base_error.Success())
           m_frame_base_error.SetErrorString(
               "Evaluation of the frame base expression failed.");
       } else {
         m_frame_base = expr_value.ResolveValue(&exe_ctx);
       }
     } else {
       m_frame_base_error.SetErrorString("No function in symbol context.");
     }
   }
 
   if (m_frame_base_error.Success())
     frame_base = m_frame_base;
 
   if (error_ptr)
     *error_ptr = m_frame_base_error;
   return m_frame_base_error.Success();
 }
 
-DWARFExpression *StackFrame::GetFrameBaseExpression(Status *error_ptr) {
+DWARFExpressionList *StackFrame::GetFrameBaseExpression(Status *error_ptr) {
   if (!m_sc.function) {
     if (error_ptr) {
       error_ptr->SetErrorString("No function in symbol context.");
     }
     return nullptr;
   }
 
   return &m_sc.function->GetFrameBaseExpression();
if (cu)
     return cu->GetLanguage();
   return lldb::eLanguageTypeUnknown;
 }
 
 lldb::LanguageType StackFrame::GuessLanguage() {
   LanguageType lang_type = GetLanguage();
 
   if (lang_type == eLanguageTypeUnknown) {
-    SymbolContext sc = GetSymbolContext(eSymbolContextFunction 
+    SymbolContext sc = GetSymbolContext(eSymbolContextFunction
                                         | eSymbolContextSymbol);
     if (sc.function) {
       lang_type = sc.function->GetMangled().GuessLanguage();
     }
     else if (sc.symbol)
     {
       lang_type = sc.symbol->GetMangled().GuessLanguage();
     }
ValueObjectSP GetValueForDereferincingOffset(StackFrame &frame,
   // ValueObject for the result of *(base+offset)
 
   if (!base->IsPointerOrReferenceType()) {
     return ValueObjectSP();
   }
 
   Status error;
   ValueObjectSP pointee = base->Dereference(error);
-    
   if (!pointee) {
     return ValueObjectSP();
   }
 
   if (offset >= 0 && uint64_t(offset) >= pointee->GetByteSize()) {
     int64_t index = offset / pointee->GetByteSize().getValueOr(1);
     offset = offset % pointee->GetByteSize().getValueOr(1);
     const bool can_create = true;
Instruction::Operand op =
       offset ? Instruction::Operand::BuildDereference(
                    Instruction::Operand::BuildSum(
                        Instruction::Operand::BuildRegister(reg),
                        Instruction::Operand::BuildImmediate(offset)))
              : Instruction::Operand::BuildDereference(
                    Instruction::Operand::BuildRegister(reg));
 
   for (VariableSP var_sp : variables) {
-    if (var_sp->LocationExpression().MatchesOperand(frame, op))
+    if (var_sp->LocationExpressionList().MatchesOperand(frame, op))
       return frame.GetValueObjectForFrameVariable(var_sp, eNoDynamicValues);
   }
 
   const uint32_t current_inst =
       disassembler.GetInstructionList().GetIndexOfInstructionAtAddress(pc);
   if (current_inst == UINT32_MAX) {
     return ValueObjectSP();
   }

lldb/test/Shell/SymbolFile/DWARF/x86/debug_loc.s

 
 # CHECK-LABEL: image dump symfile
 # CHECK: CompileUnit{0x00000000}
 # CHECK:   Function{
 # CHECK:     Variable{{.*}}, name = "x0", {{.*}}, scope = parameter, location =
 # CHECK-NEXT:  [0x0000000000000000, 0x0000000000000001): DW_OP_reg5 RDI
 # CHECK-NEXT:  [0x0000000000000001, 0x0000000000000006): DW_OP_reg0 RAX
 # CHECK:     Variable{{.*}}, name = "x1", {{.*}}, scope = parameter
-# CHECK:     Variable{{.*}}, name = "x2", {{.*}}, scope = parameter, location = 0x00000000: error: unexpected end of data
+# CHECK:     Variable{{.*}}, name = "x2", {{.*}}, scope = parameter
 # CHECK:     Variable{{.*}}, name = "x3", {{.*}}, scope = parameter, location =
 # CHECK-NEXT:  [0x0000000000000002, 0x0000000000000003): DW_OP_reg1 RDX
-# LOCLISTS:  Variable{{.*}}, name = "x4", {{.*}}, scope = parameter, location =
-# LOCLISTS-NEXT: DW_LLE_startx_length   (0x000000000000dead, 0x0000000000000001): DW_OP_reg2 RCX
+# LOCLISTS:  Variable{{.*}}, name = "x4", {{.*}}, scope = parameter
+# LOCLISTS-EMPTY:
 
 .ifdef LOC
 .macro OFFSET_PAIR lo hi
         .quad \lo
         .quad \hi
 .endm
 
 .macro BASE_ADDRESS base

lldb/test/Shell/SymbolFile/DWARF/x86/dwp.s

 # CHECK: Function: {{.*}}, name = "F1", range = [0x0000000000000001-0x0000000000000002)
 # CHECK: Variable: {{.*}}, name = "x", type = "int", valid ranges = <block>, location = [0x0000000000000001, 0x0000000000000002) -> DW_OP_reg1 RDX
 
 # SYMBOLS:      Compile units:
 # SYMBOLS-NEXT: CompileUnit{0x00000000}, language = "<not loaded>", file = '0.c'
 # SYMBOLS-NEXT:   Variable{{.*}}, name = "A", {{.*}}, location = DW_OP_GNU_addr_index 0x0
 # SYMBOLS-NEXT:   Function{{.*}}, demangled = F0
 # SYMBOLS-NEXT:   Block{{.*}}, ranges = [0x00000000-0x00000001)
-# SYMBOLS-NEXT:     Variable{{.*}}, name = "x", {{.*}}, location = 
-# SYMBOLS-NEXT:       DW_LLE_startx_length   (0x0000000000000001, 0x0000000000000001): DW_OP_reg0 RAX
+# SYMBOLS-NEXT:     Variable{{.*}}, name = "x", {{.*}}, location =
+# SYMBOLS-NEXT:       [0x0000000000000000, 0x0000000000000001): DW_OP_reg0 RAX
 # SYMBOLS-EMPTY:
 # SYMBOLS-NEXT: CompileUnit{0x00000001}, language = "<not loaded>", file = '1.c'
 # SYMBOLS-NEXT:   Variable{{.*}}, name = "A", {{.*}}, location = DW_OP_GNU_addr_index 0x2
 # SYMBOLS-NEXT:   Function{{.*}}, demangled = F1
 # SYMBOLS-NEXT:   Block{{.*}}, ranges = [0x00000001-0x00000002)
-# SYMBOLS-NEXT:     Variable{{.*}}, name = "x", {{.*}}, location = 
-# SYMBOLS-NEXT:       DW_LLE_startx_length   (0x0000000000000003, 0x0000000000000001): DW_OP_reg1 RDX
+# SYMBOLS-NEXT:     Variable{{.*}}, name = "x", {{.*}}, location =
+# SYMBOLS-NEXT:       [0x0000000000000001, 0x0000000000000002): DW_OP_reg1 RDX
 # SYMBOLS-EMPTY:
 # SYMBOLS-NEXT: CompileUnit{0x00000002}, language = "<not loaded>", file = '2.c'
 # SYMBOLS-NEXT:   Variable{{.*}}, name = "A", {{.*}}, location = DW_OP_GNU_addr_index 0x4
 # SYMBOLS-NEXT:   Function{{.*}}, demangled = F2
 # SYMBOLS-NEXT:   Block{{.*}}, ranges = [0x00000002-0x00000003)
-# SYMBOLS-NEXT:     Variable{{.*}}, name = "x", {{.*}}, location = 
-# SYMBOLS-NEXT:       DW_LLE_startx_length   (0x0000000000000005, 0x0000000000000001): DW_OP_reg2 RCX
+# SYMBOLS-NEXT:     Variable{{.*}}, name = "x", {{.*}}, location =
+# SYMBOLS-NEXT:       [0x0000000000000002, 0x0000000000000003): DW_OP_reg2 RCX
 # SYMBOLS-EMPTY:
 # SYMBOLS-NEXT: CompileUnit{0x00000003}, language = "<not loaded>", file = '3.c'
 # SYMBOLS-NEXT:   Variable{{.*}}, name = "A", {{.*}}, location = DW_OP_GNU_addr_index 0x6
 # SYMBOLS-NEXT:   Function{{.*}}, demangled = F3
 # SYMBOLS-NEXT:   Block{{.*}}, ranges = [0x00000003-0x00000004)
-# SYMBOLS-NEXT:     Variable{{.*}}, name = "x", {{.*}}, location = 
-# SYMBOLS-NEXT:       DW_LLE_startx_length   (0x0000000000000007, 0x0000000000000001): DW_OP_reg3 RBX
+# SYMBOLS-NEXT:     Variable{{.*}}, name = "x", {{.*}}, location =
+# SYMBOLS-NEXT:       [0x0000000000000003, 0x0000000000000004): DW_OP_reg3 RBX
 # SYMBOLS-EMPTY:
 # SYMBOLS-NEXT: CompileUnit{0x00000004}, language = "<not loaded>", file = ''
 # SYMBOLS-EMPTY:
 
         .section        .debug_abbrev,"",@progbits
         .byte   1                       # Abbreviation Code
         .byte   17                      # DW_TAG_compile_unit
         .byte   0                       # DW_CHILDREN_no

 .Lstr_offsets\I:
         .long   .Lstr\I-.debug_str.dwo
 .Lstr_offsets_end\I:
 
         .section        .debug_loc.dwo,"e",@progbits
 .Lloc\I:
         .byte   3                       # DW_LLE_startx_length
         .uleb128 \I*2+1
-        .long   1                
+        .long   1
         .short 1                      # Expression size
         .byte   80+\I                   # super-register DW_OP_reg0+\I
         .byte   0                       # DW_LLE_end_of_list
 .Lloc_end\I:
 
         .section        .debug_abbrev.dwo,"e",@progbits
 .Labbrev\I:
         .byte   \I*10+1                 # Abbreviation Code

llvm/lib/DebugInfo/DWARF/DWARFDebugLoc.cpp

 Error DWARFLocationTable::visitAbsoluteLocationList(
     uint64_t Offset, Optional<SectionedAddress> BaseAddr,
     std::function<Optional<SectionedAddress>(uint32_t)> LookupAddr,
     function_ref<bool(Expected<DWARFLocationExpression>)> Callback) const {
   DWARFLocationInterpreter Interp(BaseAddr, std::move(LookupAddr));
   return visitLocationList(&Offset, [&](const DWARFLocationEntry &E) {
     Expected<Optional<DWARFLocationExpression>> Loc = Interp.Interpret(E);
     if (!Loc)
-      return Callback(Loc.takeError());
-    if (*Loc)
+      consumeError(Loc.takeError());
+    else if (*Loc)
       return Callback(**Loc);
     return true;
   });
 }
 
 void DWARFDebugLoc::dump(raw_ostream &OS, const MCRegisterInfo *MRI,
                          const DWARFObject &Obj, DIDumpOptions DumpOpts,
                          Optional<uint64_t> DumpOffset) const {

llvm/utils/gn/secondary/lldb/source/Expression/BUILD.gn

deps = [
 
     # FIXME:
     # DEPENDS
     # intrinsics_gen
   ]
   include_dirs = [ ".." ]
   sources = [
     "DWARFExpression.cpp",
+    "DWARFExpressionList.cpp",
     "DiagnosticManager.cpp",
     "Expression.cpp",
     "ExpressionVariable.cpp",
     "FunctionCaller.cpp",
     "IRExecutionUnit.cpp",
     "IRInterpreter.cpp",
     "IRMemoryMap.cpp",
     "LLVMUserExpression.cpp",
     "Materializer.cpp",
     "REPL.cpp",
     "UserExpression.cpp",
     "UtilityFunction.cpp",
   ]
 }