Add the ability to show when variables fails to be available when debug info is valid.

[clayborg]

Summary

Many times when debugging variables might not be available even though a user can successfully set breakpoints and stops somewhere. Letting the user know will help users fix these kinds of issues and have a better debugging experience.

Examples of this include:

• enabling -gline-tables-only and being able to set file and line breakpoints and yet see no variables
• unable to open object file for DWARF in .o file debugging for darwin targets due to modification time mismatch or not being able to locate the N_OSO file.

This patch adds an new API to SBValueList:

lldb::SBError lldb::SBValueList::GetError();

object so that if you request a stack frame's variables using SBValueList SBFrame::GetVariables(...), you can get an error the describes why the variables were not available.

This patch adds the ability to get an error back when requesting variables from a lldb_private::StackFrame when calling GetVariableList.

It also now shows an error in response to "frame variable" if we have debug info and are unable to get varialbes due to an error as mentioned above:

(lldb) frame variable
error: "a.o" object from the "/tmp/libfoo.a" archive: either the .o file doesn't exist in the archive or the modification time (0x63111541) of the .o file doesn't match

[labath]

lldb/include/lldb/Target/StackFrame.h

264

Could this return Expected<VariableList*> ?

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

4161

This isn't a particularly reliable way of detecting whether variable information was emitted. For example a command line clang -gline-tables-only -g2 will in fact produce full debug info and clang -g1 will not. Could we make that determination based on the presence of actual variable DIEs in the debug info? Perhaps query the index whether it knows of any (global) variable or any type defined within the compile unit?

lldb/test/API/commands/frame/var/TestFrameVar.py

174–175

Why not just pass -grecord-command-line in CFLAGS_EXTRAS? I think then you should be able to remove @skipUnlessDarwin from this test...

[clayborg]

lldb/include/lldb/Target/StackFrame.h

264

We don't have the equivalent of Expected in LLDB that uses a Status, so I opted for this as it was already being used. I started with Expected<VariableList*> but the code using it was messy and had conversions to llvm::Error and back to Status again. Also using an Expected with a pointer didn't look good and caused some bad looking code.

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

4161

This function only gets called when there are no variables in a stack frame at all and checks for reasons why. So if "-gline-tables-only -g2" is used, this function won't get called if there were variables.

I planned to make a follow up patch that detected no variables in a compile uint by checking the compile unit's abbreviation set to see if it had any DW_TAG_variable or DW_TAG_formal_parameter definitions, and if there weren't any respond with "-gline-tables-only might be enabled....".

If we see this option for sure and have the side affect of there being no variables, I would like to user the users know what they can do to fix things if at all possible.

4162–4163

I could rephrase this as "-gline-tables-only detected in compiler flags, variable information might be been removed for this compile unit"?

lldb/test/API/commands/frame/var/TestFrameVar.py

174–175

I thought I tried that, but I was able to get this to work as suggested. I will change this.

[clayborg]

Use -grecord-command-line instead of setting RC_DEBUG_OPTIONS.

[clayborg]

lldb/include/lldb/Target/StackFrame.h

264

There are many places that call this function that also don't need to check the error and if we use a Expected<VariableList*>, we need to add a bunch of consumeError(...) code. See all of the call sites where I added a "nullptr" for the "error_ptr" to see why I chose to do it this way to keep the code cleaner. Many places are getting the variable list to look for things or use them for autocomplete.

[labath]

lldb/include/lldb/Target/StackFrame.h

264

Ok, I am convinced by the optionalness of the error in this case.

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

4161

I get that, but this check is not completely correct in either direction. For example, clang -g1 will not produce variable information, but this code will not detect it. Same goes for clang -gmlt. And I probably missed some other ways one can prevent variable info from being generated. Keeping up with all the changes in clang flags will just be a game of whack-a-mole. If we checked the actual debug info, then we would catch all of these cases, including the (default) case when the compiler did not embed command line information into the debug info.

And I don't think we need to know the precise command line to give meaningful advice to the users. In all of these cases, sticking an extra -g at the end of the command line will cause the variables to reappear. If we wanted to, we could also put a link to the lldb web page where we can (at length) describe the various reasons why variables may not be available and how to fix them.

lldb/test/API/commands/frame/var/TestFrameVar.py

101

just change to assertIn(s, command_error), and then you get the error message for free.

174–175

Cool. Can we also remove @skipUnlessDarwin then?

lldb/test/API/functionalities/archives/Makefile

11–12

I don't know how important this is, but I believe the build was deleting the .o files to ensure that we access the copies within the archive. If you think that's fine, then just delete this line.

17–18

And probably this comment as well, because it doesn't make sense if we don't delete the other files.

[clayborg]

• Don't check for compiler arguments directly, look at all DIEs for a compile unit and return an error if there are no variable DIEs in any DIEs in each compile unit.
• Use "assertIn(a, b)" instead of otther asserts

[clayborg]

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

4161

I switched over to just looking for any variable DIEs anywhere in the CU. This should cover all options. Let me know if you think we should add a top level web page and reference it in the error message?

lldb/test/API/functionalities/archives/Makefile

11–12

Yeah, part of my test touches the .o file and only rebuilds the libfoo.a so I have to leave the .o files there.

[labath]

Looks good. Thanks.

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

4161

I think it might be nice to have some kind of a "I can't debug" troubleshooting page, but I don't think we need to tie it to the future of this patch.

lldb/test/API/commands/frame/var/TestFrameVar.py

173

I guess this isn't necessary any more.

[clayborg]

Yikes, looks like you can't set a breakpoint by name 'main' on windows with the debug info stripped... I will add a skipIfWindows to the failing test.

[clayborg]

Reopen for submission with windows fix.

[clayborg]

Added a @skipIfWindows to make on TestFrameVar.test_gline_tables_only as windows doesn't seem to be able to set a breakpoint by function name 'main' when debug info is -gline-tables-only

[clayborg]

lldb/test/API/commands/frame/var/TestFrameVar.py

166

This is the line that will fix the windows buildbots.

[clayborg]

If anyone can accept this diff again it would be most appreciated, the only failing buildbot was windows and I added @skipIfWindows to the failing test.

lldb/bindings/interface/SBValueList.i

public:
     GetValueAtIndex (uint32_t idx) const;
 
     lldb::SBValue
     FindValueObjectByUID (lldb::user_id_t uid);
 
     lldb::SBValue
     GetFirstValueByName (const char* name) const;
 
