[lldb] Add support for specifying language when setting watchpoint by expression

[bulbazord]

Summary

This is useful in contexts where you have multiple languages in play:
You may be stopped in a frame for language A, but want to set a watchpoint
with an expression using language B. The current way to do this is to
use the setting target.language while setting the watchpoint and
unset it after the watchpoint is set, but that's kind of clunky and
somewhat error-prone. This should add a better way to do this.

rdar://108202559

[jasonmolenda]

LGTM.

lldb/source/Interpreter/OptionGroupWatchpoint.cpp

67

I don't care much, but the formatting of this entry is pretty inconsistent with the two SET_1's above. Should they match?

[bulbazord]

lldb/source/Interpreter/OptionGroupWatchpoint.cpp

67

I applied clang-format to the entire thing and this is what it gave me.... /shrug

[mib]

I think we should still be able to use this new flag with the previous ones (i.e. watchpoint set -l c++ -w read -- &my_var)

lldb/source/Interpreter/OptionGroupWatchpoint.cpp

67

Having a different option group for this flag means it can't be used with the other ones ... Is that really what you want ?

[bulbazord]

In D149111#4296670, @mib wrote:

I think we should still be able to use this new flag with the previous ones (i.e. watchpoint set -l c++ -w read -- &my_var)

You can do that still with this patch. I'm placing the language flag in a 2nd group so that watchpoint set variable does not have access to this flag, but watchpoint set expression does. You can still mix and match the flags for expression.

lldb/source/Interpreter/OptionGroupWatchpoint.cpp

67

OptionGroupWatchpoint as far as I can tell is only used for watchpoint set expression and watchpoint set variable. I don't think this flag makes sense for watchpoint set variable, so I'm adding it to the 2nd group for expression and opting out for variable.

[mib]

In D149111#4296709, @bulbazord wrote:

In D149111#4296670, @mib wrote:

I think we should still be able to use this new flag with the previous ones (i.e. watchpoint set -l c++ -w read -- &my_var)

You can do that still with this patch. I'm placing the language flag in a 2nd group so that watchpoint set variable does not have access to this flag, but watchpoint set expression does. You can still mix and match the flags for expression.

Thanks for clarifying that. LGTM!

[bulbazord]

Looks like this test does not pass on windows: https://lab.llvm.org/buildbot/#/builders/219/builds/2389

I'm aware and working on this.

[bulbazord]

In D149111#4299871, @bulbazord wrote:

Looks like this test does not pass on windows: https://lab.llvm.org/buildbot/#/builders/219/builds/2389

I'm aware and working on this.

I marked the test as unsupported on windows in 7590cc908807b1bfc63695ca016a60327c1aacdf. This should get the bot green again.

lldb/include/lldb/Interpreter/OptionGroupWatchpoint.h

enum WatchType {
     eWatchRead,
     eWatchWrite,
     eWatchReadWrite
   };
 
   WatchType watch_type;
   uint32_t watch_size;
   bool watch_type_specified;
+  lldb::LanguageType language_type;
 
 private:
   OptionGroupWatchpoint(const OptionGroupWatchpoint &) = delete;
   const OptionGroupWatchpoint &
   operator=(const OptionGroupWatchpoint &) = delete;
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_INTERPRETER_OPTIONGROUPWATCHPOINT_H

lldb/source/Commands/CommandObjectWatchpoint.cpp

corresponding to the byte size of the data type.");
 
     // Push the variant into the argument entry.
     arg.push_back(var_name_arg);
 
     // Push the data for the only argument into the m_arguments vector.
     m_arguments.push_back(arg);
 
     // Absorb the '-w' and '-s' options into our option group.
