[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

40

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.

49

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

40

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.

50–51

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

50–51

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

50–51

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

50–51

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

50–51

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

50–51

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

50–51

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

790–801

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

22

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

50–51

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

50–51

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

2743–2746

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

50–51

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

2684

llvm::ListSeparator separator;

2692–2693

s->AsRawOstream() << separator;

lldb/source/Symbol/Variable.cpp

449 ↗

(On Diff #411203)

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 ↗

(On Diff #411898)

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

240

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

2752–2753

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.
   ///
   /// \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;
+  bool
+  Dump(Stream *s, ExecutionContextScope *exe_scope, DumpStyle style,
+       uint32_t addr_byte_size = UINT32_MAX,
+       ModuleLookupShowRange show_range = ModuleLookupShowRange::None) 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/DWARFAddressRange.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
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,
+      ABI *abi,
+      llvm::function_ref<bool(llvm::DWARFAddressRange, lldb::addr_t, bool &)>
+          filter,
+      llvm::function_ref<void(llvm::DWARFAddressRange, bool)> printer);
+
+  bool GetLocationExpressions(
+      llvm::function_ref<bool(llvm::DWARFLocationExpression)> fn) 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/lldb-private-enumerations.h

 enum StatisticKind {
   ExpressionSuccessful = 0,
   ExpressionFailure = 1,
   FrameVarSuccess = 2,
   FrameVarFailure = 3,
   StatisticMax = 4
 };
 
+enum class ModuleLookupShowRange {
+  None = 0,
+  Single = 1,
+  All = 2,
+};
 
 inline std::string GetStatDescription(lldb_private::StatisticKind K) {
    switch (K) {
    case StatisticKind::ExpressionSuccessful:
      return "Number of expr evaluation successes";
    case StatisticKind::ExpressionFailure:
      return "Number of expr evaluation failures";
    case StatisticKind::FrameVarSuccess:

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,
+                        ModuleLookupShowRange show_range, 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, show_range);
   }
   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,
+                                  ModuleLookupShowRange show_range) {
   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, show_range, 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,
+                                     ModuleLookupShowRange show_range) {
   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, show_range, strm);
       }
     }
     strm.IndentLess();
   }
   return num_matches;
 }
 
 static void DumpSymbolContextList(ExecutionContextScope *exe_scope,
                                   Stream &strm, SymbolContextList &sc_list,
-                                  bool verbose) {
+                                  bool verbose,
+                                  ModuleLookupShowRange show_range) {
   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, show_range, 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,
+                                     ModuleLookupShowRange show_range) {
   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, show_range);
     }
     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,
+                                          ModuleLookupShowRange show_range) {
   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, show_range);
       return num_matches;
     }
   }
   return 0;
 }
 
 static size_t FindModulesByName(Target *target, const char *module_name,
                                 ModuleList &module_list,
for (uint32_t idx = 0; idx < num_matches; idx++) {
       result.GetOutputStream().Printf("\n");
     }
     return result.Succeeded();
   }
 
   CommandOptions m_options;
 };
 