+    lldb::SBError GetError();
+
     %extend {
        %nothreadallow;
        std::string lldb::SBValueList::__str__ (){
            lldb::SBStream description;
            const size_t n = $self->GetSize();
            if (n)
            {
                for (size_t i=0; i<n; ++i)

lldb/include/lldb/API/SBError.h

 protected:
   friend class SBBreakpoint;
   friend class SBBreakpointLocation;
   friend class SBBreakpointName;
   friend class SBCommandReturnObject;
   friend class SBCommunication;
   friend class SBData;
   friend class SBDebugger;
+  friend class SBFile;
   friend class SBHostOS;
   friend class SBPlatform;
   friend class SBProcess;
   friend class SBReproducer;
   friend class SBStructuredData;
   friend class SBTarget;
   friend class SBThread;
   friend class SBTrace;
   friend class SBValue;
+  friend class SBValueList;
   friend class SBWatchpoint;
-  friend class SBFile;
 
   friend class lldb_private::ScriptInterpreter;
 
   lldb_private::Status *get();
 
   lldb_private::Status *operator->();
 
   const lldb_private::Status &operator*() const;

lldb/include/lldb/API/SBValueList.h

public:
   lldb::SBValue GetValueAtIndex(uint32_t idx) const;
 
   lldb::SBValue GetFirstValueByName(const char *name) const;
 
   lldb::SBValue FindValueObjectByUID(lldb::user_id_t uid);
 
   const lldb::SBValueList &operator=(const lldb::SBValueList &rhs);
 
+  // Get an error for why this list is empty.
+  //
+  // If this list is empty, check for an underlying error in the debug
+  // information that prevented this list from being populated. This is not
+  // meant to return an error if there is no debug information as it is ok for a
+  // value list to be empty and no error should be returned in that case. If the
+  // debug info is for an assembly file or language that doesn't have any
+  // variables, no error should be returned.
+  //
+  // This is designed as a way to let users know when they enable certain
+  // compiler options that enable debug information but provide a degraded
+  // debug information content, like -gline-tables-only, which is a compiler
+  // option that allows users to set file and line breakpoints, but users get
+  // confused when no variables show up during debugging.
+  //
+  // It is also designed to inform a user that debug information might be
+  // available if an external file, like a .dwo file, but that file doesn't
+  // exist or wasn't able to be loaded due to a mismatched ID. When debugging
+  // with fission enabled, the line tables are linked into the main executable,
+  // but if the .dwo or .dwp files are not available or have been modified,
+  // users can get confused if they can stop at a file and line breakpoint but
+  // can't see variables in this case.
+  //
+  // This error can give vital clues to the user about the cause is and allow
+  // the user to fix the issue.
+  lldb::SBError GetError();
+
 protected:
   // only useful for visualizing the pointer or comparing two SBValueLists to
   // see if they are backed by the same underlying Impl.
   void *opaque_ptr();
 
 private:
   friend class SBFrame;
 
private:
 
   const ValueListImpl *operator->() const;
 
   const ValueListImpl &operator*() const;
 
   ValueListImpl &ref();
 
   std::unique_ptr<ValueListImpl> m_opaque_up;
+
+  void SetError(const lldb_private::Status &status);
 };
 
 } // namespace lldb
 
 #endif // LLDB_API_SBVALUELIST_H

lldb/include/lldb/Symbol/SymbolFile.h

virtual CompilerDeclContext GetDeclContextForUID(lldb::user_id_t uid) {
     return CompilerDeclContext();
   }
   virtual CompilerDeclContext GetDeclContextContainingUID(lldb::user_id_t uid) {
     return CompilerDeclContext();
   }
   virtual uint32_t ResolveSymbolContext(const Address &so_addr,
                                         lldb::SymbolContextItem resolve_scope,
                                         SymbolContext &sc) = 0;
+
+  /// Get an error that describes why variables might be missing for a given
+  /// symbol context.
+  ///
+  /// If there is an error in the debug information that prevents variables from
+  /// being fetched, this error will get filled in. If there is no debug
+  /// informaiton, no error should be returned. But if there is debug
+  /// information and something prevents the variables from being available a
+  /// valid error should be returned. Valid cases include:
+  /// - compiler option that removes variables (-gline-tables-only)
+  /// - missing external files
+  ///   - .dwo files in fission are not accessible or missing
+  ///   - .o files on darwin when not using dSYM files that are not accessible
+  ///     or missing
+  /// - mismatched exteral files
+  ///   - .dwo files in fission where the DWO ID doesn't match
+  ///   - .o files on darwin when modification timestamp doesn't match
+  /// - corrupted debug info
+  ///
+  /// \param[in] frame
+  ///   The stack frame to use as a basis for the context to check. The frame
+  ///   address can be used if there is not debug info due to it not being able
+  ///   to be loaded, or if there is a debug info context, like a compile unit,
+  ///   or function, it can be used to track down more information on why
+  ///   variables are missing.
+  ///
+  /// \returns
+  ///   An error specifying why there should have been debug info with variable
+  ///   information but the variables were not able to be resolved.
+  virtual Status GetFrameVariableError(StackFrame &frame) {
+    return Status();
+  }
   virtual uint32_t
   ResolveSymbolContext(const SourceLocationSpec &src_location_spec,
                        lldb::SymbolContextItem resolve_scope,
                        SymbolContextList &sc_list);
 
   virtual void DumpClangAST(Stream &s) {}
   virtual void FindGlobalVariables(ConstString name,
                                    const CompilerDeclContext &parent_decl_ctx,

lldb/include/lldb/Target/StackFrame.h

public:
   /// pc value even though variables would be available at this point if it
   /// were a live stack frame.
   ///
   /// \param[in] get_file_globals
   ///     Whether to also retrieve compilation-unit scoped variables
   ///     that are visible to the entire compilation unit (e.g. file
   ///     static in C, globals that are homed in this CU).
   ///
+  /// \param [out] error_ptr
+  ///   If there is an error in the debug information that prevents variables
+  ///   from being fetched. \see SymbolFile::GetFrameVariableError() for full
+  ///   details.
+  ///
   /// \return
   ///     A pointer to a list of variables.
-  VariableList *GetVariableList(bool get_file_globals);
+  VariableList *GetVariableList(bool get_file_globals, Status *error_ptr);
 
   /// Retrieve the list of variables that are in scope at this StackFrame's
   /// pc.
   ///
   /// A frame that is not live may return an empty VariableListSP for a
   /// given pc value even though variables would be available at this point if
   /// it were a live stack frame.
   ///

lldb/packages/Python/lldbsuite/test/builders/builder.py

def _getDebugInfoArgs(self, debug_info):
             return ["MAKE_DSYM=NO"]
         if debug_info == "dwo":
             return ["MAKE_DSYM=NO", "MAKE_DWO=YES"]
         if debug_info == "gmodules":
             return ["MAKE_DSYM=NO", "MAKE_GMODULES=YES"]
         return None
 
     def getBuildCommand(self, debug_info, architecture=None, compiler=None,
-            dictionary=None, testdir=None, testname=None):
+            dictionary=None, testdir=None, testname=None, make_targets=None):
         debug_info_args = self._getDebugInfoArgs(debug_info)
         if debug_info_args is None:
             return None
-
+        if make_targets is None:
+            make_targets = ["all"]
         command_parts = [
-            self.getMake(testdir, testname), debug_info_args, ["all"],
+            self.getMake(testdir, testname), debug_info_args, make_targets,
             self.getArchCFlags(architecture), self.getArchSpec(architecture),
             self.getCCSpec(compiler), self.getExtraMakeArgs(),
             self.getSDKRootSpec(), self.getModuleCacheSpec(),
             self.getLibCxxArgs(), self.getCmdLine(dictionary)]
         command = list(itertools.chain(*command_parts))
 
         return command
 
     def cleanup(self, dictionary=None):
         """Perform a platform-specific cleanup after the test."""
         return True

lldb/packages/Python/lldbsuite/test/lldbtest.py

def getDebugInfo(self):
         method = getattr(self, self.testMethodName)
         return getattr(method, "debug_info", None)
 
     def build(
             self,
             debug_info=None,
             architecture=None,
             compiler=None,
-            dictionary=None):
+            dictionary=None,
+            make_targets=None):
         """Platform specific way to build binaries."""
         if not architecture and configuration.arch:
             architecture = configuration.arch
 
         if debug_info is None:
             debug_info = self.getDebugInfo()
 
         dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
 
         testdir = self.mydir
         testname = self.getBuildDirBasename()
 
         module = builder_module()
         command = builder_module().getBuildCommand(debug_info, architecture,
-                compiler, dictionary, testdir, testname)
+                compiler, dictionary, testdir, testname, make_targets)
         if command is None:
             raise Exception("Don't know how to build binary")
 
         self.runBuildCommand(command)
 
     def runBuildCommand(self, command):
         self.trace(seven.join_for_shell(command))
         try:

