Print a warning when stopped in a frame LLDB has no plugin for.

[aprantl]

Summary

This patchs adds an optional warning that is printed when stopped at a
frame that was compiled in a source language that LLDB has no plugin
for.

The motivational use-case is debugging Swift code on Linux. When the
user accidentally invokes the system LLDB that was built without the
Swift plugin, it is very much non-obvious why debugging doesnt
work. This warning makes it easy to figure out what went wrong.

rdar://problem/56986569

[JDevlieghere]

lldb/source/Target/Process.cpp

5808

For eWarningsOptimization this check happens in PrintWarning. I think your approach is better, but it'd be nice for the two to be consistent.

[aprantl]

Address review feedback and add a similar test for the previously untested optimization warning.

[JDevlieghere]

LGTM!

[aprantl]

220c17ffd4e1b127bcc02b25980b7934184ee1da

lldb/include/lldb/Target/Process.h

public:
   void SetIgnoreBreakpointsInExpressions(bool ignore);
   bool GetUnwindOnErrorInExpressions() const;
   void SetUnwindOnErrorInExpressions(bool ignore);
   bool GetStopOnSharedLibraryEvents() const;
   void SetStopOnSharedLibraryEvents(bool stop);
   bool GetDetachKeepsStopped() const;
   void SetDetachKeepsStopped(bool keep_stopped);
   bool GetWarningsOptimization() const;
+  bool GetWarningsUnsupportedLanguage() const;
   bool GetStopOnExec() const;
   std::chrono::seconds GetUtilityExpressionTimeout() const;
   bool GetOSPluginReportsAllThreads() const;
   void SetOSPluginReportsAllThreads(bool does_report);
 
 protected:
   Process *m_process; // Can be nullptr for global ProcessProperties
   std::unique_ptr<ProcessExperimentalProperties> m_experimental_properties_up;
public:
 
   enum {
     eBroadcastInternalStateControlStop = (1 << 0),
     eBroadcastInternalStateControlPause = (1 << 1),
     eBroadcastInternalStateControlResume = (1 << 2)
   };
 
   /// Process warning types.
-  enum Warnings { eWarningsOptimization = 1 };
+  enum Warnings { eWarningsOptimization = 1, eWarningsUnsupportedLanguage = 2 };
 
   typedef Range<lldb::addr_t, lldb::addr_t> LoadRange;
   // We use a read/write lock to allow on or more clients to access the process
   // state while the process is stopped (reader). We lock the write lock to
   // control access to the process while it is running (readers, or clients
   // that want the process stopped can block waiting for the process to stop,
   // or just try to lock it to see if they can immediately access the stopped
   // process. If the try read lock fails, then the process is running.
/// \see Process::Notifications
   /// Prints a async warning message to the user one time per Module where a
   /// function is found that was compiled with optimization, per Process.
   ///
   /// \param [in] sc
   ///     A SymbolContext with eSymbolContextFunction and eSymbolContextModule
   ///     pre-computed.
   void PrintWarningOptimization(const SymbolContext &sc);
 
+  /// Print a user-visible warning about a function written in a
+  /// language that this version of LLDB doesn't support.
+  ///
+  /// \see PrintWarningOptimization
+  void PrintWarningUnsupportedLanguage(const SymbolContext &sc);
+
   virtual bool GetProcessInfo(ProcessInstanceInfo &info);
 
 public:
   /// Get the exit status for a process.
   ///
   /// \return
   ///     The process's return code, or -1 if the current process
   ///     state is not eStateExited.

lldb/source/Target/Process.cpp

 }
 
 bool ProcessProperties::GetWarningsOptimization() const {
   const uint32_t idx = ePropertyWarningOptimization;
   return m_collection_sp->GetPropertyAtIndexAsBoolean(
       nullptr, idx, g_process_properties[idx].default_uint_value != 0);
 }
 
