gdb/python: introduce gdb.TargetConnection object type

This commit adds a new object type gdb.TargetConnection.  This new
type represents a connection within GDB (a connection as displayed by
'info connections').

There's three ways to find a gdb.TargetConnection, there's a new
'gdb.connections()' function, which returns a list of all currently
active connections.

Or you can read the new 'connection' property on the gdb.Inferior
object type, this contains the connection for that inferior (or None
if the inferior has no connection, for example, it is exited).

Finally, there's a new gdb.events.connection_removed event registry,
this emits a new gdb.ConnectionEvent whenever a connection is removed
from GDB (this can happen when all inferiors using a connection exit,
though this is not always the case, depending on the connection type).
The gdb.ConnectionEvent has a 'connection' property, which is the
gdb.TargetConnection being removed from GDB.

The gdb.TargetConnection has an 'is_valid()' method.  A connection
object becomes invalid when the underlying connection is removed from
GDB (as discussed above, this might be when all inferiors using a
connection exit, or it might be when the user explicitly replaces a
connection in GDB by issuing another 'target' command).

The gdb.TargetConnection has the following read-only properties:

  'num': The number for this connection,

  'type': e.g. 'native', 'remote', 'sim', etc

  'description': The longer description as seen in the 'info
                 connections' command output.

  'details': A string or None.  Extra details for the connection, for
             example, a remote connection's details might be
             'hostname:port'.

gdb/Makefile.in

@@ -391,6 +391,7 @@ SUBDIR_PYTHON_SRCS = \
 	python/py-bpevent.c \
 	python/py-breakpoint.c \
 	python/py-cmd.c \
+	python/py-connection.c \
 	python/py-continueevent.c \
 	python/py-event.c \
 	python/py-evtregistry.c \

gdb/NEWS

@@ -59,6 +59,21 @@ show logging enabled
   ** New function gdb.Architecture.integer_type(), which returns an
      integer type given a size and a signed-ness.
 
+  ** New gdb.TargetConnection object type that represents a connection
+     (as displayed by the 'info connections' command).
+
+  ** The gdb.Inferior type now has a 'connection' property which is an
+     instance of gdb.TargetConnection, the connection used by this
+     inferior.  This can be None if the inferior has no connection.
+
+  ** New 'gdb.events.connection_removed' event registry, which emits a
+     'gdb.ConnectionEvent' when a connection is removed from GDB.
+     This event has a 'connection' property, a gdb.TargetConnection
+     object for the connection being removed.
+
+  ** New gdb.connections() function that returns a list of all
+     currently active connections.
+
 * New features in the GDB remote stub, GDBserver
 
   ** GDBserver is now supported on OpenRISC GNU/Linux.

gdb/doc/python.texi

@@ -220,6 +220,7 @@ optional arguments while skipping others.  Example:
 * Lazy Strings In Python::      Python representation of lazy strings.
 * Architectures In Python::     Python representation of architectures.
 * Registers In Python::         Python representation of registers.
+* Connections In Python::	Python representation of connections.
 * TUI Windows In Python::       Implementing new TUI windows.
 @end menu
 
@@ -565,6 +566,13 @@ returned from @code{gdb.Architecture.name}
 (@pxref{gdbpy_architecture_name,,Architecture.name}).
 @end defun
 
+@anchor{gdbpy_connections}
+@defun gdb.connections
+Return a list of @code{gdb.TargetConnection} objects, one for each
+currently active connection (@pxref{Connections In Python}).  The
+connection objects are in no particular order in the returned list.
+@end defun
+
 @node Exception Handling
 @subsubsection Exception Handling
 @cindex python exceptions
@@ -3095,10 +3103,18 @@ A @code{gdb.Inferior} object has the following attributes:
 ID of inferior, as assigned by GDB.
 @end defvar
 
+@anchor{gdbpy_inferior_connection}
+@defvar Inferior.connection
+The @code{gdb.TargetConnection} for this inferior (@pxref{Connections
+In Python}), or @code{None} if this inferior has no connection.
+@end defvar
+
 @defvar Inferior.connection_num
 ID of inferior's connection as assigned by @value{GDBN}, or None if
-the inferior is not connected to a target.
+the inferior is not connected to a target.  @xref{Inferiors Connections
-@xref{Inferiors Connections and Programs}.
+and Programs}.  This is equivalent to
+@code{gdb.Inferior.connection.num} in the case where
+@code{gdb.Inferior.connection} is not @code{None}.
 @end defvar
 
 @defvar Inferior.pid
@@ -3439,6 +3455,15 @@ which has a single attribute:
 An integer, the value of the exit code @value{GDBN} will return.
 @end defvar
 
