[lldb/Lua] add initial Lua typemaps

[tammela]

Summary

This patch adds the integer handling typemaps and the typemap for
string returning functions.

The integer handling typemaps overrides SWIG's own typemaps to distinct
the handling of integers from floating point.

The typemap for string returning functions is a port of Python's
typemap.

[JDevlieghere]

We guarantee that the SB API is ABI stable so you cannot change the signature of existing functions. Would an overload do the trick?

[tammela]

Removing spurious line

[tammela]

In D94937#2505676, @JDevlieghere wrote:

We guarantee that the SB API is ABI stable so you cannot change the signature of existing functions. Would an overload do the trick?

Hmmm, that's tricky. I will see if I can come up with something.

[tammela]

In D94937#2505676, @JDevlieghere wrote:

We guarantee that the SB API is ABI stable so you cannot change the signature of existing functions. Would an overload do the trick?

If overloaded with const char *GetStringValue(const char *fail_value = nullptr), SWIG emits a warning when building the Python wrapper saying that the method is shadowed and doesn't emit it.
const char *GetStringValue() works, however it doesn't follow the API contract.
Would adding a new method GetConstStringValue() also be acceptable?

I'm out of ideas to solve this. This method is very Python oriented, as the SWIG wrapper understands the {in,out} documentation. This doesn't happen for the Lua wrapper.

[JDevlieghere]

I replied before I actually tried to understand what your'e trying to achieve, and it's still not entirely clear to me. I think what you need is something similar like python-typemaps.swig which helps swig understand char** types and such.

For context, originally SWIG wasn't great at handling std::strings (which has since been fixed) and the designers of the SB API were worried about the ABI stability of the std::string class. None of these are concerns anymore today, but the ABI being stable means we're stuck with it for now. If we ever do an SB API v2, this is definitely one of the things we'd fix, but currently there are no plans for that.

[tammela]

In D94937#2511222, @JDevlieghere wrote:

I replied before I actually tried to understand what your'e trying to achieve, and it's still not entirely clear to me. I think what you need is something similar like python-typemaps.swig which helps swig understand char** types and such.

For context, originally SWIG wasn't great at handling std::strings (which has since been fixed) and the designers of the SB API were worried about the ABI stability of the std::string class. None of these are concerns anymore today, but the ABI being stable means we're stuck with it for now. If we ever do an SB API v2, this is definitely one of the things we'd fix, but currently there are no plans for that.

That's exactly what I need, thanks. I will adjust accordingly.

[tammela]

Addressing comments

[tammela]

Typos

[JDevlieghere]

LGTM

lldb/bindings/lua/lua-typemaps.swig

7 ↗

(On Diff #318300)

nit: Lua 5.3

lldb/bindings/interface/SBStructuredData.i

public:
         lldb::SBStructuredData GetItemAtIndex(size_t idx) const;
 
         uint64_t GetIntegerValue(uint64_t fail_value = 0) const;
 
         double GetFloatValue(double fail_value = 0.0) const;
 
         bool GetBooleanValue(bool fail_value = false) const;
 
-        size_t GetStringValue(char *dst, size_t dst_len) const;
+        const char *GetStringValue(const char *fail_value = nullptr) const;
 
         lldb::SBError
         GetAsJSON(lldb::SBStream &stream) const;
 
         lldb::SBError
         GetDescription(lldb::SBStream &stream) const;
 
         lldb::SBError
         SetFromJSON(lldb::SBStream &stream);
     };
 }

lldb/examples/python/in_call_stack.py

 #!/usr/bin/env python
 
 
 def __lldb_init_module(debugger, internal_dict):
   debugger.HandleCommand(
       'command alias in_call_stack breakpoint command add --python-function in_call_stack.in_call_stack -k name -v %1'
   )
 
 
 def in_call_stack(frame, bp_loc, arg_dict, _):
   """Only break if the given name is in the current call stack."""
-  name = arg_dict.GetValueForKey('name').GetStringValue(1000)
+  name = arg_dict.GetValueForKey('name').GetStringValue()
   thread = frame.GetThread()
   found = False
   for frame in thread.frames:
     # Check the symbol.
     symbol = frame.GetSymbol()
     if symbol and name in frame.GetSymbol().GetName():
       return True
     # Check the function.
     function = frame.GetFunction()
     if function and name in function.GetName():
       return True
   return False

