[LLDB] Dump valid ranges of variables

[zequanwu]

Summary

This allows image lookup -a ... -v to print variables only if the given
address is covered by the valid ranges of the variables. Since variables created
in dwarf plugin always has empty scope range, print the variable if it has
empty scope.

[jingham]

It's really useful to be able to see these variable ranges, so the feature seems good to me, but I think the valid range output should be governed by another flag, like --show-variable-ranges. In optimized code, there can be a whole lot of ranges for each variable, so this could get really noisy and make the whole output hard to look at, so it would be good to have a way to turn it off. Unfortunately -v doesn't work for that since the non -v version isn't so useful.

[zequanwu]

In D119963#3327139, @jingham wrote:

It's really useful to be able to see these variable ranges, so the feature seems good to me, but I think the valid range output should be governed by another flag, like --show-variable-ranges. In optimized code, there can be a whole lot of ranges for each variable, so this could get really noisy and make the whole output hard to look at, so it would be good to have a way to turn it off.

Using a flag to control it seems good to me.

Unfortunately -v doesn't work for that since the non -v version isn't so useful.

I don't quite understand what you mean here. I suppose we want a flag --show-variable-ranges to have effect only when -v is given in image lookup -v -a .... Is this what you mean?

[jingham]

In D119963#3327472, @zequanwu wrote:

In D119963#3327139, @jingham wrote:

It's really useful to be able to see these variable ranges, so the feature seems good to me, but I think the valid range output should be governed by another flag, like --show-variable-ranges. In optimized code, there can be a whole lot of ranges for each variable, so this could get really noisy and make the whole output hard to look at, so it would be good to have a way to turn it off.

Using a flag to control it seems good to me.

Unfortunately -v doesn't work for that since the non -v version isn't so useful.

I don't quite understand what you mean here. I suppose we want a flag --show-variable-ranges to have effect only when -v is given in image lookup -v -a .... Is this what you mean?

I was addressing another unasked question: It seemed odd to say "add another flag to reduce the amount of output for something that is only printed when the user asks for verbose output". So I was trying to explain why that made sense. The reason being that when we made the "image lookup" command, the non-verbose version wasn't actually terribly useful, but the verbose version was. So pretty much everybody uses the -v flag when the command is used. The other option would be to do the horrible thing some tools do and have multiple -v's meaning more and more verbose. You could do it that way too (the option parser can count the number of -v's it has seen). But I think it's a lot better to have an option to dial up the specific extra info you want in this case.

But you are right, we don't print the variable information at all without -v, so while it's odd to have --show-variable-ranges only take effect when -v is supplied, I think that's the reasonable way to do it.

[zequanwu]

Add -show-variables-ranges/-R flag to enable it with -v.

[labath]

This comment has been deleted.

lldb/source/Commands/Options.td

960

961

A not widely known fact: It is possible to produce an long option without a short version by using an non-printable character in place of the short option. You can see and example of that in disassemble --force, defined in this file.

If we are considering this a niche option, then maybe we don't need to use a random character just to have a short version.

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

29

I don't think that the information itself is out of place here, but I think it can get confusing when one sees it like this, next to the location field. So, if we had an output like location = RDI, valid ranges = [0, 20), I think one would/could read it as "the variable is in RDI from PC=0 to PC=20", but what it _really_ is telling you is "the variable (or its value -- I'm not sure) exists between PC=0 and PC=20, *and* for the exact PC that you are querying (0 in this case), it's value happens to be in RDI".

We could try to come up with a way to make this less confusing, but maybe we could just sidestep this problem and just print this information in the image dump symfile output.

39

If you printed the information here, then there would be no (or less) confusion as the location field contains explicit range information. Additionally, the image dump symfile output is so verbose, than an extra field does not make a difference.