+// Verbose level.
+static constexpr OptionEnumValueElement g_target_modules_lookup_show_range[] = {
+    {
+        (int64_t)ModuleLookupShowRange::Single,
+        "single",
+        "Only print the range that contains file address being looked up",
+    },
+    {
+        (int64_t)ModuleLookupShowRange::All,
+        "all",
+        "Print all ranges",
+    },
+};
+
 // Lookup information in images
 #define LLDB_OPTIONS_target_modules_lookup
 #include "CommandOptions.inc"
 
 class CommandObjectTargetModulesLookup : public CommandObjectParsed {
 public:
   enum {
     eLookupTypeInvalid = -1,
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 'R':
+        m_show_range = (ModuleLookupShowRange)OptionArgParser::ToOptionEnum(
+            option_arg, GetDefinitions()[option_idx].enum_values,
+            (int32_t)ModuleLookupShowRange::None, error);
+        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_show_range = ModuleLookupShowRange::None;
       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.
+    ModuleLookupShowRange m_show_range; // 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_show_range)) {
           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_show_range)) {
           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_show_range)) {
           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_show_range)) {
           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", 
+    "R">, GroupRange<1, 6>, EnumArg<"Value", 
+    "OptionEnumValues(g_target_modules_lookup_show_range)">, 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,
+                   ModuleLookupShowRange show_range) 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);
+              },
+          auto dump_range = [&s, addr_size](Variable::RangeList::Entry range) {
+            s->PutCString(" [");
+            s->AsRawOstream()
+                << llvm::format_hex(range.GetRangeBase(), 2 + 2 * addr_size);
+            s->PutCString(", ");
+            s->AsRawOstream()
+                << llvm::format_hex(range.GetRangeEnd(), 2 + 2 * addr_size);
+            s->PutCString(")");
+          };
+          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>");
+            DWARFExpression &expr = var_sp->LocationExpression();
+            if (show_range == ModuleLookupShowRange::None) {
               s->PutCString(", location = ");
               var_sp->DumpLocationForAddress(s, *this);
               s->PutCString(", decl = ");
               var_sp->GetDeclaration().DumpStopContext(s, false);
-              s->EOL();
+            } else {
+              s->PutCString(", valid ranges =");
+              if (show_range == ModuleLookupShowRange::All) {
+                for (auto range : var_sp->GetScopeRange())
+                  dump_range(range);
+              } else if (auto *range =
+                             var_sp->GetScopeRange().FindEntryThatContains(
+                                 file_addr))
+                dump_range(*range);
+
+              addr_t function_load_addr =
+                  sc.block->CalculateSymbolContextFunction()
+                      ->GetAddressRange()
+                      .GetBaseAddress()
+                      .GetFileAddress();
+              auto filter = [&](llvm::DWARFAddressRange range,
+                                addr_t func_file_addr, bool &should_continue) {
+                if (show_range == ModuleLookupShowRange::All) {
+                  should_continue = true;
+                  return true;
+                }
+                addr_t slide = function_load_addr - func_file_addr;
+                range.LowPC += slide;
+                range.HighPC += slide;
+
+                if (range.LowPC <= file_addr && file_addr < range.HighPC) {
+                  should_continue = false;
+                  return true;
                 }
+                return false;
+              };
+              auto range_printer = [&](llvm::DWARFAddressRange range,
+                                       bool is_first) {
+                if (!is_first)
+                  s->PutCString(", ");
+                s->PutCString("[");
+                s->AsRawOstream()
+                    << llvm::format_hex(range.LowPC, 2 + 2 * addr_size);
+                s->PutCString(", ");
+                s->AsRawOstream()
+                    << llvm::format_hex(range.HighPC, 2 + 2 * addr_size);
+                s->PutCString(") -> ");
+              };
+              s->PutCString(", location = ");
+              expr.DumpLocations(s, lldb::eDescriptionLevelBrief,
+                                 function_load_addr, abi.get(), filter,
+                                 range_printer);
+              s->PutCString(", decl = ");
+              var_sp->GetDeclaration().DumpStopContext(s, false);
+            }
+            s->EOL();
           }
         }
       }
     } else {
       if (fallback_style != DumpStyleInvalid)
         return Dump(s, exe_scope, fallback_style, DumpStyleInvalid, addr_size);
       return false;
     }

lldb/source/Expression/DWARFExpression.cpp

 
 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, lldb::addr_t load_function_start,