lldb/include/lldb/API/SBStructuredData.h

 //===-- SBStructuredData.h --------------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_API_SBSTRUCTUREDDATA_H
 #define LLDB_API_SBSTRUCTUREDDATA_H
 
 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBModule.h"
 
 namespace lldb {
 
 class SBStructuredData {
 public:
   SBStructuredData();
 
public:
 
   /// Return the floating point value if this data structure is a floating
   /// type.
   double GetFloatValue(double fail_value = 0.0) const;
 
   /// Return the boolean value if this data structure is a boolean type.
   bool GetBooleanValue(bool fail_value = false) const;
 
-  /// Provides the string value if this data structure is a string type.
-  ///
-  /// \param[out] dst
-  ///     pointer where the string value will be written. In case it is null,
-  ///     nothing will be written at \a dst.
-  ///
-  /// \param[in] dst_len
-  ///     max number of characters that can be written at \a dst. In case it is
-  ///     zero, nothing will be written at \a dst. If this length is not enough
-  ///     to write the complete string value, (\a dst_len - 1) bytes of the
-  ///     string value will be written at \a dst followed by a null character.
-  ///
-  /// \return
-  ///     Returns the byte size needed to completely write the string value at
-  ///     \a dst in all cases.
-  size_t GetStringValue(char *dst, size_t dst_len) const;
+  /// Return the string value if this data structure is a string type.
+  const char *GetStringValue(const char *fail_value = nullptr) const;
 
 protected:
   friend class SBTraceOptions;
   friend class SBDebugger;
   friend class SBTarget;
   friend class SBProcess;
   friend class SBThread;
   friend class SBThreadPlan;

lldb/include/lldb/Core/StructuredDataImpl.h

 //===-- StructuredDataImpl.h ------------------------------------*- C++ -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_CORE_STRUCTUREDDATAIMPL_H
 #define LLDB_CORE_STRUCTUREDDATAIMPL_H
 
 #include "lldb/Target/StructuredDataPlugin.h"
 #include "lldb/Utility/Event.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StructuredData.h"
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-forward.h"
 #include "llvm/ADT/StringRef.h"
 
public:
   double GetFloatValue(double fail_value = 0.0) const {
     return (m_data_sp ? m_data_sp->GetFloatValue(fail_value) : fail_value);
   }
 
   bool GetBooleanValue(bool fail_value = false) const {
     return (m_data_sp ? m_data_sp->GetBooleanValue(fail_value) : fail_value);
   }
 
-  size_t GetStringValue(char *dst, size_t dst_len) const {
-    if (!m_data_sp)
-      return 0;
-
-    llvm::StringRef result = m_data_sp->GetStringValue();
-    if (result.empty())
-      return 0;
-
-    if (!dst || !dst_len) {
-      char s[1];
-      return (::snprintf(s, 1, "%s", result.data()));
-    }
-    return (::snprintf(dst, dst_len, "%s", result.data()));
+  const char *GetStringValue(const char *fail_value = nullptr) const {
+    return (m_data_sp ? m_data_sp->GetStringValue(fail_value).data()
+                      : fail_value);
   }
 
 private:
   lldb::StructuredDataPluginWP m_plugin_wp;
   StructuredData::ObjectSP m_data_sp;
 };
 } // namespace lldb_private
 #endif

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

 def skipIfEditlineSupportMissing(func):
     return _get_bool_config_skip_if_decorator("editline")(func)
 
 def skipIfLLVMTargetMissing(target):
     config = lldb.SBDebugger.GetBuildConfiguration()
     targets = config.GetValueForKey("targets").GetValueForKey("value")
     found = False
     for i in range(targets.GetSize()):
-        if targets.GetItemAtIndex(i).GetStringValue(99) == target:
+        if targets.GetItemAtIndex(i).GetStringValue() == target:
             found = True
             break
 
     return unittest2.skipIf(not found, "requires " + target)
 
 # Call sysctl on darwin to see if a specified hardware feature is available on this machine.
 def skipUnlessFeature(feature):
     def is_feature_enabled(self):

lldb/source/API/SBStructuredData.cpp

 //===-- SBStructuredData.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/SBStructuredData.h"
 #include "SBReproducerPrivate.h"
 
 #include "lldb/API/SBStream.h"
 #include "lldb/API/SBStringList.h"
 #include "lldb/Core/StructuredDataImpl.h"
 #include "lldb/Target/StructuredDataPlugin.h"
 #include "lldb/Utility/Event.h"
 #include "lldb/Utility/Status.h"

 
 bool SBStructuredData::GetBooleanValue(bool fail_value) const {
   LLDB_RECORD_METHOD_CONST(bool, SBStructuredData, GetBooleanValue, (bool),
                            fail_value);
 
   return (m_impl_up ? m_impl_up->GetBooleanValue(fail_value) : fail_value);
 }
 
-size_t SBStructuredData::GetStringValue(char *dst, size_t dst_len) const {
-  LLDB_RECORD_CHAR_PTR_METHOD_CONST(size_t, SBStructuredData, GetStringValue,
-                                    (char *, size_t), dst, "", dst_len);
+const char *SBStructuredData::GetStringValue(const char *fail_value) const {
+  LLDB_RECORD_METHOD_CONST(const char *, SBStructuredData, GetStringValue,
+                           (const char *), fail_value);
 
-  return (m_impl_up ? m_impl_up->GetStringValue(dst, dst_len) : 0);
+  return (m_impl_up ? m_impl_up->GetStringValue(fail_value) : fail_value);
 }
 
 namespace lldb_private {
 namespace repro {
 
 template <> void RegisterMethods<SBStructuredData>(Registry &R) {
   LLDB_REGISTER_CONSTRUCTOR(SBStructuredData, ());
   LLDB_REGISTER_CONSTRUCTOR(SBStructuredData, (const lldb::SBStructuredData &));
template <> void RegisterMethods<SBStructuredData>(Registry &R) {
   LLDB_REGISTER_METHOD_CONST(lldb::SBStructuredData, SBStructuredData,
                              GetValueForKey, (const char *));
   LLDB_REGISTER_METHOD_CONST(lldb::SBStructuredData, SBStructuredData,
                              GetItemAtIndex, (size_t));
   LLDB_REGISTER_METHOD_CONST(uint64_t, SBStructuredData, GetIntegerValue,
                              (uint64_t));
   LLDB_REGISTER_METHOD_CONST(double, SBStructuredData, GetFloatValue, (double));
   LLDB_REGISTER_METHOD_CONST(bool, SBStructuredData, GetBooleanValue, (bool));
-  LLDB_REGISTER_CHAR_PTR_METHOD_CONST(size_t, SBStructuredData, GetStringValue);
+  LLDB_REGISTER_METHOD_CONST(const char *, SBStructuredData, GetStringValue,
+                             (const char *));
 }
 
 } // namespace repro
 } // namespace lldb_private

lldb/test/API/commands/platform/basic/TestPlatformPython.py

def test_platform_list(self):
                         host_platform.GetName() == 'host',
                         'The host platform is present')
         # Select another platform and verify that the platform is added to
         # the platform list.
         platform_idx = self.dbg.GetNumAvailablePlatforms() - 1
         if platform_idx < 1:
             self.fail('No platforms other than host are available')
         platform_data = self.dbg.GetAvailablePlatformInfoAtIndex(platform_idx)
-        platform_name = platform_data.GetValueForKey('name').GetStringValue(100)
+        platform_name = platform_data.GetValueForKey('name').GetStringValue()
         self.assertNotEqual(platform_name, 'host')
         self.dbg.SetCurrentPlatform(platform_name)
         selected_platform = self.dbg.GetSelectedPlatform()
         self.assertTrue(selected_platform.IsValid())
         self.assertEqual(selected_platform.GetName(), platform_name)
         self.assertEqual(self.dbg.GetNumPlatforms(), initial_num_platforms + 1)
         platform_found = False
         for platform_idx in range(self.dbg.GetNumPlatforms()):

lldb/test/API/commands/target/stop-hooks/stop_hook.py

def __init__(self, target, extra_args, dict):
             self.ret_val = True
 
     def handle_stop(self, exe_ctx, stream):
         self.counter += 1
         stream.Print("I have stopped %d times.\n"%(self.counter))
         increment = 1
         value = self.extra_args.GetValueForKey("increment")
         if value:
-            incr_as_str = value.GetStringValue(100)
+            incr_as_str = value.GetStringValue()
             increment = int(incr_as_str)
         else:
             stream.Print("Could not find increment in extra_args\n")
         frame = exe_ctx.GetFrame()
         expression = "g_var += %d"%(increment)
         expr_result = frame.EvaluateExpression(expression)
         if not expr_result.GetError().Success():
             stream.Print("Error running expression: %s"%(expr_result.GetError().GetCString()))

lldb/test/API/functionalities/breakpoint/breakpoint_command/bktptcmd.py

 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)
+    se_string = se_value.GetStringValue()
     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)