+@item events.connection_removed
+This is emitted when @value{GDBN} removes a connection
+(@pxref{Connections In Python}).  The event is of type
+@code{gdb.ConnectionEvent}.  This has a single read-only attribute:
+
+@defvar ConnectionEvent.connection
+The @code{gdb.TargetConnection} that is being removed.
+@end defvar
+
 @end table
 
 @node Threads In Python
@@ -5973,6 +5998,70 @@ properties:
 A string that is the name of this register group.
 @end defvar
 
+@node Connections In Python
+@subsubsection Connections In Python
+@cindex connections in python
+@value{GDBN} lets you run and debug multiple programs in a single
+session.  Each program being debugged has a connection, the connection
+describes how @value{GDBN} controls the program being debugged.
+Examples of different connection types are @samp{native} and
+@samp{remote}.  @xref{Inferiors Connections and Programs}.
+
+@value{GDBN} uses the @code{gdb.TargetConnection} object type to
+represent a connection in Python code.  To get a list of all
+connections use @code{gdb.connections}
+(@pxref{gdbpy_connections,,gdb.connections}).
+
+To get the connection for a single @code{gdb.Inferior} read its
+@code{gdb.Inferior.connection} attribute
+(@pxref{gdbpy_inferior_connection,,gdb.Inferior.connection}).
+
+A @code{gdb.TargetConnection} has the following method:
+
+@defun TargetConnection.is_valid ()
+Return @code{True} if the @code{gdb.TargetConnection} object is valid,
+@code{False} if not.  A @code{gdb.TargetConnection} will become
+invalid if the connection no longer exists within @value{GDBN}, this
+might happen when no inferiors are using the connection, but could be
+delayed until the user replaces the current target.
+
+Reading any of the @code{gdb.TargetConnection} properties will throw
+an exception if the connection is invalid.
+@end defun
+
+A @code{gdb.TargetConnection} has the following read-only properties:
+
+@defvar TargetConnection.num
+An integer assigned by @value{GDBN} to uniquely identify this
+connection.  This is the same value as displayed in the @samp{Num}
+column of the @code{info connections} command output (@pxref{Inferiors
+Connections and Programs,,info connections}).
+@end defvar
+
+@defvar TargetConnection.type
+A string that describes what type of connection this is.  This string
+will be one of the valid names that can be passed to the @code{target}
+command (@pxref{Target Commands,,target command}).
+@end defvar
+
+@defvar TargetConnection.description
+A string that gives a short description of this target type.  This is
+the same string that is displayed in the @samp{Description} column of
+the @code{info connection} command output (@pxref{Inferiors
+Connections and Programs,,info connections}).
+@end defvar
+
+@defvar TargetConnection.details
+An optional string that gives additional information about this
+connection.  This attribute can be @code{None} if there are no
+additional details for this connection.
+
+An example of a connection type that might have additional details is
+the @samp{remote} connection, in this case the details string can
+contain the @samp{@var{hostname}:@var{port}} that was used to connect
+to the remote target.
+@end defvar
+
 @node TUI Windows In Python
 @subsubsection Implementing new TUI windows
 @cindex Python TUI Windows

gdb/observable.c

@@ -78,6 +78,7 @@ DEFINE_OBSERVABLE (user_selected_context_changed);
 DEFINE_OBSERVABLE (styling_changed);
 DEFINE_OBSERVABLE (current_source_symtab_and_line_changed);
 DEFINE_OBSERVABLE (gdb_exiting);
+DEFINE_OBSERVABLE (connection_removed);
 
 } /* namespace observers */
 } /* namespace gdb */

gdb/observable.h

@@ -253,6 +253,9 @@ extern observable<> current_source_symtab_and_line_changed;
 /* Called when GDB is about to exit.  */
 extern observable<int> gdb_exiting;
 
+/* When a connection is removed.  */
+extern observable<process_stratum_target */* target */> connection_removed;
+
 } /* namespace observers */
 
 } /* namespace gdb */

gdb/python/py-all-events.def

@@ -39,3 +39,4 @@ GDB_PY_DEFINE_EVENT(breakpoint_deleted)
 GDB_PY_DEFINE_EVENT(breakpoint_modified)
 GDB_PY_DEFINE_EVENT(before_prompt)
 GDB_PY_DEFINE_EVENT(gdb_exiting)
+GDB_PY_DEFINE_EVENT(connection_removed)

gdb/python/py-connection.c