lldb/source/API/SBFrame.cpp

if (stop_locker.TryLock(&process->GetRunLock())) {
           if (sc.block)
             sc.block->AppendVariables(
                 can_create, get_parent_variables,
                 stop_if_block_is_inlined_function,
                 [frame](Variable *v) { return v->IsInScope(frame); },
                 &variable_list);
           if (value_type == eValueTypeVariableGlobal) {
             const bool get_file_globals = true;
-            VariableList *frame_vars = frame->GetVariableList(get_file_globals);
+            VariableList *frame_vars = frame->GetVariableList(get_file_globals,
+                                                              nullptr);
             if (frame_vars)
               frame_vars->AppendVariablesIfUnique(variable_list);
           }
           ConstString const_name(name);
           VariableSP variable_sp(
               variable_list.FindVariable(const_name, value_type));
           if (variable_sp) {
             value_sp = frame->GetValueObjectForFrameVariable(variable_sp,
SBValueList SBFrame::GetVariables(const lldb::SBVariablesOptions &options) {
   std::set<VariableSP> variable_set;
   Process *process = exe_ctx.GetProcessPtr();
   if (target && process) {
     Process::StopLocker stop_locker;
     if (stop_locker.TryLock(&process->GetRunLock())) {
       frame = exe_ctx.GetFramePtr();
       if (frame) {
         VariableList *variable_list = nullptr;
-        variable_list = frame->GetVariableList(true);
+        Status var_error;
+        variable_list = frame->GetVariableList(true, &var_error);
+        if (var_error.Fail())
+          value_list.SetError(var_error);
         if (variable_list) {
           const size_t num_variables = variable_list->GetSize();
           if (num_variables) {
             for (const VariableSP &variable_sp : *variable_list) {
               if (variable_sp) {
                 bool add_variable = false;
                 switch (variable_sp->GetScope()) {
                 case eValueTypeVariableGlobal:

lldb/source/API/SBValueList.cpp

 //===-- SBValueList.cpp ---------------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/API/SBValueList.h"
+#include "lldb/API/SBError.h"
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBValue.h"
 #include "lldb/Core/ValueObjectList.h"
 #include "lldb/Utility/Instrumentation.h"
-
+#include "lldb/Utility/Status.h"
 #include <vector>
 
 using namespace lldb;
 using namespace lldb_private;
 
 class ValueListImpl {
 public:
   ValueListImpl() = default;
 
   ValueListImpl(const ValueListImpl &rhs) = default;
 
   ValueListImpl &operator=(const ValueListImpl &rhs) {
     if (this == &rhs)
       return *this;
     m_values = rhs.m_values;
+    m_error = rhs.m_error;
     return *this;
   }
 
   uint32_t GetSize() { return m_values.size(); }
 
   void Append(const lldb::SBValue &sb_value) { m_values.push_back(sb_value); }
 
   void Append(const ValueListImpl &list) {
if (name) {
       for (auto val : m_values) {
         if (val.IsValid() && val.GetName() && strcmp(name, val.GetName()) == 0)
           return val;
       }
     }
     return lldb::SBValue();
   }
 
+  const Status &GetError() const { return m_error; }
+
+  void SetError(const Status &error) { m_error = error; }
+
 private:
   std::vector<lldb::SBValue> m_values;
+  Status m_error;
 };
 
 SBValueList::SBValueList() { LLDB_INSTRUMENT_VA(this); }
 
 SBValueList::SBValueList(const SBValueList &rhs) {
   LLDB_INSTRUMENT_VA(this, rhs);
 
   if (rhs.IsValid())

 }
 
 void *SBValueList::opaque_ptr() { return m_opaque_up.get(); }
 
 ValueListImpl &SBValueList::ref() {
   CreateIfNeeded();
   return *m_opaque_up;
 }
+
+lldb::SBError SBValueList::GetError() {
+  LLDB_INSTRUMENT_VA(this);
+  SBError sb_error;
+  if (m_opaque_up)
+    sb_error.SetError(m_opaque_up->GetError());
+  return sb_error;
+}
+
+void SBValueList::SetError(const lldb_private::Status &status) {
+  ref().SetError(status);
+}

lldb/source/Commands/CommandObjectFrame.cpp

bool DoExecute(Args &command, CommandReturnObject &result) override {
     StackFrame *frame = m_exe_ctx.GetFramePtr();
 
     Stream &s = result.GetOutputStream();
 
     // Be careful about the stack frame, if any summary formatter runs code, it
     // might clear the StackFrameList for the thread.  So hold onto a shared
     // pointer to the frame so it stays alive.
 
+    Status error;
     VariableList *variable_list =
-        frame->GetVariableList(m_option_variable.show_globals);
+        frame->GetVariableList(m_option_variable.show_globals, &error);
+
+    if (error.Fail() && (!variable_list || variable_list->GetSize() == 0)) {
+      result.AppendError(error.AsCString());
 
+    }
     VariableSP var_sp;
     ValueObjectSP valobj_sp;
 
     TypeSummaryImplSP summary_format_sp;
     if (!m_option_variable.summary.IsCurrentValueEmpty())
       DataVisualization::NamedSummaryFormats::GetSummaryFormat(
           ConstString(m_option_variable.summary.GetCurrentValue()),
           summary_format_sp);

lldb/source/Core/IOHandlerCursesGUI.cpp

bool WindowDelegateDraw(Window &window, bool force) override {
     }
 
     ValueObjectList local_values;
     if (frame_block) {
       // Only update the variables if they have changed
       if (m_frame_block != frame_block) {
         m_frame_block = frame_block;
 
-        VariableList *locals = frame->GetVariableList(true);
+        VariableList *locals = frame->GetVariableList(true, nullptr);
         if (locals) {
           const DynamicValueType use_dynamic = eDynamicDontRunTarget;
           for (const VariableSP &local_sp : *locals) {
             ValueObjectSP value_sp =
                 frame->GetValueObjectForFrameVariable(local_sp, use_dynamic);
             if (value_sp) {
               ValueObjectSP synthetic_value_sp = value_sp->GetSyntheticValue();
               if (synthetic_value_sp)

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

void ClangExpressionDeclMap::LookUpLldbClass(NameSearchContext &context) {
   // a function that claims to have an object pointer (through
   // DW_AT_object_pointer?) but is not formally a method of the class.
   // In that case, just look up the "this" variable in the current scope
   // and use its type.
   // FIXME: This code is formally correct, but clang doesn't currently
   // emit DW_AT_object_pointer
   // for C++ so it hasn't actually been tested.
 
-  VariableList *vars = frame->GetVariableList(false);
+  VariableList *vars = frame->GetVariableList(false, nullptr);
 
   lldb::VariableSP this_var = vars->FindVariable(ConstString("this"));
 
   if (this_var && this_var->IsInScope(frame) &&
       this_var->LocationIsValidForFrame(frame)) {
     Type *this_type = this_var->GetType();
 
     if (!this_type)
if (method_decl) {
     return;
   }
   // This branch will get hit if we are executing code in the context of
   // a function that claims to have an object pointer (through
   // DW_AT_object_pointer?) but is not formally a method of the class.
   // In that case, just look up the "self" variable in the current scope
   // and use its type.
 
-  VariableList *vars = frame->GetVariableList(false);
+  VariableList *vars = frame->GetVariableList(false, nullptr);
 
   lldb::VariableSP self_var = vars->FindVariable(ConstString("self"));
 
   if (!self_var)
     return;
   if (!self_var->IsInScope(frame))
     return;
   if (!self_var->LocationIsValidForFrame(frame))

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

public:
 
   /// Return the location table for parsing the given location list data. The
   /// format is chosen according to the unit type. Never returns null.
   std::unique_ptr<llvm::DWARFLocationTable>
   GetLocationTable(const lldb_private::DataExtractor &data) const;
 
   lldb_private::DWARFDataExtractor GetLocationData() const;
 
+  /// Returns true if any DIEs in the unit match any DW_TAG values in \a tags.
+  ///
+  /// \param[in] tags
+  ///   An array of dw_tag_t values to check all abbrevitions for.
+  ///
+  /// \returns
+  ///   True if any DIEs match any tag in \a tags, false otherwise.
+  bool HasAny(llvm::ArrayRef<dw_tag_t> tags);
+
 protected:
   DWARFUnit(SymbolFileDWARF &dwarf, lldb::user_id_t uid,
             const DWARFUnitHeader &header,
             const DWARFAbbreviationDeclarationSet &abbrevs,
             DIERef::Section section, bool is_dwo);
 
   llvm::Error ExtractHeader(SymbolFileDWARF &dwarf,
                             const lldb_private::DWARFDataExtractor &data,

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

 
 llvm::Expected<DWARFRangeList>
 DWARFUnit::FindRnglistFromIndex(uint32_t index) {
   llvm::Expected<uint64_t> maybe_offset = GetRnglistOffset(index);
   if (!maybe_offset)
     return maybe_offset.takeError();
   return FindRnglistFromOffset(*maybe_offset);
 }
+
+
+bool DWARFUnit::HasAny(llvm::ArrayRef<dw_tag_t> tags) {
+  ExtractUnitDIEIfNeeded();
+  if (m_dwo)
+    return m_dwo->HasAny(tags);
+
+  for (const auto &die: m_die_array) {
+    for (const auto tag: tags) {
+      if (tag == die.Tag())
+        return true;
+    }
+  }
+  return false;
+}

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

public:
 
   void
   ParseDeclsForContext(lldb_private::CompilerDeclContext decl_ctx) override;
 
   uint32_t ResolveSymbolContext(const lldb_private::Address &so_addr,
                                 lldb::SymbolContextItem resolve_scope,
                                 lldb_private::SymbolContext &sc) override;
 
+  lldb_private::Status
+  GetFrameVariableError(lldb_private::StackFrame &frame) override;
+
   uint32_t ResolveSymbolContext(
       const lldb_private::SourceLocationSpec &src_location_spec,
       lldb::SymbolContextItem resolve_scope,
       lldb_private::SymbolContextList &sc_list) override;
 
   void
   FindGlobalVariables(lldb_private::ConstString name,
                       const lldb_private::CompilerDeclContext &parent_decl_ctx,

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

LanguageType SymbolFileDWARF::GetLanguageFamily(DWARFUnit &unit) {
   return LanguageTypeFromDWARF(lang);
 }
 
 StatsDuration::Duration SymbolFileDWARF::GetDebugInfoIndexTime() {
   if (m_index)
     return m_index->GetIndexTime();
   return {};
 }
+
+Status SymbolFileDWARF::GetFrameVariableError(StackFrame &frame) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
+  CompileUnit *cu = frame.GetSymbolContext(eSymbolContextCompUnit).comp_unit;
+  if (!cu)
+    return Status();
+
+  DWARFCompileUnit *dwarf_cu = GetDWARFCompileUnit(cu);
+  if (!dwarf_cu)
+    return Status();
+
+  // Don't return an error for assembly files as they typically don't have
+  // varaible information.
+  if (dwarf_cu->GetDWARFLanguageType() == DW_LANG_Mips_Assembler)
+    return Status();
+
+  // Check if this compile unit has any variable DIEs. If it doesn't then there
+  // is not variable information for the entire compile unit.
+  if (dwarf_cu->HasAny({DW_TAG_variable, DW_TAG_formal_parameter}))
+    return Status();
+
+  return Status("no variable information is available in debug info for this "
+                "compile unit");
+}

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

public:
   bool CompleteType(lldb_private::CompilerType &compiler_type) override;
   uint32_t ResolveSymbolContext(const lldb_private::Address &so_addr,
                                 lldb::SymbolContextItem resolve_scope,
                                 lldb_private::SymbolContext &sc) override;
   uint32_t ResolveSymbolContext(
       const lldb_private::SourceLocationSpec &src_location_spec,
       lldb::SymbolContextItem resolve_scope,
       lldb_private::SymbolContextList &sc_list) override;
+
+  lldb_private::Status
+  GetFrameVariableError(lldb_private::StackFrame &frame) override;
+
   void
   FindGlobalVariables(lldb_private::ConstString name,
                       const lldb_private::CompilerDeclContext &parent_decl_ctx,
                       uint32_t max_matches,
                       lldb_private::VariableList &variables) override;
   void FindGlobalVariables(const lldb_private::RegularExpression &regex,
                            uint32_t max_matches,
                            lldb_private::VariableList &variables) override;
typedef lldb_private::RangeDataVector<lldb::addr_t, lldb::addr_t,
                                         lldb::addr_t>
       FileRangeMap;
 
   // Class specific types
   struct CompileUnitInfo {
     lldb_private::FileSpec so_file;
     lldb_private::ConstString oso_path;
     llvm::sys::TimePoint<> oso_mod_time;
+    lldb_private::Status oso_load_error;
     OSOInfoSP oso_sp;
     lldb::CompUnitSP compile_unit_sp;
     uint32_t first_symbol_index = UINT32_MAX;
     uint32_t last_symbol_index = UINT32_MAX;
     uint32_t first_symbol_id = UINT32_MAX;
     uint32_t last_symbol_id = UINT32_MAX;
     FileRangeMap file_range_map;
     bool file_range_map_valid = false;

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

 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/TypeMap.h"
 #include "lldb/Symbol/VariableList.h"
 #include "llvm/Support/ScopedPrinter.h"
 
+#include "lldb/Target/StackFrame.h"
+
 #include "LogChannelDWARF.h"
 #include "SymbolFileDWARF.h"
 
 #include <memory>
 
 using namespace lldb;
 using namespace lldb_private;
 
if (pos != m_oso_map.end()) {
         // than the one from the CU.
         auto oso_mod_time = std::chrono::time_point_cast<std::chrono::seconds>(
             FileSystem::Instance().GetModificationTime(oso_file));
         // A timestamp of 0 means that the linker was in deterministic mode. In
         // that case, we should skip the check against the filesystem last
         // modification timestamp, since it will never match.
         if (comp_unit_info->oso_mod_time != llvm::sys::TimePoint<>() &&
             oso_mod_time != comp_unit_info->oso_mod_time) {
-          obj_file->GetModule()->ReportError(
-              "debug map object file '%s' has changed (actual time is "
-              "%s, debug map time is %s"
-              ") since this executable was linked, file will be ignored",
-              oso_file.GetPath().c_str(), llvm::to_string(oso_mod_time).c_str(),
-              llvm::to_string(comp_unit_info->oso_mod_time).c_str());
+          comp_unit_info->oso_load_error.SetErrorStringWithFormat(
+              "debug map object file \"%s\" changed (actual: 0x%8.8x, debug "
+              "map: 0x%8.8x) since this executable was linked, debug info "
+              "will not be loaded", oso_file.GetPath().c_str(),
+              (uint32_t)llvm::sys::toTimeT(oso_mod_time),
+              (uint32_t)llvm::sys::toTimeT(comp_unit_info->oso_mod_time));
+          obj_file->GetModule()->ReportError("%s",
+              comp_unit_info->oso_load_error.AsCString());
           return nullptr;
         }
 
       } else {
         const bool must_exist = true;
 
         if (!ObjectFile::SplitArchivePathWithObject(oso_path, oso_file,
                                                     oso_object, must_exist)) {
+          comp_unit_info->oso_load_error.SetErrorStringWithFormat(
+              "debug map object file \"%s\" containing debug info does not "
+              "exist, debug info will not be loaded",
+              comp_unit_info->oso_path.GetCString());
           return nullptr;
         }
       }
       // Always create a new module for .o files. Why? Because we use the debug
       // map, to add new sections to each .o file and even though a .o file
       // might not have changed, the sections that get added to the .o file can
       // change.
       ArchSpec oso_arch;
       // Only adopt the architecture from the module (not the vendor or OS)
       // since .o files for "i386-apple-ios" will historically show up as "i386
       // -apple-macosx" due to the lack of a LC_VERSION_MIN_MACOSX or
       // LC_VERSION_MIN_IPHONEOS load command...
       oso_arch.SetTriple(m_objfile_sp->GetModule()
                              ->GetArchitecture()
                              .GetTriple()
                              .getArchName()
                              .str()
                              .c_str());
       comp_unit_info->oso_sp->module_sp = std::make_shared<DebugMapModule>(
           obj_file->GetModule(), GetCompUnitInfoIndex(comp_unit_info), oso_file,
           oso_arch, oso_object ? &oso_object : nullptr, 0,
           oso_object ? comp_unit_info->oso_mod_time : llvm::sys::TimePoint<>());
+
+      if (!comp_unit_info->oso_sp->module_sp || !comp_unit_info->oso_sp->module_sp->GetObjectFile()) {
+        if (oso_object && FileSystem::Instance().Exists(oso_file)) {
+          // If we are loading a .o file from a .a file the "oso_object" will
+          // have a valid value name and if the .a file exists, either the .o
+          // file didn't exist in the .a file or the mod time didn't match.
+          comp_unit_info->oso_load_error.SetErrorStringWithFormat(
+              "\"%s\" object from the \"%s\" archive: "
+              "either the .o file doesn't exist in the archive or the "
+              "modification time (0x%8.8x) of the .o file doesn't match",
+              oso_object.AsCString(), oso_file.GetPath().c_str(),
+              (uint32_t)llvm::sys::toTimeT(comp_unit_info->oso_mod_time));
+        }
+      }
     }
   }
   if (comp_unit_info->oso_sp)
     return comp_unit_info->oso_sp->module_sp.get();
   return nullptr;
 }
 
 bool SymbolFileDWARFDebugMap::GetFileSpecForSO(uint32_t oso_idx,
if (oso_objfile) {
       ModuleSP module_sp = oso_objfile->GetModule();
       if (module_sp)
         oso_modules.Append(module_sp);
     }
     return false; // Keep iterating
   });
   return oso_modules;
 }
+
+Status SymbolFileDWARFDebugMap::GetFrameVariableError(StackFrame &frame) {
+  std::lock_guard<std::recursive_mutex> guard(GetModuleMutex());
+
+  // We need to make sure that our PC value from the frame matches the module
+  // for this object file since we will lookup the PC file address in the debug
+  // map below.
+  Address pc_addr = frame.GetFrameCodeAddress();
+  if (pc_addr.GetModule() == m_objfile_sp->GetModule()) {
+    Symtab *symtab = m_objfile_sp->GetSymtab();
+    if (symtab) {
+      const DebugMap::Entry *debug_map_entry =
+          m_debug_map.FindEntryThatContains(pc_addr.GetFileAddress());
+      if (debug_map_entry) {
+        Symbol *symbol =
+            symtab->SymbolAtIndex(debug_map_entry->data.GetExeSymbolIndex());
+        if (symbol) {
+          uint32_t oso_idx = 0;
+          CompileUnitInfo *comp_unit_info =
+              GetCompileUnitInfoForSymbolWithID(symbol->GetID(), &oso_idx);
+          if (comp_unit_info) {
+            Module *oso_module = GetModuleByCompUnitInfo(comp_unit_info);
+            if (oso_module) {
+              // Check the .o file's DWARF in case it has an error to display.
+              SymbolFile *oso_sym_file = oso_module->GetSymbolFile();
+              if (oso_sym_file)
+                return oso_sym_file->GetFrameVariableError(frame);
+            }
+            // If we don't have a valid OSO module here, then something went
+            // wrong as we have a symbol for the address in the debug map, but
+            // we weren't able to open the .o file. Display an appropriate
+            // error
+            if (comp_unit_info->oso_load_error.Fail())
+              return comp_unit_info->oso_load_error;
+            else
+              return Status("unable to load debug map object file \"%s\" "
+                            "exist, debug info will not be loaded",
+                            comp_unit_info->oso_path.GetCString());
+          }
+        }
+      }
+    }
+  }
+  return Status();
+}

lldb/source/Symbol/Variable.cpp

if (compiler_type.IsValid()) {
           request.AddCompletion(prefix_path.str());
         }
       } break;
       }
     } else {
       if (frame) {
         const bool get_file_globals = true;
 
-        VariableList *variable_list = frame->GetVariableList(get_file_globals);
+        VariableList *variable_list = frame->GetVariableList(get_file_globals,
+                                                             nullptr);
 
         if (variable_list) {
           for (const VariableSP &var_sp : *variable_list)
             request.AddCompletion(var_sp->GetName().AsCString());
         }
       }
     }
   } else {
default:
         if (compiler_type.IsValid()) {
           PrivateAutoCompleteMembers(frame, token, remaining_partial_path,
                                      prefix_path, compiler_type, request);
         } else if (frame) {
           // We haven't found our variable yet
           const bool get_file_globals = true;
 
           VariableList *variable_list =
-              frame->GetVariableList(get_file_globals);
+              frame->GetVariableList(get_file_globals, nullptr);
 
           if (!variable_list)
             break;
 
           for (VariableSP var_sp : *variable_list) {
 
             if (!var_sp)
               continue;

lldb/source/Target/StackFrame.cpp

 #include "lldb/Core/Value.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/Core/ValueObjectMemory.h"
 #include "lldb/Core/ValueObjectVariable.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Symbol/SymbolContextScope.h"
+#include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrameRecognizer.h"
 #include "lldb/Target/Target.h"
if ((m_flags.Get() & resolve_scope) != resolve_scope) {
     m_flags.Set(resolve_scope | resolved);
   }
 
   // Return the symbol context with everything that was possible to resolve
   // resolved.
   return m_sc;
 }
 
-VariableList *StackFrame::GetVariableList(bool get_file_globals) {
+VariableList *StackFrame::GetVariableList(bool get_file_globals,
+                                          Status *error_ptr) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   if (m_flags.IsClear(RESOLVED_VARIABLES)) {
     m_flags.Set(RESOLVED_VARIABLES);
+    m_variable_list_sp = std::make_shared<VariableList>();
 
     Block *frame_block = GetFrameBlock();
 
     if (frame_block) {
       const bool get_child_variables = true;
       const bool can_create = true;
       const bool stop_if_child_block_is_inlined_function = true;
-      m_variable_list_sp = std::make_shared<VariableList>();
       frame_block->AppendBlockVariables(can_create, get_child_variables,
                                         stop_if_child_block_is_inlined_function,
                                         [](Variable *v) { return true; },
                                         m_variable_list_sp.get());
     }
   }
 
   if (m_flags.IsClear(RESOLVED_GLOBAL_VARIABLES) && get_file_globals) {
     m_flags.Set(RESOLVED_GLOBAL_VARIABLES);
 
     if (m_flags.IsClear(eSymbolContextCompUnit))
       GetSymbolContext(eSymbolContextCompUnit);
 
     if (m_sc.comp_unit) {
       VariableListSP global_variable_list_sp(
           m_sc.comp_unit->GetVariableList(true));
       if (m_variable_list_sp)
         m_variable_list_sp->AddVariables(global_variable_list_sp.get());
       else
         m_variable_list_sp = global_variable_list_sp;
     }
   }
 
+  if (error_ptr && m_variable_list_sp->GetSize() == 0) {
+    // Check with the symbol file to check if there is an error for why we
+    // don't have variables that the user might need to know about.
+    GetSymbolContext(eSymbolContextEverything);
+    if (m_sc.module_sp) {
+      SymbolFile *sym_file = m_sc.module_sp->GetSymbolFile();
+      if (sym_file)
+        *error_ptr = sym_file->GetFrameVariableError(*this);
+    }
+  }
+
   return m_variable_list_sp.get();
 }
 
 VariableListSP
 StackFrame::GetInScopeVariableList(bool get_file_globals,
                                    bool must_have_valid_location) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   // We can't fetch variable information for a history stack frame.
bool StackFrame::HasDebugInformation() {
   return m_sc.line_entry.IsValid();
 }
 
 ValueObjectSP
 StackFrame::GetValueObjectForFrameVariable(const VariableSP &variable_sp,
                                            DynamicValueType use_dynamic) {
   ValueObjectSP valobj_sp;
   { // Scope for stack frame mutex.  We need to drop this mutex before we figure
-    // out the dynamic value.  That will require converting the StackID in the 
-    // VO back to a StackFrame, which will in turn require locking the 
-    // StackFrameList.  If we still hold the StackFrame mutex, we could suffer 
-    // lock inversion against the pattern of getting the StackFrameList and 
+    // out the dynamic value.  That will require converting the StackID in the
+    // VO back to a StackFrame, which will in turn require locking the
+    // StackFrameList.  If we still hold the StackFrame mutex, we could suffer
+    // lock inversion against the pattern of getting the StackFrameList and
     // then the stack frame, which is fairly common.
     std::lock_guard<std::recursive_mutex> guard(m_mutex);
     if (IsHistorical()) {
       return valobj_sp;
     }
-    VariableList *var_list = GetVariableList(true);
+    VariableList *var_list = GetVariableList(true, nullptr);
     if (var_list) {
       // Make sure the variable is a frame variable
       const uint32_t var_idx = var_list->FindIndexForVariable(variable_sp.get());
       const uint32_t num_variables = var_list->GetSize();
       if (var_idx < num_variables) {
         valobj_sp = m_variable_list_value_objects.GetValueObjectAtIndex(var_idx);
         if (!valobj_sp) {
           if (m_variable_list_value_objects.GetSize() < num_variables)
DisassemblerSP disassembler_sp =
       Disassembler::DisassembleRange(target_arch, plugin_name, flavor,
                                      *target_sp, pc_range, force_live_memory);
 
   if (!disassembler_sp || !disassembler_sp->GetInstructionList().GetSize()) {
     return ValueObjectSP();
   }
 
   const bool get_file_globals = false;
-  VariableList *variables = GetVariableList(get_file_globals);
+  VariableList *variables = GetVariableList(get_file_globals, nullptr);
 
   if (!variables) {
     return ValueObjectSP();
   }
 
   return DoGuessValueAt(*this, reg, offset, *disassembler_sp, *variables,
                         GetFrameCodeAddress());
 }

lldb/test/API/commands/frame/var/TestFrameVar.py

 """
 Make sure the frame variable -g, -a, and -l flags work.
 """
 
 
 
 import lldb
 import lldbsuite.test.lldbutil as lldbutil
+from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
-
+import os
+import time
 
 class TestFrameVar(TestBase):
 
     # If your test case doesn't stress debug info, then
     # set this to true.  That way it won't be run once for
     # each debug info format.
     NO_DEBUG_INFO_TESTCASE = True
 
def do_test(self):
         self.assertEqual(result, lldb.eReturnStatusSuccessFinishResult, "frame var -a didn't succeed")
         output = command_result.GetOutput()
         self.assertNotIn("argc", output, "Globals found argc")
         self.assertNotIn("argv", output, "Globals found argv")
         self.assertNotIn("test_var", output, "Globals found test_var")
         self.assertIn("g_var", output, "Globals didn't find g_var")
 
 
-
+    def check_frame_variable_errors(self, thread, error_strings):
+        command_result = lldb.SBCommandReturnObject()
+        interp = self.dbg.GetCommandInterpreter()
+        result = interp.HandleCommand("frame variable", command_result)
+        self.assertEqual(result, lldb.eReturnStatusFailed,
+                         "frame var succeeded unexpectedly")
+        command_error = command_result.GetError()
+
+        frame = thread.GetFrameAtIndex(0)
+        var_list = frame.GetVariables(True, True, False, True)
+        self.assertEqual(var_list.GetSize(), 0)
+        api_error = var_list.GetError().GetCString()
+
+        for s in error_strings:
+            self.assertIn(s, command_error)
+        for s in error_strings:
+            self.assertIn(s, api_error)
+
+
+    @skipIfRemote
+    @skipUnlessDarwin
+    def test_darwin_dwarf_missing_obj(self):
+        '''
+            Test that if we build a binary with DWARF in .o files and we remove
+            the .o file for main.cpp, that we get an appropriate error when we
+            do 'frame variable' that explains why we aren't seeing variables.
+        '''
+        self.build(debug_info="dwarf")
+        exe = self.getBuildArtifact("a.out")
+        main_obj = self.getBuildArtifact("main.o")
+        # Delete the main.o file that contains the debug info so we force an
+        # error when we run to main and try to get variables
+        os.unlink(main_obj)
+
+        # We have to set a named breakpoint because we don't have any debug info
+        # because we deleted the main.o file.
+        (target, process, thread, bkpt) = lldbutil.run_to_name_breakpoint(self, 'main')
+        error_strings = [
+            'debug map object file "',
+            'main.o" containing debug info does not exist, debug info will not be loaded'
+        ]
+        self.check_frame_variable_errors(thread, error_strings)
+
+
+    @skipIfRemote
+    @skipUnlessDarwin
+    def test_darwin_dwarf_obj_mod_time_mismatch(self):
+        '''
+            Test that if we build a binary with DWARF in .o files and we update
+            the mod time of the .o file for main.cpp, that we get an appropriate
+            error when we do 'frame variable' that explains why we aren't seeing
+            variables.
+        '''
+        self.build(debug_info="dwarf")
+        exe = self.getBuildArtifact("a.out")
+        main_obj = self.getBuildArtifact("main.o")
+
+        # Set the modification time for main.o file to the current time after
+        # sleeping for 2 seconds. This ensures the modification time will have
+        # changed and will not match the modification time in the debug map and
+        # force an error when we run to main and try to get variables
+        time.sleep(2)
+        os.utime(main_obj, None)
+
+        # We have to set a named breakpoint because we don't have any debug info
+        # because we deleted the main.o file since the mod times don't match
+        # and debug info won't be loaded
+        (target, process, thread, bkpt) = lldbutil.run_to_name_breakpoint(self, 'main')
+
+        error_strings = [
+            'debug map object file "',
+            'main.o" changed (actual: 0x',
+            ', debug map: 0x',
+            ') since this executable was linked, debug info will not be loaded'
+        ]
+        self.check_frame_variable_errors(thread, error_strings)
+
+
+    @skipIfRemote
+    def test_gline_tables_only(self):
+        '''
+            Test that if we build a binary with "-gline-tables-only" that we can
+            set a file and line breakpoint successfully, and get an error
+            letting us know that this build option was enabled when trying to
+            read variables.
+        '''
+        self.build(dictionary={'CFLAGS_EXTRAS': '-gline-tables-only -grecord-command-line'})
+        exe = self.getBuildArtifact("a.out")
+
+        # We have to set a named breakpoint because we don't have any debug info
+        # because we deleted the main.o file since the mod times don't match
+        # and debug info won't be loaded
+        (target, process, thread, bkpt) = lldbutil.run_to_name_breakpoint(self, 'main')
+        error_strings = [
+            'no variable information is available in debug info for this compile unit'
+        ]
+        self.check_frame_variable_errors(thread, error_strings)

lldb/test/API/functionalities/archives/Makefile

 C_SOURCES := main.c a.c b.c c.c
 EXE :=  # Define a.out explicitly
 MAKE_DSYM := NO
 
 all: a.out libbar.a
 
 a.out: main.o libfoo.a
   $(LD) $(LDFLAGS) $^ -o $@
 
 libfoo.a: a.o b.o
   $(AR) $(ARFLAGS) $@ $^
-  $(RM) $^
 
 # This tests whether lldb can load a thin archive
 libbar.a: c.o
   $(eval LLVM_AR := $(LLVM_TOOLS_DIR)/llvm-ar)
   $(eval LLVM_ARFLAGS := -rcsDT)
   $(LLVM_AR) $(LLVM_ARFLAGS) $@ $^
-  # Note for thin archive case, we cannot remove c.o
 
 include Makefile.rules

lldb/test/API/functionalities/archives/TestBSDArchives.py

 """Test breaking inside functions defined within a BSD archive file libfoo.a."""
 
 
 
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
-
+import os
+import time
 
 class BSDArchivesTestCase(TestBase):
 
+    # If your test case doesn't stress debug info, then
+    # set this to true.  That way it won't be run once for
+    # each debug info format.
+    NO_DEBUG_INFO_TESTCASE = True
+
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number in a(int) to break at.
         self.line = line_number(
             'a.c', '// Set file and line breakpoint inside a().')
 
-    # Doesn't depend on any specific debug information.
-    @no_debug_info_test
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr24527.  Makefile.rules doesn't know how to build static libs on Windows")
     @expectedFailureAll(remote=True)
     def test(self):
         """Break inside a() and b() defined within libfoo.a."""
         self.build()
 
def test(self):
         self.expect_var_path("__b_global", type="int", value="2")
 
         # Test loading thin archives
         archive_path = self.getBuildArtifact("libbar.a")
         module_specs = lldb.SBModuleSpecList.GetModuleSpecifications(archive_path)
         num_specs = module_specs.GetSize()
         self.assertEqual(num_specs, 1)
         self.assertEqual(module_specs.GetSpecAtIndex(0).GetObjectName(), "c.o")
+
+
+    def check_frame_variable_errors(self, thread, error_strings):
+        command_result = lldb.SBCommandReturnObject()
+        interp = self.dbg.GetCommandInterpreter()
+        result = interp.HandleCommand("frame variable", command_result)
+        self.assertEqual(result, lldb.eReturnStatusFailed,
+                         "frame var succeeded unexpectedly")
+        command_error = command_result.GetError()
+
+        frame = thread.GetFrameAtIndex(0)
+        var_list = frame.GetVariables(True, True, False, True)
+        self.assertEqual(var_list.GetSize(), 0)
+        api_error = var_list.GetError().GetCString()
+
+        for s in error_strings:
+            self.assertTrue(s in command_error, 'Make sure "%s" exists in the command error "%s"' % (s, command_error))
+        for s in error_strings:
+            self.assertTrue(s in api_error, 'Make sure "%s" exists in the API error "%s"' % (s, api_error))
+
+    @skipIfRemote
+    @skipUnlessDarwin
+    def test_frame_var_errors_when_archive_missing(self):
+        """
+            Break inside a() and remove libfoo.a to make sure we can't load
+            the debug information and report an appropriate error when doing
+            'frame variable'.
+        """
+        self.build()
+        exe = self.getBuildArtifact("a.out")
+        libfoo_path = self.getBuildArtifact("libfoo.a")
+        # Delete the main.o file that contains the debug info so we force an
+        # error when we run to main and try to get variables for the a()
+        # function. Since the libfoo.a is missing, the debug info won't be
+        # loaded and we should see an error when trying to read varibles.
+        os.unlink(libfoo_path)
+
+        (target, process, thread, bkpt) = lldbutil.run_to_name_breakpoint(
+                self, 'a', bkpt_module=exe)
+
+        error_strings = [
+            'debug map object file "',
+            'libfoo.a(a.o)" containing debug info does not exist, debug info will not be loaded'
+        ]
+        self.check_frame_variable_errors(thread, error_strings)
+
+    @skipIfRemote
+    @skipUnlessDarwin
+    def test_frame_var_errors_when_mtime_mistmatch_for_object_in_archive(self):
+        """
+            Break inside a() and modify the modification time for "a.o" within
+            libfoo.a to make sure we can't load the debug information and
+            report an appropriate error when doing 'frame variable'.
+        """
+        self.build()
+        exe = self.getBuildArtifact("a.out")
+        a_path = self.getBuildArtifact("a.o")
+
+        # Change the modification time of the a.o object file after sleeping for
+        # 2 seconds to ensure the modification time is different. The rebuild
+        # only the "libfoo.a" target. This means the modification time of the
+        # a.o within libfoo.a will not match the debug map's modification time
+        # in a.out and will cause the debug information to not be loaded and we
+        # should get an appropriate error when reading variables.
+        time.sleep(2)
+        os.utime(a_path, None)
+        self.build(make_targets=["libfoo.a"])
+
+        (target, process, thread, bkpt) = lldbutil.run_to_name_breakpoint(
+                self, 'a', bkpt_module=exe)
+
+        error_strings = [
+            '"a.o" object from the "',
+            'libfoo.a" archive: either the .o file doesn\'t exist in the archive or the modification time (0x',
+            ') of the .o file doesn\'t match'
+        ]
+        self.check_frame_variable_errors(thread, error_strings)