+    ABI *abi,
+    llvm::function_ref<bool(llvm::DWARFAddressRange, addr_t, bool &)> filter,
+    llvm::function_ref<void(llvm::DWARFAddressRange, bool)> range_printer) {
+  if (!IsLocationList()) {
+    DumpLocation(s, m_data, level, abi);
+    return true;
+  }
+  bool is_first = true;
+  auto callback = [&](llvm::DWARFLocationExpression loc) -> bool {
+    bool should_continue = true;
+    if (loc.Range && filter(*loc.Range, m_loclist_addresses->func_file_addr,
+                            should_continue)) {
+      DataExtractor data = ToDataExtractor(loc, m_data.GetByteOrder(),
+                                           m_data.GetAddressByteSize());
+      range_printer(*loc.Range, is_first);
+      DumpLocation(s, data, level, abi);
+      is_first = false;
+    }
+    return should_continue;
+  };
+  if (!GetLocationExpressions(callback))
+    return false;
+  return true;
+}
+
+bool DWARFExpression::GetLocationExpressions(
+    llvm::function_ref<bool(llvm::DWARFLocationExpression)> callback) const {
   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) {
+    return callback(*loc);
+  };
+  llvm::Error E = 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 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) {
       // 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;
+      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());
+      if (loc.Range->LowPC <= addr && addr < loc.Range->HighPC)
+        data = ToDataExtractor(loc, m_data.GetByteOrder(),
     }
-    return !result;
+    return !data;
   };
-  llvm::Error E = 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;
+  GetLocationExpressions(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/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 -R s" -o "image lookup -v -a 2 -R s" \
+# RUN: -o exit | FileCheck %s --check-prefix=SINGLE-RANGE
+
+# RUN: %lldb %t -o "image lookup -v -a 0 -R a" -o "image lookup -v -a 2 -R a" \
+# 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
 
+# SINGLE-RANGE-LABEL: image lookup -v -a 0 -R s
+# SINGLE-RANGE: Variable: id = {{.*}}, name = "x0", type = "int", valid ranges =, location = [0x0000000000000000, 0x0000000000000001) -> DW_OP_reg5 RDI, decl =
+# SINGLE-RANGE: Variable: id = {{.*}}, name = "x1", type = "int", valid ranges =, location = <empty>, decl =
+# SINGLE-RANGE-LABEL: image lookup -v -a 2 -R s
+# SINGLE-RANGE: Variable: id = {{.*}}, name = "x0", type = "int", valid ranges =, location = [0x0000000000000001, 0x0000000000000006) -> DW_OP_reg0 RAX, decl =
+# SINGLE-RANGE: Variable: id = {{.*}}, name = "x1", type = "int", valid ranges =, location = <empty>, decl =
+# SINGLE-RANGE: Variable: id = {{.*}}, name = "x3", type = "int", valid ranges =, location = [0x0000000000000002, 0x0000000000000003) -> DW_OP_reg1 RDX, decl =
+
+# ALL-RANGES-LABEL: image lookup -v -a 0 -R a
+# ALL-RANGES: Variable: id = {{.*}}, name = "x0", type = "int", valid ranges =, location = [0x0000000000000000, 0x0000000000000001) -> DW_OP_reg5 RDI, [0x0000000000000001, 0x0000000000000006) -> DW_OP_reg0 RAX, decl =
+# ALL-RANGES: Variable: id = {{.*}}, name = "x1", type = "int", valid ranges =, location = <empty>, decl =
+# ALL-RANGES-LABEL: image lookup -v -a 2 -R a
+# ALL-RANGES:  Variable: id = {{.*}}, name = "x0", type = "int", valid ranges =, location = [0x0000000000000000, 0x0000000000000001) -> DW_OP_reg5 RDI, [0x0000000000000001, 0x0000000000000006) -> DW_OP_reg0 RAX, decl =
+# ALL-RANGES: Variable: id = {{.*}}, name = "x1", type = "int", valid ranges =, location = <empty>, decl =
+# ALL-RANGES: Variable: id = {{.*}}, name = "x3", type = "int", valid ranges =, location = [0x0000000000000002, 0x0000000000000003) -> DW_OP_reg1 RDX, decl =
+
 # 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-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-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