(I'm sorry, I know it was I who suggested using image lookup, but I did not realize you would be adding an extra argument because of that.)

[jingham]

There was a question on the dev list a while ago about to print out all the valid ranges of a variable. That's a useful bit of info if you're trying to figure out where you could break to actually see or change a variable's value in an optimized function. I think that's the motivation for the change, so just showing the range that encompasses the address wouldn't satisfy that initial impetus for the change.

It is a little awkward to put it in "image lookup -va" however, and odder to have it be part of the printing of an Address. It seems more like something you should ask a function?

Jim

[zequanwu]

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

29

I think this confusion can be solved by adding an argument for --show-variable-ranges. When only --show-variable-ranges is given, dump only the range that covers the querying address. When it comes with all argument, dump all valid ranges.

40–41

image dump symfile already prints valid ranges for variables along with where the value is at each range.

[labath]

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

40–41

Are you sure it does?

I was under the impression that there are two distinct range concepts being combined here. One is the range list member of the Variable object (as given by GetScopeRange -- that's the one you're printing now), and the other is the list of ranges hidden in the DWARFExpression object, which come from the debug_loc(lists) section (that's the one we've been printing so far). And that the root cause of the confusion is the very existence of these two concepts.

If I got it wrong, then do let me know, cause it would make things a lot simpler if there is only one validity concept to think about.

[zequanwu]

This comment has been deleted.

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

40–41

Dwarf plugin is supposed to construct the m_scope_range member of an Variable, but it doesn't. scope_ranges is empty at https://github.com/llvm/llvm-project/blob/main/lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp#L3468.
image dump symfile dumps the dwarf location list in m_location in Variable.
The dwarf location list has more information than m_scope_range as it contains info about where the value is during each range. (e.g. which register the variable lives in).

So, I think we need to use similar logic to construct m_scope_range when creating Variable in dwarf plugin like this https://github.com/llvm/llvm-project/blob/main/lldb/source/Expression/DWARFExpression.cpp#L145.

[labath]

In D119963#3329973, @jingham wrote:

There was a question on the dev list a while ago about to print out all the valid ranges of a variable. That's a useful bit of info if you're trying to figure out where you could break to actually see or change a variable's value in an optimized function. I think that's the motivation for the change, so just showing the range that encompasses the address wouldn't satisfy that initial impetus for the change.

I'm pretty sure the immediate motivation is testing of D119508, but yes, if there was another feature request for something like this, then it makes sense to implement it more fully.

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

40–41

Ok, I see where you're coming from. You're essentially saying that the fact that the dwarf plugin does not fill this out is a bug.

I don't think that's the case. My interpretation was (and this comment confirms it) that an empty range here means the entire enclosing block. (Also, DWARF was for a long time the only symbol file plugin, so what it does is kinda "correct by definition").

I don't think we want to change that interpretation, as forcing a copy of the range in the location list would be wasteful (it would be different if this was an interface that one could query, and that the dwarf plugin could implement by consulting the location list). However, since the dwarf class does not actually make use of this functionality (it was added to support DW_AT_start_scope, then broken at some point, and eventually removed), we do have some freedom in defining the interactions of the two fields (if you still want to pursue this, that is).

So how about this: if the user passes the extra flag, then we print both the range field (if it exists), and the *full* location list (in that order, ideally). That way the output will be either range = [a, b), [c, d), location = DW_OP_reg47 or location = [a,b) -> DW_OP_reg4, [c,d) -> DW_OP_reg7. If the dwarf plugin starts using the range field again then the output will contain both fields, which will be slightly confusing, but at least not misleading (and we can also change the format then).

[zequanwu]

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

40–41

Oh, I think I misunderstood m_scope_range. It's the range list where the variable is valid regardless whether its value is accessible or not (valid range). As for m_location in Variable, it's describing the ranges where the value is (value range). They are not the same.

So, currently how NativePDB creates local Variable's range is not correct. That only works when it's not optimized build such that the valid range is the same as the value range. It still need to create dwarf location lists to correctly represent the value range, but as mentioned here, we need to choose a generic "variable location provider" interface for that.

[labath]

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

40–41

Oh, I think I misunderstood m_scope_range. It's the range list where the variable is valid regardless whether its value is accessible or not (valid range). As for m_location in Variable, it's describing the ranges where the value is (value range).

Yes, that was my initial assumption as well, and I think that is the only interpretation in which it makes sense to have two sources of range information for a variable. However, I've done some research since then, and I haven't found any compiler or debugger which would model the program sufficiently precisely to be able to make that distinction.

There are definite limits as to how far you can go with pdb using these abstractions, but given they (the m_scope_range) exist, I think you could make use of them (as you've done now), if they are sufficient for your current use case. That said, I would definitely encourage you to create a better abstraction for providing the location information for a variable.

[zequanwu]

• Use -show-variable-ranges/-R single/all to dump single addres range that contains the querying address or all address ranges. It seeme like I can't use non-printable character like \\x01 to omit short option when it takes a parameter, so -R is used as abbrev "range".
• Refactor DWARFExpression::GetLocationExpression.

[zequanwu]

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

40–41

I think you meant to replace DWARFExpression with a more generic interface which has the same functionalities as DWARFExpression. That seems a lot work, especially on DWARFExpression::Evaluate.

[labath]

I'm not sure about ModuleLookupShowRange::Single option. It feels like it just complicates things. Did anyone request that?

FWIW, I don't think that dumping a /single/ range is particularly verbose, so I could imagine even doing that by default.

I think it should be sufficient to have just two modes, either None+All, or Single+All. Having three seems like overkill.

lldb/source/Core/Address.cpp

734–740

Use DumpAddressRange from Utility/Stream.h

766–777

Can we get rid of this lambda by inlining it into DumpLocations. I don't think we need that much flexibility.

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

20

print something like valid ranges = <block>, or maybe don't print anything at all?

40–41

Well.. not exactly "replace". You know how they say there's no software engineering problem that can't be solved by adding a layer of indirection. So, I thought we could create a new VariableLocationProvider (for lack of a better name) interface, and one of the implementations of that interface would be backed by a DWARFExpression class. Theoretically you may not need to touch the DWARFExpression class at all -- just wrap it so that it conforms to the new interface.

This is still pretty hand-wavy, so I don't know how much work would it be, but it does not seem like it should be _that_ hard..

[zequanwu]

• Remove short option. -show-variable-ranges prints all ranges. If not given, only print single range.
• Address comments.

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

40–41

Thanks, I see what you mean. I thought it would be each symbol file plugin needs to convert their debug formats to a universal one and the actual evaluation will happens in that one.

[labath]

lldb/source/Core/Address.cpp

739

This place was the only caller of Variable::DumpLocationForAddress. What if we, instead of duplicating its logic here, just change the function to do what we want?
The interface could be as simple as Variable::DumpLocations(Stream&, Address) where, if one provides an invalid Address, then all locations get dumped, and one can request a specific location by providing a concrete address.
We might even do something similar for the DWARFExpression class, and avoid the filter callbacks completely.

lldb/source/Expression/DWARFExpression.cpp

2735–2738

Could the sliding happen inside GetLocationExpressions, so that we don't have to repeat it in each callback?

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

40–41

It's true that how most of our debug parsing works by converting the debug info into a generic format, but that is something I would want to change. It is really easy to construct the generic format from dwarf debug info (because it was designed that way), but the other symbol file plugins are often struggling to fit into this model. They often have the data that lldb needs easily accessible, just not in the format that lldb can accept, and so they often have to create copies just to put it into the required format. To some extent, this is also what happened with the dwarf, as we started using some of the llvm libraries to parse the debug info.

So overall, I think it would be better to just prescribe an interface through which one can query e.g. the line tables, and leave it up to the plugins to choose a suitable data structure to answer those queries. And I can't think of a better example for why is this needed than dwarf expression evaluation.

[zequanwu]

Update.

lldb/source/Core/Address.cpp

739

I just moved the filter inside Variable::DumpLocations, because we still need to pass the filter callback to DWARFExpression::DumpLocaitons inside Variable::DumpLocaitons to choose dumping all ranges + locations or just one range location.

[labath]

lldb/source/Core/Address.cpp

739

Looking at it now, I think it'd be better to inline the callback all the way into DWARFExpression::DumpLocations. The callback is more flexible, but I'm not convinced that we need that flexibility, and the interface of the callback is pretty complex (two bool return values). I believe it would be sufficient if the function accepted an extra address argument (as an addr_t probably), and used an invalid address (LLDB_INVALID_ADDRESS) to mean "dump all locations".

lldb/source/Expression/DWARFExpression.cpp

2683

llvm::ListSeparator separator;

2691–2692

s->AsRawOstream() << separator;

lldb/source/Symbol/Variable.cpp

448

Can we keep abi and func_load_addr computations in this function? (It probably was easier to make them arguments starting from the last version of your patch, but putting the code here would reduce the diff from HEAD and also make the interface simpler).

[zequanwu]

update.

[zequanwu]

Remove unnecessary location_list_base_addr parameter from GetDescription() as it doesn't do filtering when dumping.

[labath]

Looks good, I'm sorry this took so long.

Jim, do you have anything to add?

lldb/source/Symbol/Variable.cpp

439–440

Maybe move into a header?

[jingham]

Yeah, just a couple little things in the comments. Otherwise this looks good.

lldb/include/lldb/Core/Address.h

250

You should document all_ranges.

lldb/source/Commands/Options.td

962

I missed where you return an error if somebody specifies show-variable-ranges == true w/o specifying verbose. Did I miss that?

lldb/source/Expression/DWARFExpression.cpp

2741

Local variables in lldb are all lower case and describe what they are.

[zequanwu]

Address comments

lldb/source/Commands/Options.td

962

If show-variable-ranges is given but not -v, then show-variable-ranges has no effect. I don't know if there is way to make it gives an error in that case.
I tried to make show-variable-ranges group 7 and verbose GroupRange <1,7>, then -v and show-variable-ranges combination is invalid.

[jingham]

In D119963#3355501, @zequanwu wrote:

Address comments

This sort of thing is hard to check in the option groups w/o blowing out the number of groups you need to have.

The way to check after all the option parsing is done that the options are coherent is to have the CommandOptions implement OptionParsingFinished, check the if the all_ranges is set verbose is also set, and if it isn't return a suitable error.

Can you do this (even though I see you've checked it in already.) Silently having some combination of options not work isn't a good thing.

[zequanwu]

In D119963#3355563, @jingham wrote:

In D119963#3355501, @zequanwu wrote:

Address comments

This sort of thing is hard to check in the option groups w/o blowing out the number of groups you need to have.

The way to check after all the option parsing is done that the options are coherent is to have the CommandOptions implement OptionParsingFinished, check the if the all_ranges is set verbose is also set, and if it isn't return a suitable error.

Can you do this (even though I see you've checked it in already.) Silently having some combination of options not work isn't a good thing.

Thanks. I added it at https://reviews.llvm.org/rG302d7179e101ebbf48c386a632828a1150a18769.

[jingham]

Excellent, thanks!

lldb/include/lldb/Core/Address.h

///     A const Address object reference to \a this.
   ///     The stream to which to dump the object description.
   ///
   /// \param[in] style
   ///     The display style for the address.
   ///
   /// \param[in] fallback_style
   ///     The display style for the address.
   ///
+  /// \param[in] addr_byte_size
+  ///     The address byte size for the address.
+  ///
+  /// \param[in] all_ranges
+  ///     If true, dump all valid ranges and value ranges for the variable that
+  ///     contains the address, otherwise dumping the range that contains the
+  ///     address.
+  ///
   /// \return
   ///     Returns \b true if the address was able to be displayed.
   ///     File and load addresses may be unresolved and it may not be
   ///     possible to display a valid value, \b false will be returned
   ///     in such cases.
   ///
   /// \see Address::DumpStyle
   bool Dump(Stream *s, ExecutionContextScope *exe_scope, DumpStyle style,
             DumpStyle fallback_style = DumpStyleInvalid,
-            uint32_t addr_byte_size = UINT32_MAX) const;
+            uint32_t addr_byte_size = UINT32_MAX,
+            bool all_ranges = false) const;
 
   AddressClass GetAddressClass() const;
 
   /// Get the file address.
   ///
   /// If an address comes from a file on disk that has section relative
   /// addresses, then it has a virtual address that is relative to unique
   /// section in the object file.

lldb/include/lldb/Expression/DWARFExpression.h

 #define LLDB_EXPRESSION_DWARFEXPRESSION_H
 
 #include "lldb/Core/Address.h"
 #include "lldb/Core/Disassembler.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Scalar.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/lldb-private.h"
+#include "llvm/DebugInfo/DWARF/DWARFLocationExpression.h"
 #include <functional>
 
 class DWARFUnit;
 
 namespace lldb_private {
 
 /// \class DWARFExpression DWARFExpression.h
 /// "lldb/Expression/DWARFExpression.h" Encapsulates a DWARF location
public:
   /// 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] location_list_base_addr
-  ///     If this is a location list based expression, this is the
-  ///     address of the object that owns it. NOTE: this value is
-  ///     different from the DWARF version of the location list base
-  ///     address which is compile unit relative. This base address
-  ///     is the address of the object that owns the location list.
-  ///
   /// \param[in] abi
   ///     An optional ABI plug-in that can be used to resolve register
   ///     names.
-  void GetDescription(Stream *s, lldb::DescriptionLevel level,
-                      lldb::addr_t location_list_base_addr, ABI *abi) const;
+  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
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;
+
   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

lldb/include/lldb/Symbol/Variable.h

public:
   bool IsArtificial() const { return m_artificial; }
 
   bool IsStaticMember() const { return m_static_member; }
 
   DWARFExpression &LocationExpression() { return m_location; }
 
   const DWARFExpression &LocationExpression() const { return m_location; }
 
-  bool DumpLocationForAddress(Stream *s, const Address &address);
+  // 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);
 
   bool IsInScope(StackFrame *frame);
 
   bool LocationIsValidForFrame(StackFrame *frame);

lldb/source/Commands/CommandObjectTarget.cpp

 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Target/ThreadSpec.h"
 #include "lldb/Utility/Args.h"
 #include "lldb/Utility/LLDBLog.h"
 #include "lldb/Utility/State.h"
 #include "lldb/Utility/Timer.h"
+#include "lldb/lldb-private-enumerations.h"
 
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/FormatAdapters.h"
 
 
 using namespace lldb;
 using namespace lldb_private;
if (SymbolFile *symbol_file = module->GetSymbolFile(true)) {
       symbol_file->Dump(strm);
       return true;
     }
   }
   return false;
 }
 
 static void DumpAddress(ExecutionContextScope *exe_scope,
-                        const Address &so_addr, bool verbose, Stream &strm) {
+                        const Address &so_addr, bool verbose, bool all_ranges,
+                        Stream &strm) {
   strm.IndentMore();
   strm.Indent("    Address: ");
   so_addr.Dump(&strm, exe_scope, Address::DumpStyleModuleWithFileAddress);
   strm.PutCString(" (");
   so_addr.Dump(&strm, exe_scope, Address::DumpStyleSectionNameOffset);
   strm.PutCString(")\n");
   strm.Indent("    Summary: ");
   const uint32_t save_indent = strm.GetIndentLevel();
   strm.SetIndentLevel(save_indent + 13);
   so_addr.Dump(&strm, exe_scope, Address::DumpStyleResolvedDescription);
   strm.SetIndentLevel(save_indent);
   // Print out detailed address information when verbose is enabled
   if (verbose) {
     strm.EOL();
-    so_addr.Dump(&strm, exe_scope, Address::DumpStyleDetailedSymbolContext);
+    so_addr.Dump(&strm, exe_scope, Address::DumpStyleDetailedSymbolContext,
+                 Address::DumpStyleInvalid, UINT32_MAX, all_ranges);
   }
   strm.IndentLess();
 }
 
 static bool LookupAddressInModule(CommandInterpreter &interpreter, Stream &strm,
                                   Module *module, uint32_t resolve_mask,
                                   lldb::addr_t raw_addr, lldb::addr_t offset,
-                                  bool verbose) {
+                                  bool verbose, bool all_ranges) {
   if (module) {
     lldb::addr_t addr = raw_addr - offset;
     Address so_addr;
     SymbolContext sc;
     Target *target = interpreter.GetExecutionContext().GetTargetPtr();
     if (target && !target->GetSectionLoadList().IsEmpty()) {
       if (!target->GetSectionLoadList().ResolveLoadAddress(addr, so_addr))
         return false;
       else if (so_addr.GetModule().get() != module)
         return false;
     } else {
       if (!module->ResolveFileAddress(addr, so_addr))
         return false;
     }
 
     ExecutionContextScope *exe_scope =
         interpreter.GetExecutionContext().GetBestExecutionContextScope();
-    DumpAddress(exe_scope, so_addr, verbose, strm);
+    DumpAddress(exe_scope, so_addr, verbose, all_ranges, strm);
     //        strm.IndentMore();
     //        strm.Indent ("    Address: ");
     //        so_addr.Dump (&strm, exe_scope,
     //        Address::DumpStyleModuleWithFileAddress);
     //        strm.PutCString (" (");
     //        so_addr.Dump (&strm, exe_scope,
     //        Address::DumpStyleSectionNameOffset);
     //        strm.PutCString (")\n");
static bool LookupAddressInModule(CommandInterpreter &interpreter, Stream &strm,
   }
 
   return false;
 }
 
 static uint32_t LookupSymbolInModule(CommandInterpreter &interpreter,
                                      Stream &strm, Module *module,
                                      const char *name, bool name_is_regex,
-                                     bool verbose) {
+                                     bool verbose, bool all_ranges) {
   if (!module)
     return 0;
 
   Symtab *symtab = module->GetSymtab();
   if (!symtab)
     return 0;
 
   SymbolContext sc;
if (num_matches > 0) {
     DumpFullpath(strm, &module->GetFileSpec(), 0);
     strm.PutCString(":\n");
     strm.IndentMore();
     for (uint32_t i = 0; i < num_matches; ++i) {
       Symbol *symbol = symtab->SymbolAtIndex(match_indexes[i]);
       if (symbol && symbol->ValueIsAddress()) {
         DumpAddress(
             interpreter.GetExecutionContext().GetBestExecutionContextScope(),
-            symbol->GetAddressRef(), verbose, strm);
+            symbol->GetAddressRef(), verbose, all_ranges, strm);
       }
     }
     strm.IndentLess();
   }
   return num_matches;
 }
 
 static void DumpSymbolContextList(ExecutionContextScope *exe_scope,
                                   Stream &strm, SymbolContextList &sc_list,
-                                  bool verbose) {
+                                  bool verbose, bool all_ranges) {
   strm.IndentMore();
 
   const uint32_t num_matches = sc_list.GetSize();
 
   for (uint32_t i = 0; i < num_matches; ++i) {
     SymbolContext sc;
     if (sc_list.GetContextAtIndex(i, sc)) {
       AddressRange range;
 
       sc.GetAddressRange(eSymbolContextEverything, 0, true, range);
 
-      DumpAddress(exe_scope, range.GetBaseAddress(), verbose, strm);
+      DumpAddress(exe_scope, range.GetBaseAddress(), verbose, all_ranges, strm);
     }
   }
   strm.IndentLess();
 }
 
 static size_t LookupFunctionInModule(CommandInterpreter &interpreter,
                                      Stream &strm, Module *module,
                                      const char *name, bool name_is_regex,
                                      const ModuleFunctionSearchOptions &options,
-                                     bool verbose) {
+                                     bool verbose, bool all_ranges) {
   if (module && name && name[0]) {
     SymbolContextList sc_list;
     size_t num_matches = 0;
     if (name_is_regex) {
       RegularExpression function_name_regex((llvm::StringRef(name)));
       module->FindFunctions(function_name_regex, options, sc_list);
     } else {
       ConstString function_name(name);
       module->FindFunctions(function_name, CompilerDeclContext(),
                             eFunctionNameTypeAuto, options, sc_list);
     }
     num_matches = sc_list.GetSize();
     if (num_matches) {
       strm.Indent();
       strm.Printf("%" PRIu64 " match%s found in ", (uint64_t)num_matches,
                   num_matches > 1 ? "es" : "");
       DumpFullpath(strm, &module->GetFileSpec(), 0);
       strm.PutCString(":\n");
       DumpSymbolContextList(
           interpreter.GetExecutionContext().GetBestExecutionContextScope(),
-          strm, sc_list, verbose);
+          strm, sc_list, verbose, all_ranges);
     }
     return num_matches;
   }
   return 0;
 }
 
 static size_t LookupTypeInModule(Target *target,
                                  CommandInterpreter &interpreter, Stream &strm,
static size_t LookupTypeHere(Target *target, CommandInterpreter &interpreter,
   strm.EOL();
   return type_list.GetSize();
 }
 
 static uint32_t LookupFileAndLineInModule(CommandInterpreter &interpreter,
                                           Stream &strm, Module *module,
                                           const FileSpec &file_spec,
                                           uint32_t line, bool check_inlines,
-                                          bool verbose) {
+                                          bool verbose, bool all_ranges) {
   if (module && file_spec) {
     SymbolContextList sc_list;
     const uint32_t num_matches = module->ResolveSymbolContextsForFileSpec(
         file_spec, line, check_inlines, eSymbolContextEverything, sc_list);
     if (num_matches > 0) {
       strm.Indent();
       strm.Printf("%u match%s found in ", num_matches,
                   num_matches > 1 ? "es" : "");
       strm << file_spec;
       if (line > 0)
         strm.Printf(":%u", line);
       strm << " in ";
       DumpFullpath(strm, &module->GetFileSpec(), 0);
       strm.PutCString(":\n");
       DumpSymbolContextList(
           interpreter.GetExecutionContext().GetBestExecutionContextScope(),
-          strm, sc_list, verbose);
+          strm, sc_list, verbose, all_ranges);
       return num_matches;
     }
   }
   return 0;
 }
 
 static size_t FindModulesByName(Target *target, const char *module_name,
                                 ModuleList &module_list,
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
 
       case 'A':
         m_print_all = true;
         break;
 
       case 'r':
         m_use_regex = true;
         break;
+
+      case '\x01':
+        m_all_ranges = true;
+        break;
       default:
         llvm_unreachable("Unimplemented option");
       }
 
       return error;
     }
 
     void OptionParsingStarting(ExecutionContext *execution_context) override {
       m_type = eLookupTypeInvalid;
       m_str.clear();
       m_file.Clear();
       m_addr = LLDB_INVALID_ADDRESS;
       m_offset = 0;
       m_line_number = 0;
       m_use_regex = false;
       m_include_inlines = true;
+      m_all_ranges = false;
       m_verbose = false;
       m_print_all = false;
     }
 
     llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
       return llvm::makeArrayRef(g_target_modules_lookup_options);
     }
 
     int m_type;        // Should be a eLookupTypeXXX enum after parsing options
     std::string m_str; // Holds name lookup
     FileSpec m_file;   // Files for file lookups
     lldb::addr_t m_addr; // Holds the address to lookup
     lldb::addr_t
         m_offset; // Subtract this offset from m_addr before doing lookups.
     uint32_t m_line_number; // Line number for file+line lookups
     bool m_use_regex;       // Name lookups in m_str are regular expressions.
     bool m_include_inlines; // Check for inline entries when looking up by
                             // file/line.
