Merge commit '738af7a6241c' from llvm.org/master into apple/master

Author: git apple-llvm automerger

lldb/include/lldb/API/SBBreakpoint.h

@@ -94,6 +94,9 @@ class LLDB_API SBBreakpoint {
 
   void SetScriptCallbackFunction(const char *callback_function_name);
 
+  SBError SetScriptCallbackFunction(const char *callback_function_name,
+                                 SBStructuredData &extra_args);
+
   void SetCommandLineCommands(SBStringList &commands);
 
   bool GetCommandLineCommands(SBStringList &commands);

lldb/include/lldb/API/SBBreakpointLocation.h

@@ -55,11 +55,14 @@ class LLDB_API SBBreakpointLocation {
 
   void SetScriptCallbackFunction(const char *callback_function_name);
 
+  SBError SetScriptCallbackFunction(const char *callback_function_name,
+                                    lldb::SBStructuredData &extra_args);
+
   SBError SetScriptCallbackBody(const char *script_body_text);
 
-  void SetCommandLineCommands(SBStringList &commands);
+  void SetCommandLineCommands(lldb::SBStringList &commands);
 
-  bool GetCommandLineCommands(SBStringList &commands);
+  bool GetCommandLineCommands(lldb::SBStringList &commands);
 
   void SetThreadID(lldb::tid_t sb_thread_id);
 

lldb/include/lldb/API/SBBreakpointName.h

@@ -85,9 +85,12 @@ class LLDB_API SBBreakpointName {
 
   void SetScriptCallbackFunction(const char *callback_function_name);
 
-  void SetCommandLineCommands(SBStringList &commands);
+  SBError SetScriptCallbackFunction(const char *callback_function_name,
+                                    SBStructuredData &extra_args);
 
-  bool GetCommandLineCommands(SBStringList &commands);
+  void SetCommandLineCommands(lldb::SBStringList &commands);
+
+  bool GetCommandLineCommands(lldb::SBStringList &commands);
 
   SBError SetScriptCallbackBody(const char *script_body_text);
 

lldb/include/lldb/API/SBStructuredData.h

@@ -93,6 +93,9 @@ class SBStructuredData {
   friend class SBTarget;
   friend class SBThread;
   friend class SBThreadPlan;
+  friend class SBBreakpoint;
+  friend class SBBreakpointLocation;
+  friend class SBBreakpointName;
 
   StructuredDataImplUP m_impl_up;
 };

lldb/include/lldb/Interpreter/OptionGroupPythonClassWithDict.h

@@ -24,13 +24,10 @@ namespace lldb_private {
 class OptionGroupPythonClassWithDict : public OptionGroup {
 public:
   OptionGroupPythonClassWithDict(const char *class_use,
-                      int class_option = 'C',
-                      int key_option = 'k', 
-                      int value_option = 'v',
-                      const char *class_long_option = "python-class",
-                      const char *key_long_option = "python-class-key",
-                      const char *value_long_option = "python-class-value",
-                      bool required = false);
+                                 bool is_class = true,
+                                 int class_option = 'C',
+                                 int key_option = 'k', 
+                                 int value_option = 'v');
 
   ~OptionGroupPythonClassWithDict() override;
 
@@ -48,16 +45,17 @@ class OptionGroupPythonClassWithDict : public OptionGroup {
   const StructuredData::DictionarySP GetStructuredData() {
     return m_dict_sp;
   }
-  const std::string &GetClassName() {
-    return m_class_name;
+  const std::string &GetName() {
+    return m_name;
   }
 
 protected:
-  std::string m_class_name;
+  std::string m_name;
   std::string m_current_key;
   StructuredData::DictionarySP m_dict_sp;
   std::string m_class_usage_text, m_key_usage_text, m_value_usage_text;
-  OptionDefinition m_option_definition[3];
+  bool m_is_class;
+  OptionDefinition m_option_definition[4];
 };
 
 } // namespace lldb_private

lldb/include/lldb/Interpreter/ScriptInterpreter.h

@@ -120,8 +120,10 @@ class ScriptInterpreter : public PluginInterface {
     return error;
   }
 
-  virtual Status GenerateBreakpointCommandCallbackData(StringList &input,
-                                                       std::string &output) {
+  virtual Status GenerateBreakpointCommandCallbackData(
+      StringList &input,
+      std::string &output,
+      bool has_extra_args) {
     Status error;
     error.SetErrorString("not implemented");
     return error;
@@ -311,14 +313,17 @@ class ScriptInterpreter : public PluginInterface {
     return error;
   }
 
-  void SetBreakpointCommandCallbackFunction(
+  Status SetBreakpointCommandCallbackFunction(
       std::vector<BreakpointOptions *> &bp_options_vec,
-      const char *function_name);
+      const char *function_name, 
+      StructuredData::ObjectSP extra_args_sp);
 
-  /// Set a one-liner as the callback for the breakpoint.
-  virtual void
-  SetBreakpointCommandCallbackFunction(BreakpointOptions *bp_options,
-                                       const char *function_name) {}
+  /// Set a script function as the callback for the breakpoint.
+  virtual Status
+  SetBreakpointCommandCallbackFunction(
+      BreakpointOptions *bp_options,
+      const char *function_name,
+      StructuredData::ObjectSP extra_args_sp) {}
 
   /// Set a one-liner as the callback for the watchpoint.
   virtual void SetWatchpointCommandCallback(WatchpointOptions *wp_options,
@@ -463,6 +468,12 @@ class ScriptInterpreter : public PluginInterface {
   const char *GetScriptInterpreterPtyName();
 
   int GetMasterFileDescriptor();
+  
+  virtual llvm::Expected<size_t> 
+  GetNumFixedArgumentsForCallable(const llvm::StringRef &callable_name) { 
+    return llvm::createStringError(
+    llvm::inconvertibleErrorCode(), "Unimplemented function");
+  }
 
   static std::string LanguageToString(lldb::ScriptLanguage language);
 

lldb/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_command/TestBreakpointCommand.py

@@ -18,7 +18,7 @@ class BreakpointCommandTestCase(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24528")
-    def test_breakpoint_command_sequence(self):
+    def not_test_breakpoint_command_sequence(self):
         """Test a sequence of breakpoint command add, list, and delete."""
         self.build()
         self.breakpoint_command_sequence()
@@ -107,6 +107,10 @@ def breakpoint_command_sequence(self):
             "breakpoint command add -s command -o 'frame variable --show-types --scope' 1 4")
         self.runCmd(
             "breakpoint command add -s python -o 'import side_effect; side_effect.one_liner = \"one liner was here\"' 2")
+
+        import side_effect
+        self.runCmd("command script import --allow-reload ./bktptcmd.py")
+
         self.runCmd(
             "breakpoint command add --python-function bktptcmd.function 3")
 
@@ -151,8 +155,6 @@ def breakpoint_command_sequence(self):
 
         self.runCmd("breakpoint delete 4")
 
-        self.runCmd("command script import --allow-reload ./bktptcmd.py")
-
         # Next lets try some other breakpoint kinds.  First break with a regular expression
         # and then specify only one file.  The first time we should get two locations,
         # the second time only one:

lldb/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_command/TestBreakpointCommandsFromPython.py

@@ -19,10 +19,15 @@ class PythonBreakpointCommandSettingTestCase(TestBase):
 
     @add_test_categories(['pyapi'])
     def test_step_out_python(self):
-        """Test stepping out using avoid-no-debug with dsyms."""
+        """Test stepping out using a python breakpoint command."""
         self.build()
         self.do_set_python_command_from_python()
 
+    def test_bkpt_cmd_bad_arguments(self):
+        """Test what happens when pass structured data to a command:"""
+        self.build()
+        self.do_bad_args_to_python_command()
+        
     def setUp(self):
         TestBase.setUp(self)
         self.main_source = "main.c"
@@ -43,6 +48,18 @@ def do_set_python_command_from_python(self):
             "Set break point at this line.", self.main_source_spec)
         self.assertTrue(func_bkpt, VALID_BREAKPOINT)
 
+        fancy_bkpt = self.target.BreakpointCreateBySourceRegex(
+            "Set break point at this line.", self.main_source_spec)
+        self.assertTrue(fancy_bkpt, VALID_BREAKPOINT)
+
+        fancier_bkpt = self.target.BreakpointCreateBySourceRegex(
+            "Set break point at this line.", self.main_source_spec)
+        self.assertTrue(fancier_bkpt, VALID_BREAKPOINT)
+
+        not_so_fancy_bkpt = self.target.BreakpointCreateBySourceRegex(
+            "Set break point at this line.", self.main_source_spec)
+        self.assertTrue(not_so_fancy_bkpt, VALID_BREAKPOINT)
+
         # Also test that setting a source regex breakpoint with an empty file
         # spec list sets it on all files:
         no_files_bkpt = self.target.BreakpointCreateBySourceRegex(
@@ -75,14 +92,37 @@ def do_set_python_command_from_python(self):
             "Failed to set the script callback body: %s." %
             (error.GetCString()))
 
-        self.dbg.HandleCommand(
-            "command script import --allow-reload ./bktptcmd.py")
+        self.expect("command script import --allow-reload ./bktptcmd.py")
+        
         func_bkpt.SetScriptCallbackFunction("bktptcmd.function")
 
+        extra_args = lldb.SBStructuredData()
+        stream = lldb.SBStream()
+        stream.Print('{"side_effect" : "I am fancy"}')
+        extra_args.SetFromJSON(stream)
+        error = fancy_bkpt.SetScriptCallbackFunction("bktptcmd.another_function", extra_args)
+        self.assertTrue(error.Success(), "Failed to add callback %s"%(error.GetCString()))
+        
+        stream.Clear()
+        stream.Print('{"side_effect" : "I am so much fancier"}')
+        extra_args.SetFromJSON(stream)
+        
+        # Fancier's callback is set up from the command line
+        id = fancier_bkpt.GetID()
+        self.expect("breakpoint command add -F bktptcmd.a_third_function -k side_effect -v 'I am fancier' %d"%(id))
+
+        # Not so fancy gets an empty extra_args:
+        empty_args = lldb.SBStructuredData()
+        error = not_so_fancy_bkpt.SetScriptCallbackFunction("bktptcmd.empty_extra_args", empty_args)
+        self.assertTrue(error.Success(), "Failed to add callback %s"%(error.GetCString()))
+        
         # Clear out canary variables
         side_effect.bktptcmd = None
         side_effect.callback = None
-
+        side_effect.fancy    = None
+        side_effect.fancier  = None
+        side_effect.not_so_fancy = None
+        
         # Now launch the process, and do not stop at entry point.
         self.process = self.target.LaunchSimple(
             None, None, self.get_process_working_directory())
@@ -97,3 +137,38 @@ def do_set_python_command_from_python(self):
 
         self.assertEquals("callback was here", side_effect.callback)
         self.assertEquals("function was here", side_effect.bktptcmd)
+        self.assertEquals("I am fancy", side_effect.fancy)
+        self.assertEquals("I am fancier", side_effect.fancier)
+        self.assertEquals("Not so fancy", side_effect.not_so_fancy)
+
+    def do_bad_args_to_python_command(self):
+        exe = self.getBuildArtifact("a.out")
+        error = lldb.SBError()
+
+        self.target = self.dbg.CreateTarget(exe)
+        self.assertTrue(self.target, VALID_TARGET)
+
+
+        self.expect("command script import --allow-reload ./bktptcmd.py")
+
+        bkpt = self.target.BreakpointCreateBySourceRegex(
+            "Set break point at this line.", self.main_source_spec)
+        self.assertTrue(bkpt, VALID_BREAKPOINT)
+
+        # Pass a breakpoint command function that doesn't take extra_args,
+        # but pass it extra args:
+        
+        extra_args = lldb.SBStructuredData()
+        stream = lldb.SBStream()
+        stream.Print('{"side_effect" : "I am fancy"}')
+        extra_args.SetFromJSON(stream)
+
+        error = bkpt.SetScriptCallbackFunction("bktptcmd.function", extra_args)
+        self.assertTrue(error.Fail(), "Can't pass extra args if the function doesn't take them")
+
+        error = bkpt.SetScriptCallbackFunction("bktptcmd.useless_function", extra_args)
+        self.assertTrue(error.Fail(), "Can't pass extra args if the function has wrong number of args.")
+
+        error = bkpt.SetScriptCallbackFunction("bktptcmd.nosuch_function", extra_args)
+        self.assertTrue(error.Fail(), "Can't pass extra args if the function doesn't exist.")
+        

lldb/packages/Python/lldbsuite/test/functionalities/breakpoint/breakpoint_command/bktptcmd.py

@@ -1,5 +1,23 @@
 from __future__ import print_function
 import side_effect
 
+def useless_function(first, second):
+    print("I have the wrong number of arguments.")
+
 def function(frame, bp_loc, dict):
     side_effect.bktptcmd = "function was here"
+
+def another_function(frame, bp_loc, extra_args, dict):
+    se_value = extra_args.GetValueForKey("side_effect")
+    se_string = se_value.GetStringValue(100)
+    side_effect.fancy = se_string
+
+def a_third_function(frame, bp_loc, extra_args, dict):
+    se_value = extra_args.GetValueForKey("side_effect")
+    se_string = se_value.GetStringValue(100)
+    side_effect.fancier = se_string
+
+def empty_extra_args(frame, bp_loc, extra_args, dict):
+    if extra_args.IsValid():
+        side_effect.not_so_fancy = "Extra args should not be valid"
+    side_effect.not_so_fancy = "Not so fancy"

lldb/scripts/Python/python-wrapper.swig

@@ -45,7 +45,8 @@ LLDBSwigPythonBreakpointCallbackFunction
     const char *python_function_name,
     const char *session_dictionary_name,
     const lldb::StackFrameSP& frame_sp,
-    const lldb::BreakpointLocationSP& bp_loc_sp
+    const lldb::BreakpointLocationSP& bp_loc_sp,
+    lldb_private::StructuredDataImpl *args_impl
 )
 {
     lldb::SBFrame sb_frame (frame_sp);
@@ -62,7 +63,19 @@ LLDBSwigPythonBreakpointCallbackFunction
 
     PythonObject frame_arg(PyRefType::Owned, SBTypeToSWIGWrapper(sb_frame));
     PythonObject bp_loc_arg(PyRefType::Owned, SBTypeToSWIGWrapper(sb_bp_loc));
-    PythonObject result = pfunc(frame_arg, bp_loc_arg, dict);
+
+    PythonObject result;
+    // If the called function doesn't take extra_args, drop them here:
+    auto arg_info = pfunc.GetNumArguments();
+    if (arg_info.count == 3)
+      result = pfunc(frame_arg, bp_loc_arg, dict);
+    else if (arg_info.count == 4) {
+        lldb::SBStructuredData *args_value = new lldb::SBStructuredData(args_impl);
+        PythonObject args_arg(PyRefType::Owned, SBTypeToSWIGWrapper(args_value));
+        result = pfunc(frame_arg, bp_loc_arg, args_arg, dict);      
+    } else {
+      return stop_at_breakpoint;
+    }
 
     if (result.get() == Py_False)
         stop_at_breakpoint = false;

lldb/scripts/interface/SBBreakpoint.i

@@ -179,6 +179,14 @@ public:
     void
     SetScriptCallbackFunction (const char *callback_function_name);
 
+    %feature("docstring", "
+    Set the name of the script function to be called when the breakpoint is hit.
+    To use this variant, the function should take (frame, bp_loc, extra_args, dict) and
+    when the breakpoint is hit the extra_args will be passed to the callback function.") SetScriptCallbackFunction;
+    SBError
+    SetScriptCallbackFunction (const char *callback_function_name,
+                               SBStructuredData &extra_args);
+
     %feature("docstring", "
     Provide the body for the script function to be called when the breakpoint is hit.
     The body will be wrapped in a function, which be passed two arguments:

lldb/scripts/interface/SBBreakpointLocation.i

@@ -73,10 +73,19 @@ public:
     void SetAutoContinue(bool auto_continue);
 
     %feature("docstring", "
-    Set the callback to the given Python function name.") SetScriptCallbackFunction;
+    Set the callback to the given Python function name.
+    The function takes three arguments (frame, bp_loc, dict).") SetScriptCallbackFunction;
     void
     SetScriptCallbackFunction (const char *callback_function_name);
 
+    %feature("docstring", "
+    Set the name of the script function to be called when the breakpoint is hit.
+    To use this variant, the function should take (frame, bp_loc, extra_args, dict) and
+    when the breakpoint is hit the extra_args will be passed to the callback function.") SetScriptCallbackFunction;
+    SBError
+    SetScriptCallbackFunction (const char *callback_function_name,
+                               SBStructuredData &extra_args);
+
     %feature("docstring", "
     Provide the body for the script function to be called when the breakpoint location is hit.
     The body will be wrapped in a function, which be passed two arguments:

lldb/scripts/interface/SBBreakpointName.i

@@ -84,6 +84,10 @@ public:
 
   void SetScriptCallbackFunction(const char *callback_function_name);
 
+  SBError
+  SetScriptCallbackFunction (const char *callback_function_name,
+                             SBStructuredData &extra_args);
+
   void SetCommandLineCommands(SBStringList &commands);
 
   bool GetCommandLineCommands(SBStringList &commands);