[Swig] Merge typemaps with same bodies

[jingham]

This patch changes the SB API. We don't break binary compatibility with the SB API's, and especially not for something like GetInstructions/GetInstructionsWithFlavor, which are functions somebody out there is sure to be using. See:

https://lldb.llvm.org/SB-api-coding-rules.html

I didn't know you could list multiple signatures in one type map, that part is cool!

But we don't allow removing SB API's, so the part where you remove a function and replace it with a defaulted argument one or straight up remove an API can't go in as is. If you want to add a cleaner function, that's fine.

BTW, Sean isn't working on lldb anymore, so assigning him as a reviewer isn't going to do much good :-(

[tatyana-krasnukha]

Thanks for the information I missed. Removed all changes of API and joined together more typemap implementations.

[jingham]

Nice, thanks!

include/lldb/API/SBTarget.h

   lldb::SBValue CreateValueFromData(const char *name, lldb::SBData data,
                                     lldb::SBType type);
 
   lldb::SBValue CreateValueFromExpression(const char *name, const char *expr);
 
   SBSourceManager GetSourceManager();
 
   lldb::SBInstructionList ReadInstructions(lldb::SBAddress base_addr,
-                                           uint32_t count);
-
-  lldb::SBInstructionList ReadInstructions(lldb::SBAddress base_addr,
                                            uint32_t count,
-                                           const char *flavor_string);
+                                           const char *flavor_string = nullptr);
 
   lldb::SBInstructionList GetInstructions(lldb::SBAddress base_addr,
-                                          const void *buf, size_t size);
-
-  // The "WithFlavor" is necessary to keep SWIG from getting confused about
-  // overloaded arguments when using the buf + size -> Python Object magic.
-
-  lldb::SBInstructionList GetInstructionsWithFlavor(lldb::SBAddress base_addr,
-                                                    const char *flavor_string,
-                                                    const void *buf,
-                                                    size_t size);
+                                          const void *buf, size_t size,
+                                          const char *flavor_string = nullptr);
 
   lldb::SBInstructionList GetInstructions(lldb::addr_t base_addr,
-                                          const void *buf, size_t size);
-
-  lldb::SBInstructionList GetInstructionsWithFlavor(lldb::addr_t base_addr,
-                                                    const char *flavor_string,
-                                                    const void *buf,
-                                                    size_t size);
+                                          const void *buf, size_t size,
+                                          const char *flavor_string = nullptr);
 
   lldb::SBSymbolContextList FindSymbols(const char *name,
                                         lldb::SymbolType type = eSymbolTypeAny);
 
   bool operator==(const lldb::SBTarget &rhs) const;
 
   bool operator!=(const lldb::SBTarget &rhs) const;
 

scripts/Python/python-typemaps.swig

 }
 // SBProcess::ReadCStringFromMemory() uses a void*, but needs to be treated
 // as char data instead of byte data.
 %typemap(argout) (void *char_buf, size_t size) = (char *dst, size_t dst_len);
 
 
 // typemap for an outgoing buffer
 // See also SBEvent::SBEvent(uint32_t event, const char *cstr, uint32_t cstr_len).
-%typemap(in) (const char *cstr, uint32_t cstr_len) {
-   using namespace lldb_private;
-   if (PythonString::Check($input)) {
-      PythonString str(PyRefType::Borrowed, $input);
-      $1 = (char*)str.GetString().data();
-      $2 = str.GetSize();
-   }
-   else if(PythonByteArray::Check($input)) {
-      PythonByteArray bytearray(PyRefType::Borrowed, $input);
-      $1 = (char*)bytearray.GetBytes().data();
-      $2 = bytearray.GetSize();
-   }
-   else if (PythonBytes::Check($input)) {
-      PythonBytes bytes(PyRefType::Borrowed, $input);
-      $1 = (char*)bytes.GetBytes().data();
-      $2 = bytes.GetSize();
-   }
-   else {
-      PyErr_SetString(PyExc_ValueError, "Expecting a string");
-      return NULL;
-   }
-}
 // Ditto for SBProcess::PutSTDIN(const char *src, size_t src_len).