+    bool m_all_ranges;      // Print all ranges or single range.
     bool m_verbose;         // Enable verbose lookup info
     bool m_print_all; // Print all matches, even in cases where there's a best
                       // match.
   };
 
   CommandObjectTargetModulesLookup(CommandInterpreter &interpreter)
       : CommandObjectParsed(interpreter, "target modules lookup",
                             "Look up information within executable and "
bool LookupInModule(CommandInterpreter &interpreter, Module *module,
     case eLookupTypeAddress:
       if (m_options.m_addr != LLDB_INVALID_ADDRESS) {
         if (LookupAddressInModule(
                 m_interpreter, result.GetOutputStream(), module,
                 eSymbolContextEverything |
                     (m_options.m_verbose
                          ? static_cast<int>(eSymbolContextVariable)
                          : 0),
-                m_options.m_addr, m_options.m_offset, m_options.m_verbose)) {
+                m_options.m_addr, m_options.m_offset, m_options.m_verbose,
+                m_options.m_all_ranges)) {
           result.SetStatus(eReturnStatusSuccessFinishResult);
           return true;
         }
       }
       break;
 
     case eLookupTypeSymbol:
       if (!m_options.m_str.empty()) {
         if (LookupSymbolInModule(m_interpreter, result.GetOutputStream(),
                                  module, m_options.m_str.c_str(),
-                                 m_options.m_use_regex, m_options.m_verbose)) {
+                                 m_options.m_use_regex, m_options.m_verbose,
+                                 m_options.m_all_ranges)) {
           result.SetStatus(eReturnStatusSuccessFinishResult);
           return true;
         }
       }
       break;
 
     case eLookupTypeFileLine:
       if (m_options.m_file) {
         if (LookupFileAndLineInModule(
                 m_interpreter, result.GetOutputStream(), module,
                 m_options.m_file, m_options.m_line_number,
-                m_options.m_include_inlines, m_options.m_verbose)) {
+                m_options.m_include_inlines, m_options.m_verbose,
+                m_options.m_all_ranges)) {
           result.SetStatus(eReturnStatusSuccessFinishResult);
           return true;
         }
       }
       break;
 
     case eLookupTypeFunctionOrSymbol:
     case eLookupTypeFunction:
       if (!m_options.m_str.empty()) {
         ModuleFunctionSearchOptions function_options;
         function_options.include_symbols =
             m_options.m_type == eLookupTypeFunctionOrSymbol;
         function_options.include_inlines = m_options.m_include_inlines;
 
         if (LookupFunctionInModule(m_interpreter, result.GetOutputStream(),
                                    module, m_options.m_str.c_str(),
                                    m_options.m_use_regex, function_options,
-                                   m_options.m_verbose)) {
+                                   m_options.m_verbose,
+                                   m_options.m_all_ranges)) {
           result.SetStatus(eReturnStatusSuccessFinishResult);
           return true;
         }
       }
       break;
 
     case eLookupTypeType:
       if (!m_options.m_str.empty()) {

lldb/source/Commands/Options.td

def target_modules_lookup_function : Option<"function", "F">, Group<4>,
     Arg<"FunctionName">, Required, Desc<"Lookup a function by name in the debug"
     " symbols in one or more target modules.">;
   def target_modules_lookup_name : Option<"name", "n">, Group<5>,
     Arg<"FunctionOrSymbol">, Required, Desc<"Lookup a function or symbol by "
     "name in one or more target modules.">;
   def target_modules_lookup_type : Option<"type", "t">, Group<6>, Arg<"Name">,
     Required, Desc<"Lookup a type by name in the debug symbols in one or more "
     "target modules.">;
+  def target_modules_lookup_variables_ranges : Option<"show-variable-ranges", 
+    "\\x01">, GroupRange<1, 6>, Desc<"Dump valid ranges of variables (must be "
+    "used in conjunction with --verbose">;
   def target_modules_lookup_verbose : Option<"verbose", "v">,
     Desc<"Enable verbose lookup information.">;
   def target_modules_lookup_all : Option<"all", "A">, Desc<"Print all matches, "
     "not just the best match, if a best match is available.">;
 }
 
 let Command = "target stop hook add" in {
   def target_stop_hook_add_one_liner : Option<"one-liner", "o">, GroupRange<1,3>,

lldb/source/Core/Address.cpp

 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/Symtab.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/Variable.h"
 #include "lldb/Symbol/VariableList.h"
+#include "lldb/Target/ABI.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/ExecutionContextScope.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/SectionLoadList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/DataExtractor.h"
 #include "lldb/Utility/Endian.h"
if (CalculateSymbolContextLineEntry(line_entry)) {
     s.Printf(" (%s:%u:%u)", line_entry.file.GetFilename().GetCString(),
              line_entry.line, line_entry.column);
     return true;
   }
   return false;
 }
 
 bool Address::Dump(Stream *s, ExecutionContextScope *exe_scope, DumpStyle style,
-                   DumpStyle fallback_style, uint32_t addr_size) const {
+                   DumpStyle fallback_style, uint32_t addr_size,
+                   bool all_ranges) const {
   // If the section was nullptr, only load address is going to work unless we
   // are trying to deref a pointer
   SectionSP section_sp(GetSection());
   if (!section_sp && style != DumpStyleResolvedPointerDescription)
     style = DumpStyleLoadAddress;
 
   ExecutionContext exe_ctx(exe_scope);
   Target *target = exe_ctx.GetTargetPtr();
if (IsSectionOffset()) {
         }
         sc.GetDescription(s, eDescriptionLevelBrief, target);
 
         if (sc.block) {
           bool can_create = true;
           bool get_parent_variables = true;
           bool stop_if_block_is_inlined_function = false;
           VariableList variable_list;
-          sc.block->AppendVariables(can_create, get_parent_variables,
-                                    stop_if_block_is_inlined_function,
-                                    [](Variable *) { return true; },
-                                    &variable_list);
-
+          addr_t file_addr = GetFileAddress();
+          sc.block->AppendVariables(
+              can_create, get_parent_variables,
+              [&](Variable *var) {
+                return var && var->LocationIsValidForAddress(*this);
+              },
+          ABISP abi =
+              ABI::FindPlugin(ProcessSP(), module_sp->GetArchitecture());
           for (const VariableSP &var_sp : variable_list) {
-            if (var_sp && var_sp->LocationIsValidForAddress(*this)) {
-              s->Indent();
-              s->Printf("   Variable: id = {0x%8.8" PRIx64 "}, name = \"%s\"",
-                        var_sp->GetID(), var_sp->GetName().GetCString());
-              Type *type = var_sp->GetType();
-              if (type)
-                s->Printf(", type = \"%s\"", type->GetName().GetCString());
-              else
-                s->PutCString(", type = <unknown>");
-              s->PutCString(", location = ");
-              var_sp->DumpLocationForAddress(s, *this);
-              s->PutCString(", decl = ");
-              var_sp->GetDeclaration().DumpStopContext(s, false);
-              s->EOL();
-            }
-          }
-        }
-      }
+            s->PutCString(", valid ranges = ");
+            if (var_sp->GetScopeRange().IsEmpty())
+              s->PutCString("<block>");
+            else if (all_ranges) {
+              for (auto range : var_sp->GetScopeRange())
+                DumpAddressRange(s->AsRawOstream(), range.GetRangeBase(),
+                                 range.GetRangeEnd(), addr_size);
+            } else if (auto *range =
+                           var_sp->GetScopeRange().FindEntryThatContains(
+                               file_addr))
+              DumpAddressRange(s->AsRawOstream(), range->GetRangeBase(),
+                               range->GetRangeEnd(), addr_size);
+            var_sp->DumpLocations(s, all_ranges ? LLDB_INVALID_ADDRESS : *this);
     } else {
       if (fallback_style != DumpStyleInvalid)
         return Dump(s, exe_scope, fallback_style, DumpStyleInvalid, addr_size);
       return false;
     }
     break;
 
   case DumpStyleResolvedPointerDescription: {
     Process *process = exe_ctx.GetProcessPtr();
     if (process) {
       addr_t load_addr = GetLoadAddress(target);
       if (load_addr != LLDB_INVALID_ADDRESS) {
         Status memory_error;
         addr_t dereferenced_load_addr =
             process->ReadPointerFromMemory(load_addr, memory_error);
         if (dereferenced_load_addr != LLDB_INVALID_ADDRESS) {
           Address dereferenced_addr;
           if (dereferenced_addr.SetLoadAddress(dereferenced_load_addr,
                                                target)) {
             StreamString strm;
             if (dereferenced_addr.Dump(&strm, exe_scope,
                                        DumpStyleResolvedDescription,

lldb/source/Expression/DWARFExpression.cpp

llvm::Optional<llvm::RelocAddrEntry> find(const llvm::DWARFSection &Sec,
     return llvm::None;
   }
 private:
   bool IsLittleEndian;
 };
 }
 
 void DWARFExpression::GetDescription(Stream *s, lldb::DescriptionLevel level,
-                                     addr_t location_list_base_addr,
                                      ABI *abi) const {
   if (IsLocationList()) {
     // We have a location list
     lldb::offset_t offset = 0;
     std::unique_ptr<llvm::DWARFLocationTable> loctable_up =
         m_dwarf_cu->GetLocationTable(m_data);
 
     llvm::MCRegisterInfo *MRI = abi ? &abi->GetMCRegisterInfo() : nullptr;

 
 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);
 }
 
-llvm::Optional<DataExtractor>
-DWARFExpression::GetLocationExpression(addr_t load_function_start,
-                                       addr_t addr) const {
+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);
 
   std::unique_ptr<llvm::DWARFLocationTable> loctable_up =
       m_dwarf_cu->GetLocationTable(m_data);
-  llvm::Optional<DataExtractor> result;
+
   uint64_t offset = 0;
   auto lookup_addr =
       [&](uint32_t index) -> llvm::Optional<llvm::object::SectionedAddress> {
     addr_t address = ReadAddressFromDebugAddrSection(m_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;
-
-      if (loc->Range->LowPC <= addr && addr < loc->Range->HighPC)
-        result = ToDataExtractor(*loc, m_data.GetByteOrder(),
-                                 m_data.GetAddressByteSize());
     }
-    return !result;
+    return callback(*loc);
   };
-  llvm::Error E = loctable_up->visitAbsoluteLocationList(
+  llvm::Error error = loctable_up->visitAbsoluteLocationList(
       offset, llvm::object::SectionedAddress{m_loclist_addresses->cu_file_addr},
       lookup_addr, process_list);
-  if (E)
-    LLDB_LOG_ERROR(log, std::move(E), "{0}");
-  return result;
+  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) {
if (IsLocationList()) {
     addr_t load_function_start =
         sc.function->GetAddressRange().GetBaseAddress().GetFileAddress();
     if (load_function_start == LLDB_INVALID_ADDRESS)
       return false;
 
     addr_t pc = frame.GetFrameCodeAddress().GetLoadAddress(
         frame.CalculateTarget().get());
 
-    if (llvm::Optional<DataExtractor> expr = GetLocationExpression(load_function_start, pc))
+    if (llvm::Optional<DataExtractor> expr =
+            GetLocationExpression(load_function_start, pc))
       opcodes = std::move(*expr);
     else
       return false;
   } else
     opcodes = m_data;
 
 
   lldb::offset_t op_offset = 0;

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

if (call_origin) {
                call_origin->GetPubname(), return_pc, call_inst_pc);
       edge = std::make_unique<DirectCallEdge>(
           call_origin->GetMangledName(), caller_address_type, caller_address,
           tail_call, std::move(parameters));
     } else {
       if (log) {
         StreamString call_target_desc;
         call_target->GetDescription(&call_target_desc, eDescriptionLevelBrief,
-                                    LLDB_INVALID_ADDRESS, nullptr);
+                                    nullptr);
         LLDB_LOG(log, "CollectCallEdges: Found indirect call target: {0}",
                  call_target_desc.GetString());
       }
       edge = std::make_unique<IndirectCallEdge>(
           *call_target, caller_address_type, caller_address, tail_call,
           std::move(parameters));
     }
 
     if (log && parameters.size()) {
       for (const CallSiteParameter &param : parameters) {
         StreamString callee_loc_desc, caller_loc_desc;
         param.LocationInCallee.GetDescription(&callee_loc_desc,
-                                              eDescriptionLevelBrief,
-                                              LLDB_INVALID_ADDRESS, nullptr);
+                                              eDescriptionLevelBrief, nullptr);
         param.LocationInCaller.GetDescription(&caller_loc_desc,
-                                              eDescriptionLevelBrief,
-                                              LLDB_INVALID_ADDRESS, nullptr);
+                                              eDescriptionLevelBrief, nullptr);
         LLDB_LOG(log, "CollectCallEdges: \tparam: {0} => {1}",
                  callee_loc_desc.GetString(), caller_loc_desc.GetString());
       }
     }
 
     call_edges.push_back(std::move(edge));
   }
   return call_edges;

lldb/source/Symbol/Variable.cpp

if (show_context && m_owner_scope != nullptr) {
     s->PutCString(" )");
   }
 
   bool show_fullpaths = false;
   m_declaration.Dump(s, show_fullpaths);
 
   if (m_location.IsValid()) {
     s->PutCString(", location = ");
-    lldb::addr_t loclist_base_addr = LLDB_INVALID_ADDRESS;
-    if (m_location.IsLocationList()) {
-      SymbolContext variable_sc;
-      m_owner_scope->CalculateSymbolContext(&variable_sc);
-      if (variable_sc.function)
-        loclist_base_addr = variable_sc.function->GetAddressRange()
-                                .GetBaseAddress()
-                                .GetFileAddress();
-    }
     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,
-                              loclist_base_addr, abi.get());
+    m_location.GetDescription(s, lldb::eDescriptionLevelBrief, abi.get());
   }
 
   if (m_external)
     s->PutCString(", external");
 
   if (m_artificial)
     s->PutCString(", artificial");
 