+bool ProcessProperties::GetWarningsUnsupportedLanguage() const {
+  const uint32_t idx = ePropertyWarningUnsupportedLanguage;
+  return m_collection_sp->GetPropertyAtIndexAsBoolean(
+      nullptr, idx, g_process_properties[idx].default_uint_value != 0);
+}
+
 bool ProcessProperties::GetStopOnExec() const {
   const uint32_t idx = ePropertyStopOnExec;
   return m_collection_sp->GetPropertyAtIndexAsBoolean(
       nullptr, idx, g_process_properties[idx].default_uint_value != 0);
 }
 
 std::chrono::seconds ProcessProperties::GetUtilityExpressionTimeout() const {
   const uint32_t idx = ePropertyUtilityExpressionTimeout;

 
 void Process::PrintWarning(uint64_t warning_type, const void *repeat_key,
                            const char *fmt, ...) {
   bool print_warning = true;
 
   StreamSP stream_sp = GetTarget().GetDebugger().GetAsyncOutputStream();
   if (!stream_sp)
     return;
-  if (warning_type == eWarningsOptimization && !GetWarningsOptimization()) {
-    return;
-  }
 
   if (repeat_key != nullptr) {
     WarningsCollection::iterator it = m_warnings_issued.find(warning_type);
     if (it == m_warnings_issued.end()) {
       m_warnings_issued[warning_type] = WarningsPointerSet();
       m_warnings_issued[warning_type].insert(repeat_key);
     } else {
       if (it->second.find(repeat_key) != it->second.end()) {
         print_warning = false;
       } else {
         it->second.insert(repeat_key);
       }
     }
   }
 
   if (print_warning) {
     va_list args;
     va_start(args, fmt);
     stream_sp->PrintfVarArg(fmt, args);
     va_end(args);
   }
 }
 
 void Process::PrintWarningOptimization(const SymbolContext &sc) {
-  if (GetWarningsOptimization() && sc.module_sp &&
-      !sc.module_sp->GetFileSpec().GetFilename().IsEmpty() && sc.function &&
+  if (!GetWarningsOptimization())
+    return;
+  if (!sc.module_sp)
+    return;
+  if (!sc.module_sp->GetFileSpec().GetFilename().IsEmpty() && sc.function &&
       sc.function->GetIsOptimized()) {
     PrintWarning(Process::Warnings::eWarningsOptimization, sc.module_sp.get(),
                  "%s was compiled with optimization - stepping may behave "
                  "oddly; variables may not be available.\n",
                  sc.module_sp->GetFileSpec().GetFilename().GetCString());
   }
 }
 
+void Process::PrintWarningUnsupportedLanguage(const SymbolContext &sc) {
+  if (!GetWarningsUnsupportedLanguage())
+    return;
+  if (!sc.module_sp)
+    return;
+  LanguageType language = sc.GetLanguage();
+  if (language == eLanguageTypeUnknown)
+    return;
+  auto type_system_or_err = sc.module_sp->GetTypeSystemForLanguage(language);
+  if (auto err = type_system_or_err.takeError()) {
+    llvm::consumeError(std::move(err));
+    PrintWarning(Process::Warnings::eWarningsUnsupportedLanguage,
+                 sc.module_sp.get(),
+                 "This version of LLDB has no plugin for the %s language. "
+                 "Inspection of frame variables will be limited.\n",
+                 Language::GetNameForLanguageType(language));
+  }
+}
+
 bool Process::GetProcessInfo(ProcessInstanceInfo &info) {
   info.Clear();
 
   PlatformSP platform_sp = GetTarget().GetPlatform();
   if (!platform_sp)
     return false;
 
   return platform_sp->GetProcessInfo(GetID(), info);

lldb/source/Target/TargetProperties.td

def DetachKeepsStopped: Property<"detach-keeps-stopped", "Boolean">,
     DefaultFalse,
     Desc<"If true, detach will attempt to keep the process stopped.">;
   def MemCacheLineSize: Property<"memory-cache-line-size", "UInt64">,
     DefaultUnsignedValue<512>,
     Desc<"The memory cache line size">;
   def WarningOptimization: Property<"optimization-warnings", "Boolean">,
     DefaultTrue,
     Desc<"If true, warn when stopped in code that is optimized where stepping and variable availability may not behave as expected.">;
+  def WarningUnsupportedLanguage: Property<"unsupported-language-warnings", "Boolean">,
+    DefaultTrue,
+    Desc<"If true, warn when stopped in code that is written in a source language that LLDB does not support.">;
   def StopOnExec: Property<"stop-on-exec", "Boolean">,
     Global,
     DefaultTrue,
     Desc<"If true, stop when a shared library is loaded or unloaded.">;
   def UtilityExpressionTimeout: Property<"utility-expression-timeout", "UInt64">,
     DefaultUnsignedValue<15>,
     Desc<"The time in seconds to wait for LLDB-internal utility expressions.">;
 }

lldb/source/Target/Thread.cpp

bool Thread::SetSelectedFrameByIndexNoisily(uint32_t frame_idx,
   } else
     return false;
 }
 
 void Thread::FrameSelectedCallback(StackFrame *frame) {
   if (!frame)
     return;
 
-  if (frame->HasDebugInformation() && GetProcess()->GetWarningsOptimization()) {
+  if (frame->HasDebugInformation() &&
+      (GetProcess()->GetWarningsOptimization() ||
+       GetProcess()->GetWarningsUnsupportedLanguage())) {
     SymbolContext sc =
         frame->GetSymbolContext(eSymbolContextFunction | eSymbolContextModule);
     GetProcess()->PrintWarningOptimization(sc);
+    GetProcess()->PrintWarningUnsupportedLanguage(sc);
   }
 }
 
 lldb::StopInfoSP Thread::GetStopInfo() {
   if (m_destroy_called)
     return m_stop_info_sp;
 
   ThreadPlanSP completed_plan_sp(GetCompletedPlan());

lldb/test/Shell/Process/Inputs/true.c

+int main(int argc, char **argv) {
+  return 0;
+}

lldb/test/Shell/Process/Optimization.test

+Test warnings.
+REQUIRES: shell
+RUN: %clang_host -O3 %S/Inputs/true.c -std=c99 -g -o %t.exe
+RUN: %lldb -o "b main" -o r -o q -b %t.exe | FileCheck %s
+
+CHECK: compiled with optimization

lldb/test/Shell/Process/UnsupportedLanguage.test

+Test warnings.
+REQUIRES: shell
+RUN: %clang_host %S/Inputs/true.c -std=c99 -g -c -S -emit-llvm -o - \
+RUN:   | sed -e 's/DW_LANG_C99/DW_LANG_PLI/g' >%t.ll
+RUN: %clang_host %t.ll -g -o %t.exe
+RUN: %lldb -o "b main" -o r -o q -b %t.exe | FileCheck %s
+
+CHECK: This version of LLDB has no plugin for the pli language