+    se_string = se_value.GetStringValue()
     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/test/API/functionalities/breakpoint/scripted_bkpt/resolver.py

def __init__(self, bkpt, extra_args, dict):
         
       Resolver.func_list = []
       Resolver.got_files = 0
 
   def __callback__(self, sym_ctx):
       sym_name = "not_a_real_function_name"
       sym_item = self.extra_args.GetValueForKey("symbol")
       if sym_item.IsValid():
-          sym_name = sym_item.GetStringValue(1000)
+          sym_name = sym_item.GetStringValue()
       else:
           print("Didn't have a value for key 'symbol'")
 
       if sym_ctx.compile_unit.IsValid():
           Resolver.got_files = 1
       else:
           Resolver.got_files = 2
       

lldb/test/API/functionalities/breakpoint/serialize/TestBreakpointSerialization.py

def do_check_extra_args(self):
 
         copy_extra_args = side_effect.g_extra_args
         copy_keys = lldb.SBStringList()
         copy_extra_args.GetKeys(copy_keys)
         self.assertEqual(2, copy_keys.GetSize(), "Copy should have two keys")
 
         for idx in range(0, orig_keys.GetSize()):
             key = orig_keys.GetStringAtIndex(idx)
-            copy_value = copy_extra_args.GetValueForKey(key).GetStringValue(100)
+            copy_value = copy_extra_args.GetValueForKey(key).GetStringValue()
 
             if key == "first_arg":
                 self.assertEqual(copy_value, "first_value")
             elif key == "second_arg":
                 self.assertEqual(copy_value, "second_value")
             else:
                 self.Fail("Unknown key: %s"%(key))