if (variable_list.GetSize() > 0) {
       return error;
     }
   } break;
   }
   error.SetErrorString("unknown error");
   return error;
 }
 
-bool Variable::DumpLocationForAddress(Stream *s, const Address &address) {
-  // Be sure to resolve the address to section offset prior to calling this
-  // function.
-  if (address.IsSectionOffset()) {
-    SymbolContext sc;
-    CalculateSymbolContext(&sc);
-    if (sc.module_sp == address.GetModule()) {
-      ABISP abi;
-      if (m_owner_scope) {
-        ModuleSP module_sp(m_owner_scope->CalculateSymbolContextModule());
-        if (module_sp)
-          abi = ABI::FindPlugin(ProcessSP(), module_sp->GetArchitecture());
-      }
+bool Variable::DumpLocations(Stream *s, const Address &address) {
 
-      const addr_t file_addr = address.GetFileAddress();
-      if (sc.function) {
-        if (sc.function->GetAddressRange().ContainsFileAddress(address)) {
-          addr_t loclist_base_file_addr =
-              sc.function->GetAddressRange().GetBaseAddress().GetFileAddress();
-          if (loclist_base_file_addr == LLDB_INVALID_ADDRESS)
-            return false;
-          return m_location.DumpLocationForAddress(s, eDescriptionLevelBrief,
-                                                   loclist_base_file_addr,
-                                                   file_addr, abi.get());
-        }
-      }
-      return m_location.DumpLocationForAddress(s, eDescriptionLevelBrief,
-                                               LLDB_INVALID_ADDRESS, file_addr,
-                                               abi.get());
-    }
-  }
+    return m_location.DumpLocations(s, eDescriptionLevelBrief,
+                                    loclist_base_file_addr, file_addr,
   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);

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

 # RUN: llvm-mc -triple=x86_64-pc-linux -filetype=obj %s > %t
 # RUN: %lldb %t -o "image lookup -v -s lookup_loclists" -o exit | FileCheck %s
 
 # CHECK-LABEL: image lookup -v -s lookup_loclists
-# CHECK: Variable: {{.*}}, name = "x0", type = "int", location = DW_OP_reg0 RAX,
+# CHECK: Variable: {{.*}}, name = "x0", type = "int", valid ranges = <block>, location = [0x0000000000000000, 0x0000000000000003) -> DW_OP_reg0 RAX,
 # CHECK-NOT: Variable:
 
 loclists:
         nop
 .Ltmp0:
         nop
 lookup_loclists:
 .Ltmp1:

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

 # Test location list handling, including the cases of invalid input. The exact
 # behavior in the invalid cases is not particularly important, but it should be
 # "reasonable".
 
 # UNSUPPORTED: lldb-repro
 
 # RUN: llvm-mc -triple=x86_64-pc-linux -filetype=obj %s --defsym LOC=0 > %t
 # RUN: %lldb %t -o "image lookup -v -a 0" -o "image lookup -v -a 2" \
 # RUN:   -o "image dump symfile" -o exit | FileCheck %s
 
+# RUN: %lldb %t -o "image lookup -v -a 0 -show-variable-ranges" -o \
+# RUN: "image lookup -v -a 2 -show-variable-ranges" \
+# RUN: -o exit | FileCheck %s --check-prefix=ALL-RANGES
+
 # RUN: llvm-mc -triple=x86_64-pc-linux -filetype=obj %s --defsym LOCLISTS=0 > %t
 # RUN: %lldb %t -o "image lookup -v -a 0" -o "image lookup -v -a 2" \
 # RUN:   -o "image dump symfile" -o exit | FileCheck %s --check-prefix=CHECK --check-prefix=LOCLISTS
 
+# ALL-RANGES-LABEL: image lookup -v -a 0 -show-variable-ranges
+# ALL-RANGES: Variable: id = {{.*}}, name = "x0", type = "int", valid ranges = <block>, location = [0x0000000000000000, 0x0000000000000001) -> DW_OP_reg5 RDI, [0x0000000000000001, 0x0000000000000006) -> DW_OP_reg0 RAX
+# ALL-RANGES: Variable: id = {{.*}}, name = "x1", type = "int", valid ranges = <block>, location = <empty>
+# ALL-RANGES-LABEL: image lookup -v -a 2 -show-variable-ranges
+# ALL-RANGES:  Variable: id = {{.*}}, name = "x0", type = "int", valid ranges = <block>, location = [0x0000000000000000, 0x0000000000000001) -> DW_OP_reg5 RDI, [0x0000000000000001, 0x0000000000000006) -> DW_OP_reg0 RAX
+# ALL-RANGES: Variable: id = {{.*}}, name = "x1", type = "int", valid ranges = <block>, location = <empty>
+# ALL-RANGES: Variable: id = {{.*}}, name = "x3", type = "int", valid ranges = <block>, location = [0x0000000000000002, 0x0000000000000003) -> DW_OP_reg1 RDX
+
 # CHECK-LABEL: image lookup -v -a 0
-# CHECK: Variable: {{.*}}, name = "x0", type = "int", location = DW_OP_reg5 RDI,
-# CHECK: Variable: {{.*}}, name = "x1", type = "int", location = <empty>,
+# CHECK: Variable: {{.*}}, name = "x0", type = "int", valid ranges = <block>, location = [0x0000000000000000, 0x0000000000000001) -> DW_OP_reg5 RDI
+# CHECK: Variable: {{.*}}, name = "x1", type = "int", valid ranges = <block>, location = <empty>,
 
 # CHECK-LABEL: image lookup -v -a 2
-# CHECK: Variable: {{.*}}, name = "x0", type = "int", location = DW_OP_reg0 RAX,
-# CHECK: Variable: {{.*}}, name = "x1", type = "int", location = <empty>,
-# CHECK: Variable: {{.*}}, name = "x3", type = "int", location = DW_OP_reg1 RDX,
+# CHECK: Variable: {{.*}}, name = "x0", type = "int", valid ranges = <block>, location = [0x0000000000000001, 0x0000000000000006) -> DW_OP_reg0 RAX
+# CHECK: Variable: {{.*}}, name = "x1", type = "int", valid ranges = <block>, location = <empty>,
+# CHECK: Variable: {{.*}}, name = "x3", type = "int", valid ranges = <block>, location = [0x0000000000000002, 0x0000000000000003) -> DW_OP_reg1 RDX
 
 # 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 = "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
 
 .ifdef LOC

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

 # Test that we can handle DWARF 4 and 5 location lists in the same object file
 # (but different compile units).
 
 # RUN: llvm-mc -triple=x86_64-pc-linux -filetype=obj %s > %t
 # RUN: %lldb %t -o "image lookup -v -s loc" -o "image lookup -v -s loclists" \
 # RUN:   -o exit | FileCheck %s
 
 
 # CHECK-LABEL: image lookup -v -s loc
-# CHECK: Variable: {{.*}}, name = "x0", type = "int", location = DW_OP_reg5 RDI,
+# CHECK: Variable: {{.*}}, name = "x0", type = "int", valid ranges = <block>, location = [0x0000000000000000, 0x0000000000000001) -> DW_OP_reg5 RDI,
 
 # CHECK-LABEL: image lookup -v -s loclists
-# CHECK: Variable: {{.*}}, name = "x1", type = "int", location = DW_OP_reg0 RAX,
+# CHECK: Variable: {{.*}}, name = "x1", type = "int", valid ranges = <block>, location = [0x0000000000000001, 0x0000000000000002) -> DW_OP_reg0 RAX,
 
 
 loc:
         nop
 .Lloc_end:
 
 loclists:
         nop

lldb/test/Shell/SymbolFile/DWARF/x86/debug_loclists-dwo.s

 # RUN: cd %T
 # RUN: llvm-mc -triple=x86_64-pc-linux -filetype=obj %s >debug_loclists-dwo.o
 # RUN: %lldb debug_loclists-dwo.o -o "image lookup -v -s lookup_loclists" -o exit | FileCheck %s
 
 # CHECK-LABEL: image lookup -v -s lookup_loclists
-# CHECK: Variable: {{.*}}, name = "x0", type = "int", location = DW_OP_reg0 RAX,
-# CHECK: Variable: {{.*}}, name = "x1", type = "int", location = DW_OP_reg1 RDX,
+# CHECK: Variable: {{.*}}, name = "x0", type = "int", valid ranges = <block>, location = [0x0000000000000000, 0x0000000000000003) -> DW_OP_reg0 RAX,
+# CHECK: Variable: {{.*}}, name = "x1", type = "int", valid ranges = <block>, location = [0x0000000000000002, 0x0000000000000004) -> DW_OP_reg1 RDX,
 
 loclists:
         nop
 .Ltmp0:
         nop
 .Ltmp1:
 lookup_loclists:
         nop

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

 ## This tests if .debug_loclists.dwo are correctly read if they are part
 ## of a dwp file.
 
 # RUN: llvm-mc -triple=x86_64-pc-linux -filetype=obj %s --defsym MAIN=0 > %t
 # RUN: llvm-mc -triple=x86_64-pc-linux -filetype=obj %s > %t.dwp
 # RUN: %lldb %t -o "image lookup -v -s lookup_loclists" -o exit | FileCheck %s
 
 # CHECK-LABEL: image lookup -v -s lookup_loclists
-# CHECK: Variable: id = {{.*}}, name = "x0", type = "int", location = DW_OP_reg0 RAX,
-# CHECK: Variable: id = {{.*}}, name = "x1", type = "int", location = DW_OP_reg1 RDX,
+# CHECK: Variable: id = {{.*}}, name = "x0", type = "int", valid ranges = <block>, location = [0x0000000000000000, 0x0000000000000003) -> DW_OP_reg0 RAX,
+# CHECK: Variable: id = {{.*}}, name = "x1", type = "int", valid ranges = <block>, location = [0x0000000000000002, 0x0000000000000004) -> DW_OP_reg1 RDX,
 
 ## This part is kept in both the main and the dwp file to be able to reference the offsets.
 loclists:
         nop
         nop
 .Ltmp1:
 lookup_loclists:
         nop

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

 # RUN: llvm-mc --filetype=obj --triple x86_64-pc-linux %s -o %t --defsym MAIN=0
 # RUN: llvm-mc --filetype=obj --triple x86_64-pc-linux %s -o %t.dwp --defsym DWP=0
 # RUN: %lldb %t -o "target variable A" -o "image lookup -v -n F1" -b | FileCheck %s
 # RUN: lldb-test symbols %t | FileCheck %s --check-prefix=SYMBOLS
 
 # CHECK-LABEL: target variable A
 # CHECK: (INT0) A = 0
 # CHECK: (INT1) A = 1
 # CHECK: (INT2) A = 2
 # CHECK: (INT3) A = 3
 
 # CHECK-LABEL: image lookup -v -n F1
 # CHECK: CompileUnit: id = {0x00000001}, file = "1.c", language = "<not loaded>"
 # CHECK: Function: {{.*}}, name = "F1", range = [0x0000000000000001-0x0000000000000002)
-# CHECK: Variable: {{.*}}, name = "x", type = "int", location = DW_OP_reg1 RDX
+# 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

lldb/test/Shell/SymbolFile/DWARF/x86/unused-inlined-params.test

 # RUN: llvm-mc -filetype=obj %S/Inputs/unused-inlined-params.s \
 # RUN:         -triple x86_64-pc-linux -o %t.o
 # RUN: %lldb %t.o -s %s -o exit | FileCheck %s
 
 
 # In this test we verify that inlined functions still mention
 # all their parameters in `frame variable`, even when those
 # parameters were completely optimized away from the concrete
 # instance of the inlined function in the debug info.
 # The debugger should look up the parameters in the abstract
 # origin of the concrete instance.
 
 # Let us check that unused parameters of an inlined function are listed
 # at the inlined function entry.
 image lookup -v -s break_at_inlined_f_in_main
 # CHECK-LABEL: image lookup -v -s break_at_inlined_f_in_main
-# CHECK: name = "unused1", type = "void *", location = <empty>
-# CHECK: name = "used", type = "int", location = DW_OP_consts +42
-# CHECK: name = "unused2", type = "int", location = <empty>
-# CHECK: name = "partial", type = "int", location = DW_OP_reg4 RSI
-# CHECK: name = "unused3", type = "int", location = <empty>
+# CHECK: name = "unused1", type = "void *", valid ranges = <block>, location = <empty>
+# CHECK: name = "used", type = "int", valid ranges = <block>, location = [0x0000000000000011, 0x0000000000000014) -> DW_OP_consts +42
+# CHECK: name = "unused2", type = "int", valid ranges = <block>, location = <empty>
+# CHECK: name = "partial", type = "int", valid ranges = <block>, location = [0x0000000000000011, 0x0000000000000019) -> DW_OP_reg4 RSI
+# CHECK: name = "unused3", type = "int", valid ranges = <block>, location = <empty>
 
 # Show variables outsid of the live range of the 'partial' parameter
 # and verify that the output is as expected.
 image lookup -v -s break_at_inlined_f_in_main_between_printfs
 # CHECK-LABEL: image lookup -v -s break_at_inlined_f_in_main_between_printfs
-# CHECK: name = "unused1", type = "void *", location = <empty>
-# CHECK: name = "used", type = "int", location = DW_OP_reg3 RBX
-# CHECK: name = "unused2", type = "int", location = <empty>
+# CHECK: name = "unused1", type = "void *", valid ranges = <block>, location = <empty>
+# CHECK: name = "used", type = "int", valid ranges = <block>, location = [0x0000000000000014, 0x000000000000001e) -> DW_OP_reg3 RBX
+# CHECK: name = "unused2", type = "int", valid ranges = <block>, location = <empty>
 # Note: image lookup does not show variables outside of their
 #       location, so |partial| is missing here.
 # CHECK-NOT: partial
-# CHECK: name = "unused3", type = "int", location = <empty>
+# CHECK: name = "unused3", type = "int", valid ranges = <block>, location = <empty>
 
 # Check that we show parameters even if all of them are compiled away.
 image lookup -v -s  break_at_inlined_g_in_main
 # CHECK-LABEL: image lookup -v -s  break_at_inlined_g_in_main
-# CHECK: name = "unused", type = "int", location = <empty>
+# CHECK: name = "unused", type = "int", valid ranges = <block>, location = <empty>
 
 # Check that even the other inlined instance of f displays the correct
 # parameters.
 image lookup -v -s  break_at_inlined_f_in_other
 # CHECK-LABEL: image lookup -v -s  break_at_inlined_f_in_other
-# CHECK: name = "unused1", type = "void *", location = <empty>
-# CHECK: name = "used", type = "int", location = DW_OP_consts +1
-# CHECK: name = "unused2", type = "int", location = <empty>
-# CHECK: name = "partial", type = "int", location =  DW_OP_consts +2
-# CHECK: name = "unused3", type = "int", location = <empty>
+# CHECK: name = "unused1", type = "void *", valid ranges = <block>, location = <empty>
+# CHECK: name = "used", type = "int", valid ranges = <block>, location = [0x0000000000000001, 0x000000000000000b) -> DW_OP_consts +1
+# CHECK: name = "unused2", type = "int", valid ranges = <block>, location = <empty>
+# CHECK: name = "partial", type = "int", valid ranges = <block>, location = [0x0000000000000001, 0x0000000000000006) -> DW_OP_consts +2
+# CHECK: name = "unused3", type = "int", valid ranges = <block>, location = <empty>