@@ -0,0 +1,366 @@
+/* Python interface to inferiors.
+
+   Copyright (C) 2009-2021 Free Software Foundation, Inc.
+
+   This file is part of GDB.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
+
+#include "defs.h"
+#include "python-internal.h"
+#include "process-stratum-target.h"
+#include "inferior.h"
+#include "observable.h"
+#include "target-connection.h"
+#include "py-events.h"
+#include "py-event.h"
+#include "arch-utils.h"
+
+#include <map>
+
+/* The Python object that represents a connection.  */
+
+struct connection_object
+{
+  PyObject_HEAD
+
+  /* The process target that represents this connection.   When a
+     connection_object is created this field will always point at a valid
+     target.  Later, if GDB stops using this target (the target is popped
+     from all target stacks) then this field is set to nullptr, which
+     indicates that this Python object is now in the invalid state (see
+     the is_valid() method below).  */
+  struct process_stratum_target *target;
+};
+
+extern PyTypeObject connection_object_type
+  CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("connection_object");
+
+/* Require that CONNECTION be valid.  */
+#define CONNPY_REQUIRE_VALID(connection)			\
+  do {								\
+    if (connection->target == nullptr)				\
+      {								\
+	PyErr_SetString (PyExc_RuntimeError,			\
+			 _("Connection no longer exists."));	\
+	return nullptr;						\
+      }								\
+  } while (0)
+
+/* A map between process_stratum targets and the Python object representing
+   them.  We actually hold a gdbpy_ref around the Python object so that
+   reference counts are handled correctly when entries are deleted.  */
+static std::map<process_stratum_target *,
+		gdbpy_ref<connection_object>> all_connection_objects;
+
+/* Return a reference to a gdb.TargetConnection object for TARGET.  If
+   TARGET is nullptr then a reference to None is returned.
+
+   Previously created gdb.TargetConnection objects are cached, and
+   additional references to the same connection object can be returned with
+   later calls to this function.  */
+
+gdbpy_ref<>
+target_to_connection_object (process_stratum_target *target)
+{
+  if (target == nullptr)
+    return gdbpy_ref<>::new_reference (Py_None);
+
+  gdbpy_ref <connection_object> conn_obj;
+  auto conn_obj_iter = all_connection_objects.find (target);
+  if (conn_obj_iter == all_connection_objects.end ())
+    {
+      conn_obj.reset (PyObject_New (connection_object,
+				    &connection_object_type));
+      if (conn_obj == nullptr)
+	return nullptr;
+      conn_obj->target = target;
+      all_connection_objects.emplace (target, conn_obj);
+    }
+  else
+    conn_obj = conn_obj_iter->second;
+
+  gdb_assert (conn_obj != nullptr);
+
+  /* Repackage the result as a PyObject reference.  */
+  return gdbpy_ref<> ((PyObject *) conn_obj.release ());
+}
+
+/* Return a list of gdb.TargetConnection objects, one for each currently
+   active connection.  The returned list is in no particular order.  */
+
+PyObject *
+gdbpy_connections (PyObject *self, PyObject *args)
+{
+  gdbpy_ref<> list (PyList_New (0));
+  if (list == nullptr)
+    return nullptr;
+
+  for (process_stratum_target *target : all_non_exited_process_targets ())
+    {
+      gdb_assert (target != nullptr);
+
+      gdbpy_ref<> conn = target_to_connection_object (target);
+      if (conn == nullptr)
+	return nullptr;
+      gdb_assert (conn.get () != Py_None);
+
+      if (PyList_Append (list.get (), conn.get ()) < 0)
+	return nullptr;
+    }
+
+  return list.release ();
+}
+
+/* Emit a connection event for TARGET to REGISTRY.  Return 0 on success, or
+   a negative value on error.  */
+
+static int
+emit_connection_event (process_stratum_target *target,
+		       eventregistry_object *registry)
+{
+  gdbpy_ref<> event_obj
+    = create_event_object (&connection_event_object_type);
+  if (event_obj == nullptr)
+    return -1;
+
+  gdbpy_ref<> conn = target_to_connection_object (target);
+  if (evpy_add_attribute (event_obj.get (), "connection", conn.get ()) < 0)
+    return -1;
+
+  return evpy_emit_event (event_obj.get (), registry);
+}
+
+/* Callback for the connection_removed observer.  */
+
+static void
+connpy_connection_removed (process_stratum_target *target)
+{
+  if (!gdb_python_initialized)
+    return;
+
+  gdbpy_enter enter_py (get_current_arch (), current_language);
+
+  if (!evregpy_no_listeners_p (gdb_py_events.connection_removed))
+    if (emit_connection_event (target, gdb_py_events.connection_removed) < 0)
+      gdbpy_print_stack ();
+
+  auto conn_obj_iter = all_connection_objects.find (target);
+  if (conn_obj_iter != all_connection_objects.end ())
+    {
+      gdbpy_ref <connection_object> conn_obj = conn_obj_iter->second;
+      conn_obj->target = nullptr;
+      all_connection_objects.erase (target);
+    }
+}
+
+/* Called when a gdb.TargetConnection object is deallocated.  */
+
+static void
+connpy_connection_dealloc (PyObject *obj)
+{
+  connection_object *conn_obj = (connection_object *) obj;
+
+  /* As the all_connection_objects map holds a reference to each connection
+     object we can only enter the dealloc function when the reference in
+     all_connection_objects has been erased.
+
+     As we always set the target pointer back to nullptr before we erase
+     items from all_connection_objects then, when we get here, the target
+     pointer must be nullptr.  */
+  gdb_assert (conn_obj->target == nullptr);
+
+  Py_TYPE (obj)->tp_free (obj);
+}
+
+/* Implement repr() for gdb.TargetConnection.  */
+
+static PyObject *
+connpy_repr (PyObject *obj)
+{
+  connection_object *self = (connection_object *) obj;
+  process_stratum_target *target = self->target;
+
+  if (target == nullptr)
+    return PyString_FromFormat ("<%s (invalid)>", Py_TYPE (obj)->tp_name);
+
+  return PyString_FromFormat ("<%s num=%d, what=\"%s\">",
+			      Py_TYPE (obj)->tp_name,
+			      target->connection_number,
+			      make_target_connection_string (target).c_str ());
+}
+
+/* Implementation of gdb.TargetConnection.is_valid() -> Boolean.  Returns
+   True if this connection object is still associated with a
+   process_stratum_target, otherwise, returns False.  */
+
+static PyObject *
+connpy_is_valid (PyObject *self, PyObject *args)
+{
+  connection_object *conn = (connection_object *) self;
+
+  if (conn->target == nullptr)
+    Py_RETURN_FALSE;
+
+  Py_RETURN_TRUE;
+}
+
+/* Return the id number of this connection.  */
+
+static PyObject *
+connpy_get_connection_num (PyObject *self, void *closure)
+{
+  connection_object *conn = (connection_object *) self;
+
+  CONNPY_REQUIRE_VALID (conn);
+
+  auto num = conn->target->connection_number;
+  return gdb_py_object_from_longest (num).release ();
+}
+
+/* Return a string that gives the short name for this connection type.  */
+
+static PyObject *
+connpy_get_connection_type (PyObject *self, void *closure)
+{
+  connection_object *conn = (connection_object *) self;
+
+  CONNPY_REQUIRE_VALID (conn);
+
+  const char *shortname = conn->target->shortname ();
+  return host_string_to_python_string (shortname).release ();
+}
+
+/* Return a string that gives a longer description of this connection type.  */
+
+static PyObject *
+connpy_get_description (PyObject *self, void *closure)
+{
+  connection_object *conn = (connection_object *) self;
+
+  CONNPY_REQUIRE_VALID (conn);
+
+  const char *longname = conn->target->longname ();
+  return host_string_to_python_string (longname).release ();
+}
+
+/* Return a string that gives additional details about this connection, or
+   None, if there are no additional details for this connection type.  */
+
+static PyObject *
+connpy_get_connection_details (PyObject *self, void *closure)
+{
+  connection_object *conn = (connection_object *) self;
+
+  CONNPY_REQUIRE_VALID (conn);
+
+  const char *details = conn->target->connection_string ();
+  if (details != nullptr)
+    return host_string_to_python_string (details).release ();
+  else
+    Py_RETURN_NONE;
+}
+
+/* Python specific initialization for this file.  */
+
+int
+gdbpy_initialize_connection (void)
+{
+  if (PyType_Ready (&connection_object_type) < 0)
+    return -1;
+
+  if (gdb_pymodule_addobject (gdb_module, "TargetConnection",
+			      (PyObject *) &connection_object_type) < 0)
+    return -1;
+
+  return 0;
+}
+
+/* Global initialization for this file.  */
+
+void _initialize_py_connection ();
+void
+_initialize_py_connection ()
+{
+  gdb::observers::connection_removed.attach (connpy_connection_removed,
+					     "py-connection");
+}
+
+/* Methods for the gdb.TargetConnection object type.  */
+
+static PyMethodDef connection_object_methods[] =
+{
+  { "is_valid", connpy_is_valid, METH_NOARGS,
+    "is_valid () -> Boolean.\n\
+Return true if this TargetConnection is valid, false if not." },
+  { NULL }
+};
+
+/* Attributes for the gdb.TargetConnection object type.  */
+
+static gdb_PyGetSetDef connection_object_getset[] =
+{
+  { "num", connpy_get_connection_num, NULL,
+    "ID number of this connection, as assigned by GDB.", NULL },
+  { "type", connpy_get_connection_type, NULL,
+    "A short string that is the name for this connection type.", NULL },
+  { "description", connpy_get_description, NULL,
+    "A longer string describing this connection type.", NULL },
+  { "details", connpy_get_connection_details, NULL,
+    "A string containing additional connection details.", NULL },
+  { NULL }
+};
+
+/* Define the gdb.TargetConnection object type.  */
+
+PyTypeObject connection_object_type =
+{
+  PyVarObject_HEAD_INIT (NULL, 0)
+  "gdb.TargetConnection",	  /* tp_name */
+  sizeof (connection_object),	  /* tp_basicsize */
+  0,				  /* tp_itemsize */
+  connpy_connection_dealloc,	  /* tp_dealloc */
+  0,				  /* tp_print */
+  0,				  /* tp_getattr */
+  0,				  /* tp_setattr */
+  0,				  /* tp_compare */
+  connpy_repr,			  /* tp_repr */
+  0,				  /* tp_as_number */
+  0,				  /* tp_as_sequence */
+  0,				  /* tp_as_mapping */
+  0,				  /* tp_hash  */
+  0,				  /* tp_call */
+  0,				  /* tp_str */
+  0,				  /* tp_getattro */
+  0,				  /* tp_setattro */
+  0,				  /* tp_as_buffer */
+  Py_TPFLAGS_DEFAULT,		  /* tp_flags */
+  "GDB target connection object", /* tp_doc */
+  0,				  /* tp_traverse */
+  0,				  /* tp_clear */
+  0,				  /* tp_richcompare */
+  0,				  /* tp_weaklistoffset */
+  0,				  /* tp_iter */
+  0,				  /* tp_iternext */
+  connection_object_methods,	  /* tp_methods */
+  0,				  /* tp_members */
+  connection_object_getset,	  /* tp_getset */
+  0,				  /* tp_base */
+  0,				  /* tp_dict */
+  0,				  /* tp_descr_get */
+  0,				  /* tp_descr_set */
+  0,				  /* tp_dictoffset */
+  0,				  /* tp_init */
+  0				  /* tp_alloc */
+};