lldb/test/API/functionalities/step_scripted/Steps.py

 class StepUntil(StepWithChild):
     def __init__(self, thread_plan, args_data, dict):
         self.frame = thread_plan.GetThread().frames[0]
         self.target = thread_plan.GetThread().GetProcess().GetTarget()
         func_entry = args_data.GetValueForKey("variable_name")
         
         if not func_entry.IsValid():
             print("Did not get a valid entry for variable_name")
-        func_name = func_entry.GetStringValue(100)
+        func_name = func_entry.GetStringValue()
 
         self.value = self.frame.FindVariable(func_name)
         if self.value.GetError().Fail():
             print("Failed to get foo value: %s"%(self.value.GetError().GetCString()))
         else:
             print("'foo' value: %d"%(self.value.GetValueAsUnsigned()))
 
         StepWithChild.__init__(self, thread_plan)

 
 # This plan does nothing, but sets stop_mode to the
 # value of GetStopOthers for this plan.
 class StepReportsStopOthers():
     stop_mode_dict = {}
     
     def __init__(self, thread_plan, args_data, dict):
         self.thread_plan = thread_plan
-        self.key = args_data.GetValueForKey("token").GetStringValue(1000)
+        self.key = args_data.GetValueForKey("token").GetStringValue()
         
     def should_stop(self, event):
         self.thread_plan.SetPlanComplete(True)
         print("Called in should_stop")
         StepReportsStopOthers.stop_mode_dict[self.key] = self.thread_plan.GetStopOthers()
         return True
 
     def should_step(self):
         return True
 
     def explains_stop(self, event):
         return True

lldb/test/API/python_api/sbstructureddata/TestStructuredDataAPI.py

def string_struct_test(self, dict_struct):
         if not string_struct.IsValid():
             self.fail("A valid object should have been returned")
 
         # Check Type API
         if not string_struct.GetType() == lldb.eStructuredDataTypeString:
             self.fail("Wrong type returned: " + str(string_struct.GetType()))
 
         # Check API returning 'string' value
-        output = string_struct.GetStringValue(25)
+        output = string_struct.GetStringValue()
         if not "STRING" in output:
             self.fail("wrong output: " + output)
 
         # Calling wrong API on a SBStructuredData
         # (e.g. getting an integer from a string type structure)
         output = string_struct.GetIntegerValue()
         if output:
             self.fail(
def int_struct_test(self, dict_struct):
 
         # Check API returning 'integer' value
         output = int_struct.GetIntegerValue()
         if not output == 3:
             self.fail("wrong output: " + str(output))
 
         # Calling wrong API on a SBStructuredData
         # (e.g. getting a string value from an integer type structure)
-        output = int_struct.GetStringValue(25)
+        output = int_struct.GetStringValue()
         if output:
             self.fail(
                 "Valid string " +
                 output +
                 " returned for an integer object")
 
     def double_struct_test(self, dict_struct):
         floating_point_struct = lldb.SBStructuredData()
def array_struct_test(self, dict_struct):
 
         # Check API returning a valid SBStructuredData for different 'array'
         # indices
         string_struct = array_struct.GetItemAtIndex(0)
         if not string_struct.IsValid():
             self.fail("A valid object should have been returned")
         if not string_struct.GetType() == lldb.eStructuredDataTypeString:
             self.fail("Wrong type returned: " + str(string_struct.GetType()))
-        output = string_struct.GetStringValue(5)
+        output = string_struct.GetStringValue()
         if not output == "23":
             self.fail("wrong output: " + str(output))
 
         string_struct = array_struct.GetItemAtIndex(1)
         if not string_struct.IsValid():
             self.fail("A valid object should have been returned")
         if not string_struct.GetType() == lldb.eStructuredDataTypeString:
             self.fail("Wrong type returned: " + str(string_struct.GetType()))
-        output = string_struct.GetStringValue(5)
+        output = string_struct.GetStringValue()
         if not output == "arr":
             self.fail("wrong output: " + str(output))