-%typemap(in) (const char *src, size_t src_len) {
+%typemap(in) (const char *cstr, uint32_t cstr_len),
+             (const char *src, size_t src_len) {
    using namespace lldb_private;
    if (PythonString::Check($input)) {
       PythonString str(PyRefType::Borrowed, $input);
       $1 = (char*)str.GetString().data();
       $2 = str.GetSize();
    }
    else if(PythonByteArray::Check($input)) {
       PythonByteArray bytearray(PyRefType::Borrowed, $input);
       $1 = (char*)bytearray.GetBytes().data();
       $2 = bytearray.GetSize();
    }
    else if (PythonBytes::Check($input)) {
       PythonBytes bytes(PyRefType::Borrowed, $input);
       $1 = (char*)bytes.GetBytes().data();
       $2 = bytes.GetSize();
    }
    else {
       PyErr_SetString(PyExc_ValueError, "Expecting a string");
       return NULL;
    }
 }
-// And SBProcess::WriteMemory.
-%typemap(in) (const void *buf, size_t size) {
+// For SBProcess::WriteMemory, SBTarget::GetInstructions and SBDebugger::DispatchInput.
+%typemap(in) (const void *buf, size_t size),
+             (const void *data, size_t data_len) {
    using namespace lldb_private;
    if (PythonString::Check($input)) {
       PythonString str(PyRefType::Borrowed, $input);
       $1 = (void*)str.GetString().data();
       $2 = str.GetSize();
    }
    else if(PythonByteArray::Check($input)) {
       PythonByteArray bytearray(PyRefType::Borrowed, $input);
       $1 = (void*)bytearray.GetBytes().data();
       $2 = bytearray.GetSize();
    }
    else if (PythonBytes::Check($input)) {
       PythonBytes bytes(PyRefType::Borrowed, $input);
       $1 = (void*)bytes.GetBytes().data();
       $2 = bytes.GetSize();
    }
    else {
       PyErr_SetString(PyExc_ValueError, "Expecting a buffer");
       return NULL;
    }
 }
-
-// For SBDebugger::DispatchInput
-%typemap(in) (const void *data, size_t data_len) {
-   using namespace lldb_private;
-   if (PythonString::Check($input)) {
-      PythonString str(PyRefType::Borrowed, $input);
-      $1 = (void*)str.GetString().data();
-      $2 = str.GetSize();
-   }
-   else if(PythonByteArray::Check($input)) {
-      PythonByteArray bytearray(PyRefType::Borrowed, $input);
-      $1 = (void*)bytearray.GetBytes().data();
-      $2 = bytearray.GetSize();
-   }
-   else if (PythonBytes::Check($input)) {
-      PythonBytes bytes(PyRefType::Borrowed, $input);
-      $1 = (void*)bytes.GetBytes().data();
-      $2 = bytes.GetSize();
-   }
-   else {
-      PyErr_SetString(PyExc_ValueError, "Expecting a buffer");
-      return NULL;
-   }
+// For SBTarget::GetInstructions.
+// Required when we have deal with overloaded functions.
+%typemap(typecheck) (const void *buf, size_t size) {
+    $1 = ($input == Py_None) ? 0 : 1;
 }
 
 // typemap for an incoming buffer
 // See also SBProcess::ReadMemory.
 %typemap(in) (void *buf, size_t size) {
    if (PyInt_Check($input)) {
       $2 = PyInt_AsLong($input);
    } else if (PyLong_Check($input)) {

scripts/interface/SBTarget.i

     Disassemble a specified number of instructions starting at an address.
     Parameters:
        base_addr       -- the address to start disassembly from
        count           -- the number of instructions to disassemble
        flavor_string   -- may be 'intel' or 'att' on x86 targets to specify that style of disassembly
     Returns an SBInstructionList.")
     ReadInstructions;
     lldb::SBInstructionList
-    ReadInstructions (lldb::SBAddress base_addr, uint32_t count);
-
-    lldb::SBInstructionList
-    ReadInstructions (lldb::SBAddress base_addr, uint32_t count, const char *flavor_string);
-
-    %feature("docstring", "
-    Disassemble the bytes in a buffer and return them in an SBInstructionList.
-    Parameters:
-       base_addr -- used for symbolicating the offsets in the byte stream when disassembling
-       buf       -- bytes to be disassembled
-       size      -- (C++) size of the buffer
-    Returns an SBInstructionList.")
-    GetInstructions;
-    lldb::SBInstructionList
-    GetInstructions (lldb::SBAddress base_addr, const void *buf, size_t size);
+    ReadInstructions (lldb::SBAddress base_addr, uint32_t count, const char *flavor_string = nullptr);
 
     %feature("docstring", "
     Disassemble the bytes in a buffer and return them in an SBInstructionList, with a supplied flavor.
     Parameters:
        base_addr -- used for symbolicating the offsets in the byte stream when disassembling
-       flavor    -- may be 'intel' or 'att' on x86 targets to specify that style of disassembly
        buf       -- bytes to be disassembled
        size      -- (C++) size of the buffer
-    Returns an SBInstructionList.")
-    GetInstructionsWithFlavor;
+       flavor    -- may be 'intel' or 'att' on x86 targets to specify that style of disassembly
+    Returns an SBInstructionList.") 
+    GetInstructions;
     lldb::SBInstructionList
-    GetInstructionsWithFlavor (lldb::SBAddress base_addr, const char *flavor_string, const void *buf, size_t size);
+    GetInstructions (lldb::SBAddress base_addr, const void *buf, size_t size, const char *flavor_string = nullptr);
 
     lldb::SBSymbolContextList
     FindSymbols (const char *name, lldb::SymbolType type = eSymbolTypeAny);
 
     bool
     GetDescription (lldb::SBStream &description, lldb::DescriptionLevel description_level);
 
     lldb::addr_t

source/API/SBTarget.cpp

 }
 
 SBSourceManager SBTarget::GetSourceManager() {
   SBSourceManager source_manager(*this);
   return source_manager;
 }
 
 lldb::SBInstructionList SBTarget::ReadInstructions(lldb::SBAddress base_addr,
-                                                   uint32_t count) {
-  return ReadInstructions(base_addr, count, NULL);
-}
-
-lldb::SBInstructionList SBTarget::ReadInstructions(lldb::SBAddress base_addr,
                                                    uint32_t count,
                                                    const char *flavor_string) {
   SBInstructionList sb_instructions;
 
   TargetSP target_sp(GetSP());
   if (target_sp) {
     Address *addr_ptr = base_addr.get();
 

           data.GetBytes(), bytes_read, count, data_from_file));
     }
   }
 
   return sb_instructions;
 }
 
 lldb::SBInstructionList SBTarget::GetInstructions(lldb::SBAddress base_addr,
-                                                  const void *buf,
-                                                  size_t size) {
-  return GetInstructionsWithFlavor(base_addr, NULL, buf, size);
-}
-
-lldb::SBInstructionList
-SBTarget::GetInstructionsWithFlavor(lldb::SBAddress base_addr,
-                                    const char *flavor_string, const void *buf,
-                                    size_t size) {
+                                                  const void *buf, size_t size,
+                                                  const char *flavor_string) {
   SBInstructionList sb_instructions;
 
   TargetSP target_sp(GetSP());
   if (target_sp) {
     Address addr;
 
     if (base_addr.get())
       addr = *base_addr.get();
 
     const bool data_from_file = true;
 
     sb_instructions.SetDisassembler(Disassembler::DisassembleBytes(
         target_sp->GetArchitecture(), NULL, flavor_string, addr, buf, size,
         UINT32_MAX, data_from_file));
   }
 
   return sb_instructions;
 }
 
 lldb::SBInstructionList SBTarget::GetInstructions(lldb::addr_t base_addr,
-                                                  const void *buf,
-                                                  size_t size) {
-  return GetInstructionsWithFlavor(ResolveLoadAddress(base_addr), NULL, buf,
-                                   size);
-}
-
-lldb::SBInstructionList
-SBTarget::GetInstructionsWithFlavor(lldb::addr_t base_addr,
-                                    const char *flavor_string, const void *buf,
-                                    size_t size) {
-  return GetInstructionsWithFlavor(ResolveLoadAddress(base_addr), flavor_string,
-                                   buf, size);
+                                                  const void *buf, size_t size,
+                                                  const char *flavor_string) {
+  return GetInstructions(
+      ResolveLoadAddress(base_addr), buf, size, flavor_string);
 }
 
 SBError SBTarget::SetSectionLoadAddress(lldb::SBSection section,
                                         lldb::addr_t section_base_addr) {
   SBError sb_error;
   TargetSP target_sp(GetSP());
   if (target_sp) {
     if (!section.IsValid()) {