gdb/python/py-event-types.def

@@ -110,3 +110,8 @@ GDB_PY_DEFINE_EVENT_TYPE (gdb_exiting,
 			  "GdbExitingEvent",
 			  "GDB is about to exit",
 			  event_object_type);
+
+GDB_PY_DEFINE_EVENT_TYPE (connection,
+			  "ConnectionEvent",
+			  "GDB connection added or removed object",
+			  event_object_type);

gdb/python/py-inferior.c

@@ -415,6 +415,20 @@ infpy_get_num (PyObject *self, void *closure)
   return gdb_py_object_from_longest (inf->inferior->num).release ();
 }
 
+/* Return the gdb.TargetConnection object for this inferior, or None if a
+   connection does not exist.  */
+
+static PyObject *
+infpy_get_connection (PyObject *self, void *closure)
+{
+  inferior_object *inf = (inferior_object *) self;
+
+  INFPY_REQUIRE_VALID (inf);
+
+  process_stratum_target *target = inf->inferior->process_target ();
+  return target_to_connection_object (target).release ();
+}
+
 /* Return the connection number of the given inferior, or None if a
    connection does not exist.  */
 
@@ -849,6 +863,8 @@ gdbpy_initialize_inferior (void)
 static gdb_PyGetSetDef inferior_object_getset[] =
 {
   { "num", infpy_get_num, NULL, "ID of inferior, as assigned by GDB.", NULL },
+  { "connection", infpy_get_connection, NULL,
+    "The gdb.TargetConnection for this inferior.", NULL },
   { "connection_num", infpy_get_connection_num, NULL,
     "ID of inferior's connection, as assigned by GDB.", NULL },
   { "pid", infpy_get_pid, NULL, "PID of inferior, as assigned by the OS.",

gdb/python/python-internal.h

@@ -482,6 +482,10 @@ gdbpy_ref<inferior_object> inferior_to_inferior_object (inferior *inf);
 PyObject *gdbpy_buffer_to_membuf (gdb::unique_xmalloc_ptr<gdb_byte> buffer,
 				  CORE_ADDR address, ULONGEST length);
 
+struct process_stratum_target;
+gdbpy_ref<> target_to_connection_object (process_stratum_target *target);
+PyObject *gdbpy_connections (PyObject *self, PyObject *args);
+
 const struct block *block_object_to_block (PyObject *obj);
 struct symbol *symbol_object_to_symbol (PyObject *obj);
 struct value *value_object_to_value (PyObject *self);
@@ -555,6 +559,8 @@ int gdbpy_initialize_tui ()
   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 int gdbpy_initialize_membuf ()
   CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
+int gdbpy_initialize_connection ()
+  CPYCHECKER_NEGATIVE_RESULT_SETS_EXCEPTION;
 
 /* A wrapper for PyErr_Fetch that handles reference counting for the
    caller.  */

gdb/python/python.c

@@ -1876,6 +1876,7 @@ do_start_initialization ()
       || gdbpy_initialize_xmethods () < 0
       || gdbpy_initialize_unwind () < 0
       || gdbpy_initialize_membuf () < 0
+      || gdbpy_initialize_connection () < 0
       || gdbpy_initialize_tui () < 0)
     return false;
 
@@ -2326,6 +2327,10 @@ Register a TUI window constructor." },
     "architecture_names () -> List.\n\
 Return a list of all the architecture names GDB understands." },
 