-    m_option_group.Append(&m_option_watchpoint, LLDB_OPT_SET_ALL,
-                          LLDB_OPT_SET_1);
+    m_option_group.Append(&m_option_watchpoint, LLDB_OPT_SET_1, LLDB_OPT_SET_1);
     m_option_group.Finalize();
   }
 
   ~CommandObjectWatchpointSetVariable() override = default;
 
   void
   HandleArgumentCompletion(CompletionRequest &request,
                            OptionElementVector &opt_element_vector) override {

 #pragma mark Set
 
 class CommandObjectWatchpointSetExpression : public CommandObjectRaw {
 public:
   CommandObjectWatchpointSetExpression(CommandInterpreter &interpreter)
       : CommandObjectRaw(
             interpreter, "watchpoint set expression",
             "Set a watchpoint on an address by supplying an expression. "
+            "Use the '-l' option to specify the language of the expression. "
             "Use the '-w' option to specify the type of watchpoint and "
             "the '-s' option to specify the byte size to watch for. "
             "If no '-w' option is specified, it defaults to write. "
             "If no '-s' option is specified, it defaults to the target's "
             "pointer byte size. "
             "Note that there are limited hardware resources for watchpoints. "
             "If watchpoint setting fails, consider disable/delete existing "
             "ones "
bool DoExecute(llvm::StringRef raw_command,
 
     // Use expression evaluation to arrive at the address to watch.
     EvaluateExpressionOptions options;
     options.SetCoerceToId(false);
     options.SetUnwindOnError(true);
     options.SetKeepInMemory(false);
     options.SetTryAllThreads(true);
     options.SetTimeout(std::nullopt);
+    if (m_option_watchpoint.language_type != eLanguageTypeUnknown)
+      options.SetLanguage(m_option_watchpoint.language_type);
 
     ExpressionResults expr_result =
         target->EvaluateExpression(expr, frame, valobj_sp, options);
     if (expr_result != eExpressionCompleted) {
       result.AppendError("expression evaluation of address to watch failed");
       result.AppendErrorWithFormat("expression evaluated: \n%s", expr.data());
       if (valobj_sp && !valobj_sp->GetError().Success())
         result.AppendError(valobj_sp->GetError().AsCString());

lldb/source/Interpreter/OptionGroupWatchpoint.cpp

 //===-- OptionGroupWatchpoint.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/Interpreter/OptionGroupWatchpoint.h"
 
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Interpreter/OptionArgParser.h"
+#include "lldb/Target/Language.h"
 #include "lldb/lldb-enumerations.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 static constexpr OptionEnumValueElement g_watch_type[] = {
     {
         OptionGroupWatchpoint::eWatchRead,

 };
 
 static constexpr OptionDefinition g_option_table[] = {
     {LLDB_OPT_SET_1, false, "watch", 'w', OptionParser::eRequiredArgument,
      nullptr, OptionEnumValues(g_watch_type), 0, eArgTypeWatchType,
      "Specify the type of watching to perform."},
     {LLDB_OPT_SET_1, false, "size", 's', OptionParser::eRequiredArgument,
      nullptr, OptionEnumValues(g_watch_size), 0, eArgTypeByteSize,
-     "Number of bytes to use to watch a region."}};
+     "Number of bytes to use to watch a region."},
+    {LLDB_OPT_SET_2,
+     false,
+     "language",
+     'l',
+     OptionParser::eRequiredArgument,
+     nullptr,
+     {},
+     0,
+     eArgTypeLanguage,
+     "Language of expression to run"}};
 
 bool OptionGroupWatchpoint::IsWatchSizeSupported(uint32_t watch_size) {
   for (const auto& size : g_watch_size) {
     if (0  == size.value)
       break;
     if (watch_size == size.value)
       return true;
   }
   return false;
 }
 
 Status
 OptionGroupWatchpoint::SetOptionValue(uint32_t option_idx,
                                       llvm::StringRef option_arg,
                                       ExecutionContext *execution_context) {
   Status error;
   const int short_option = g_option_table[option_idx].short_option;
   switch (short_option) {
+  case 'l': {
+    language_type = Language::GetLanguageTypeFromString(option_arg);
+    if (language_type == eLanguageTypeUnknown) {
+      StreamString sstr;
+      sstr.Printf("Unknown language type: '%s' for expression. List of "
+                  "supported languages:\n",
+                  option_arg.str().c_str());
+      Language::PrintSupportedLanguagesForExpressions(sstr, " ", "\n");
+      error.SetErrorString(sstr.GetString());
+    }
+    break;
+  }
   case 'w': {
     WatchType tmp_watch_type;
     tmp_watch_type = (WatchType)OptionArgParser::ToOptionEnum(
         option_arg, g_option_table[option_idx].enum_values, 0, error);
     if (error.Success()) {
       watch_type = tmp_watch_type;
       watch_type_specified = true;
     }
OptionGroupWatchpoint::SetOptionValue(uint32_t option_idx,
   return error;
 }
 
 void OptionGroupWatchpoint::OptionParsingStarting(
     ExecutionContext *execution_context) {
   watch_type_specified = false;
   watch_type = eWatchInvalid;
   watch_size = 0;
+  language_type = eLanguageTypeUnknown;
 }
 
 llvm::ArrayRef<OptionDefinition> OptionGroupWatchpoint::GetDefinitions() {
   return llvm::ArrayRef(g_option_table);
 }

lldb/test/Shell/Watchpoint/ExpressionLanguage.test

+# RUN: %clangxx_host %p/Inputs/languages.cpp -g -o %t.out
+# RUN: %lldb -b -o 'settings set interpreter.stop-command-source-on-error false' -s %s %t.out 2>&1 | FileCheck %s
+
+settings  show interpreter.stop-command-source-on-error
+# CHECK: interpreter.stop-command-source-on-error (boolean) = false
+
+b main
+run
+# CHECK: stopped
+# CHECK-NEXT: stop reason = breakpoint
+
+watchpoint set expression -- &g_foo
+# CHECK: Watchpoint created:
+
+watchpoint set expression -l c++ -- &g_bar
+# CHECK: Watchpoint created:
+
+watchpoint set expression -l fake -- &g_baz
+# CHECK: Unknown language type: 'fake' for expression. List of supported languages:

lldb/test/Shell/Watchpoint/Inputs/languages.cpp

+#include <cstdint>
+#include <iostream>
+
+uint64_t g_foo = 5;
+uint64_t g_bar = 6;
+uint64_t g_baz = 7;
+
+int main() {
+  int val = 8;
+  printf("Hello world! %d\n", val);
+  return 0;
+}