+  { "connections", gdbpy_connections, METH_NOARGS,
+    "connections () -> List.\n\
+Return a list of gdb.TargetConnection objects." },
+
   {NULL, NULL, 0, NULL}
 };
 

gdb/target-connection.c

@@ -24,6 +24,7 @@
 
 #include "inferior.h"
 #include "target.h"
+#include "observable.h"
 
 /* A map between connection number and representative process_stratum
    target.  */
@@ -49,6 +50,9 @@ connection_list_add (process_stratum_target *t)
 void
 connection_list_remove (process_stratum_target *t)
 {
+  /* Notify about the connection being removed before we reset the
+     connection number to zero.  */
+  gdb::observers::connection_removed.notify (t);
   process_targets.erase (t->connection_number);
   t->connection_number = 0;
 }

gdb/testsuite/gdb.multi/multi-target-info-inferiors.exp

@@ -15,18 +15,27 @@
 
 # Test "info inferiors" and "info connections" with multiple targets.
 
+load_lib gdb-python.exp
+
 source $srcdir/$subdir/multi-target.exp.tcl
 
 if {![multi_target_prepare]} {
     return
 }
 
+# Cache the result of calling skip_python_tests into a local variable.
+set run_python_tests [expr ! [skip_python_tests]]
+
 # Test "info inferiors" and "info connections".  MULTI_PROCESS
 # indicates whether the multi-process feature of remote targets is
 # turned off or on.
 proc test_info_inferiors {multi_process} {
     setup "off"
 
+    if { $::run_python_tests } {
+	gdb_test_no_output "source ${::remote_python_file}" "load python file"
+    }
+
     gdb_test_no_output \
 	"set remote multiprocess-feature-packet $multi_process"
 
@@ -86,6 +95,18 @@ proc test_info_inferiors {multi_process} {
 		     "[connection_num 5 $inf]${ws}core${ws}Local core dump file${ws}" \
 		    ]
 
+	    if { $::run_python_tests } {
+		gdb_test "python info_connections()" \
+		    [multi_line \
+			 "Num${ws}What${ws}Description" \
+			 "[connection_num 1 $inf]${ws}native${ws}Native process" \
+			 "[connection_num 2 $inf]${ws}extended-remote localhost:$decimal${ws}Extended remote serial target in gdb-specific protocol" \
+			 "[connection_num 3 $inf]${ws}core${ws}Local core dump file" \
+			 "[connection_num 4 $inf]${ws}extended-remote localhost:$decimal${ws}Extended remote serial target in gdb-specific protocol" \
+			 "[connection_num 5 $inf]${ws}core${ws}Local core dump file" \
+			]
+	    }
+
 	    gdb_test "info inferiors" \
 		[multi_line \
 		     "Num${ws}Description${ws}Connection${ws}Executable${ws}" \
@@ -96,9 +117,26 @@ proc test_info_inferiors {multi_process} {
 		     "[inf_desc 5 $inf]4 \\(extended-remote localhost:$decimal\\)${ws}${binfile}${ws}" \
 		     "[inf_desc 6 $inf]5 \\(core\\)${ws}${binfile}${ws}" \
 		    ]
+
+	    if { $::run_python_tests } {
+		gdb_test "python info_inferiors()" \
+		    [multi_line \
+		     "Inferior 1, Connection #1: native" \
+		     "Inferior 2, Connection #2: extended-remote localhost:$decimal" \
+		     "Inferior 3, Connection #3: core" \
+		     "Inferior 4, Connection #1: native" \
+		     "Inferior 5, Connection #4: extended-remote localhost:$decimal" \
+		     "Inferior 6, Connection #5: core" \
+		    ]
 	    }
 	}
     }
+}
+
+if { $run_python_tests } {
+    set remote_python_file [gdb_remote_download host \
+				${srcdir}/${subdir}/${testfile}.py]
+}
 
 # Test "info inferiors" and "info connections" commands.
 with_test_prefix "info-inferiors" {

gdb/testsuite/gdb.multi/multi-target-info-inferiors.py

@@ -0,0 +1,64 @@
+# Copyright (C) 2021 Free Software Foundation, Inc.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+import gdb
+
+# Take a gdb.TargetConnection and return the connection number.
+def conn_num(c):
+    return c.num
+
+# Takes a gdb.TargetConnection and return a string that is either the
+# type, or the type and details (if the details are not None).
+def make_target_connection_string(c):
+    if c.details is None:
+        return c.type
+    else:
+        return "%s %s" % (c.type, c.details)
+
+# A Python implementation of 'info connections'.  Produce output that
+# is identical to the output of 'info connections' so we can check
+# that aspects of gdb.TargetConnection work correctly.
+def info_connections():
+    all_connections = sorted(gdb.connections(), key=conn_num)
+    current_conn = gdb.selected_inferior().connection
+    what_width = 0
+    for c in all_connections:
+        s = make_target_connection_string(c)
+        if len(s) > what_width:
+            what_width = len(s)
+
+    fmt = "  Num  %%-%ds  Description" % what_width
+    print(fmt % "What")
+    fmt = "%%s%%-3d  %%-%ds  %%s" % what_width
+    for c in all_connections:
+        if c == current_conn:
+            prefix = "* "
+        else:
+            prefix = "  "
+
+        print(fmt % (prefix, c.num, make_target_connection_string(c),
+                     c.description))
+
+def inf_num(i):
+    return i.num
+
+# Print information about each inferior, and the connection it is
+# using.
+def info_inferiors():
+    all_inferiors = sorted(gdb.inferiors(), key=inf_num)
+    for i in gdb.inferiors():
+        print("Inferior %d, Connection #%d: %s" %
+              (i.num, i.connection_num,
+               make_target_connection_string(i.connection)))

gdb/testsuite/gdb.python/py-connection.c

@@ -0,0 +1,22 @@
+/* This testcase is part of GDB, the GNU debugger.
+
+   Copyright 2021 Free Software Foundation, Inc.
+
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program.  If not, see  <http://www.gnu.org/licenses/>.  */
+
+int
+main (void)
+{
+  return 0;
+}

gdb/testsuite/gdb.python/py-connection.exp

@@ -0,0 +1,69 @@
+# Copyright (C) 2021 Free Software Foundation, Inc.
+
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+# This file is for testing the gdb.TargetConnection API.  This API is
+# already tested in gdb.multi/multi-target-info-inferiors.exp and
+# gdb.python/py-inferior.exp, this file just covers some edge cases
+# that are not tested in other places.
+
+load_lib gdb-python.exp
+
+standard_testfile
+
+if { [prepare_for_testing "failed to prepare" ${testfile} ${srcfile}] } {
+    return -1
+}
+
+# Skip all tests if Python scripting is not enabled.
+if { [skip_python_tests] } { continue }
+
+if ![runto_main] then {
+    return 0
+}
+
+# Create a gdb.TargetConnection object and check it is initially
+# valid.
+gdb_test_no_output "python conn = gdb.selected_inferior().connection"
+gdb_test "python print(conn)" \
+    "<gdb.TargetConnection num=1, what=\"\[^\"\]+\">" \
+    "print gdb.TargetConnection while it is still valid"
+gdb_test "python print(conn.is_valid())" "True" "is_valid returns True"
+
+# Get the connection again, and ensure we get the exact same object.
+gdb_test_no_output "python conn2 = gdb.selected_inferior().connection"
+gdb_test "python print('Same object: %s' % (conn is conn2))" "True"
+
+# Now invalidate the connection, and ensure that the is_valid method
+# starts to return False.
+gdb_test "info connections" "\r\n\\* 1 .*" \
+    "info connections while the connection is still around"
+gdb_test "disconnect" "" "kill the inferior" \
+    "A program is being debugged already\\.  Kill it\\? .*y or n. $" "y"
+gdb_test "info connections" "No connections\\." \
+    "info connections now all the connections have gone"
+gdb_test "python print(conn)" "<gdb.TargetConnection \\(invalid\\)>" \
+    "print gdb.TargetConnection now its invalid"
+gdb_test "python print(conn.is_valid())" "False" "is_valid returns False"
+
+# Now check that accessing properties of the invalid connection cases
+# an error.
+gdb_test "python print(conn.num)" \
+    "RuntimeError: Connection no longer exists\\.\r\n.*"
+gdb_test "python print(conn.type)" \
+    "RuntimeError: Connection no longer exists\\.\r\n.*"
+gdb_test "python print(conn.description)" \
+    "RuntimeError: Connection no longer exists\\.\r\n.*"
+gdb_test "python print(conn.details)" \
+    "RuntimeError: Connection no longer exists\\.\r\n.*"

gdb/testsuite/gdb.python/py-inferior.exp

@@ -51,6 +51,8 @@ gdb_py_test_silent_cmd "python i0 = inferiors\[0\]" "get first inferior" 0
 gdb_test "python print ('result = %s' % (i0 == inferiors\[0\]))" " = True" "test equality comparison (true)"
 gdb_test "python print ('result = %s' % i0.num)" " = \[0-9\]+" "test Inferior.num"
 gdb_test "python print ('result = %s' % i0.connection_num)" " = \[0-9\]+" "test Inferior.connection_num"
+gdb_test "python print ('result = %s' % (i0.connection_num == i0.connection.num))" " = True" \
+    "Inferior.connection_num equals Inferior.connection.num"
 gdb_test "python print ('result = %s' % i0.pid)" " = \[0-9\]+" "test Inferior.pid"
 gdb_test "python print ('result = %s' % i0.was_attached)" " = False" "test Inferior.was_attached"
 gdb_test "python print (i0.threads ())" "\\(<gdb.InferiorThread object at 0x\[\[:xdigit:\]\]+>,\\)" "test Inferior.threads"
@@ -264,6 +266,8 @@ with_test_prefix "is_valid" {
 	"RuntimeError: Inferior no longer exists.*"
     gdb_test "python print (inf_list\[1\].connection_num)" \
 	"RuntimeError: Inferior no longer exists.*"
+    gdb_test "python print (inf_list\[1\].connection)" \
+	"RuntimeError: Inferior no longer exists.*"
     gdb_test "python print (inf_list\[1\].pid)" \
 	"RuntimeError: Inferior no longer exists.*"
     gdb_test "python print (inf_list\[1\].was_attached)" \
@@ -281,7 +285,9 @@ with_test_prefix "selected_inferior" {
     gdb_test "inferior 1" ".*" "switch to first inferior"
     gdb_test "py print (gdb.selected_inferior().num)" "1" "first inferior selected"
     gdb_test "py print (gdb.selected_inferior().connection_num)" "1" \
-	"first inferior's connection"
+	"first inferior's connection number"
+    gdb_test "py print (gdb.selected_inferior().connection.num)" "1" \
+	"first inferior's connection number, though connection object"
     # Figure out if inf 1 has a native target.
     set inf_1_is_native [gdb_is_target_native]
 
@@ -289,6 +295,8 @@ with_test_prefix "selected_inferior" {
     gdb_test "inferior 3" ".*" "switch to third inferior"
     gdb_test "py print (gdb.selected_inferior().num)" "3" "third inferior selected"
     gdb_test "py print (gdb.selected_inferior().connection_num)" "None" \
+	"third inferior's None connection number"
+    gdb_test "py print (gdb.selected_inferior().connection)" "None" \
 	"third inferior's None connection"
     gdb_test "target native" "Done.  Use the \"run\" command to start a process." \
 	"target for the third inferior"
@@ -302,7 +310,15 @@ with_test_prefix "selected_inferior" {
     }
     gdb_test "py print (gdb.selected_inferior().connection_num)" \
 	"$expected_connection_num" \
-	"third inferior's native connection"
+	"third inferior's native connection number"
+    gdb_test "py print (gdb.selected_inferior().connection.num)" \
+	"$expected_connection_num" \
+	"third inferior's native connection number, though connection object"
+
+    # Test printing of gdb.TargetConnection object.
+    gdb_test "py print (gdb.selected_inferior().connection)" \
+	"<gdb.TargetConnection num=${expected_connection_num}, what=\"\[^\"\]+\">" \
+	"print a connection object"
 
     gdb_test "inferior 1" ".*" "switch back to first inferior"
     gdb_test_no_output "remove-inferiors 3" "remove second inferior"