This patch adds Python debugger support.  It may be contributed upstream at

some point, but the suitability (or lack thereof) has not yet been determined.

 # Default target

 all:		build_all

-build_all:	$(BUILDPYTHON) oldsharedmods sharedmods gdbhooks Modules/_testembed python-config

+build_all:	$(BUILDPYTHON) oldsharedmods sharedmods gdbhooks Modules/_testembed python-config build-py_db

 # Compile a binary with gcc profile guided optimization.

 profile-opt:

 	@mv config.c Modules

 	@echo "The Makefile was updated, you may need to re-run make."

+SHLIB_FLAGS = -shared -fpic

+

+libpython$(LDVERSION)_db.so.1.0:        $(srcdir)/py_db/libpython34_db.c

+	$(CC) -o $@ $(CFLAGS) $(PY_CPPFLAGS) $(CPPFLAGS) $(SHLIB_FLAGS) $<

+

+check_offset:  $(srcdir)/py_db/check_offsets.c

+	$(CC) -o $@ $(CFLAGS) $(PY_CPPFLAGS) $(CPPFLAGS) $<

+

+build-py_db:   libpython$(LDVERSION)_db.so.1.0 check_offset

+

+install-py_db: libpython$(LDVERSION)_db.so.1.0 check_offset

+	$(INSTALL_SHARED) libpython$(LDVERSION)_db.so.1.0 $(DESTDIR)$(LIBDIR)

+	$(INSTALL_PROGRAM) check_offset $(DESTDIR)$(BINDIR)

 Modules/Setup: $(srcdir)/Modules/Setup.dist

 	@if test -f Modules/Setup; then \

 		$(TESTRUNNER) $(QUICKTESTOPTS)

-install: @FRAMEWORKINSTALLFIRST@ commoninstall bininstall maninstall @FRAMEWORKINSTALLLAST@

+install: @FRAMEWORKINSTALLFIRST@ commoninstall bininstall maninstall install-py_db @FRAMEWORKINSTALLLAST@

 	if test "x$(ENSUREPIP)" != "xno"  ; then \

 		case $(ENSUREPIP) in \

 			upgrade) ensurepip="--upgrade" ;; \

--- /dev/null

+++ Python-3.4.0/py_db/check_offsets.c

@@ -0,0 +1,87 @@

+/*

+ * CDDL HEADER START

+ *

+ * The contents of this file are subject to the terms of the

+ * Common Development and Distribution License (the "License").

+ * You may not use this file except in compliance with the License.

+ *

+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

+ * or http://www.opensolaris.org/os/licensing.

+ * See the License for the specific language governing permissions

+ * and limitations under the License.

+ *

+ * When distributing Covered Code, include this CDDL HEADER in each

+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

+ * If applicable, add the following below this CDDL HEADER, with the

+ * fields enclosed by brackets "[]" replaced with your own identifying

+ * information: Portions Copyright [yyyy] [name of copyright owner]

+ *

+ * CDDL HEADER END

+ */

+/*

+ * Copyright (c) 2012, Oracle and/or its affiliates. All rights reserved.

+ */

+

+#include <stdio.h>

+

+#include <Python.h>

+#include <frameobject.h>

+

+#include "libpython34_db_32.h"

+

+#if 0

+#define	offsetof(s, m)	((size_t)(&(((s *)0)->m)))

+#endif

+

+int

+main(void)

+{

+/*

+ * PyCodeObject co_name

+ * PyCodeObject co_filename

+ * PyCodeObject co_lnotab

+ * PyFrameObject f_back

+ * PyFrameObject f_code

+ * PyFrameObject f_lasti

+ * PyInterpreterState next

+ * PyInterpreterState tstate_head

+ * PyBytesObject ob_sval

+ * PyBytesObject ob_size

+ * PyThreadState frame

+ * PyThreadState next

+ */

+

+	printf("struct member: native 32\n");

+	printf("PyCodeObject co_name: %d %d\n", offsetof(PyCodeObject, co_name),

+	    offsetof(PyCodeObject32, co_name));

+	printf("PyCodeObject co_filename: %d %d\n", offsetof(PyCodeObject,

+	    co_filename), offsetof(PyCodeObject32, co_filename));

+	printf("PyCodeObject co_lnotab: %d %d\n", offsetof(PyCodeObject,

+	    co_lnotab), offsetof(PyCodeObject32, co_lnotab));

+	printf("PyFrameObject f_back: %d %d\n", offsetof(PyFrameObject, f_back),

+	    offsetof(PyFrameObject32, f_back));

+	printf("PyFrameObject f_code: %d %d\n", offsetof(PyFrameObject, f_code),

+	    offsetof(PyFrameObject32, f_code));

+	printf("PyFrameObject f_lasti: %d %d\n", offsetof(PyFrameObject,

+	    f_lasti), offsetof(PyFrameObject32, f_lasti));

+	printf("PyInterpreterState next: %d %d\n", offsetof(PyInterpreterState,

+	    next), offsetof(PyInterpreterState32, next));

+	printf("PyInterpreterState tstate_head: %d %d\n",

+	    offsetof(PyInterpreterState, tstate_head),

+	    offsetof(PyInterpreterState32, tstate_head));

+	printf("PyBytesObject ob_sval: %d %d\n", offsetof(PyBytesObject,

+	    ob_sval), offsetof(PyBytesObject32, ob_sval));

+	printf("PyBytesObject ob_size: %d %d\n", offsetof(PyBytesObject,

+	    ob_base.ob_size), offsetof(PyBytesObject32, ob_size));

+	printf("PyThreadState frame: %d %d\n", offsetof(PyThreadState, frame),

+	    offsetof(PyThreadState32, frame));

+	printf("PyThreadState next: %d %d\n", offsetof(PyThreadState, next),

+	    offsetof(PyThreadState32, next));

+

+	printf("\nObject sizes\n");

+	printf("PyObject: %d %d\n", sizeof (PyObject), sizeof (PyObject32));

+	printf("PyVarObject: %d %d\n", sizeof (PyVarObject),

+	    sizeof (PyVarObject32));

+

+	return (0);

+}

--- /dev/null

+++ Python-3.4.0/py_db/libpython34_db.c

@@ -0,0 +1,654 @@

+/*

+ * CDDL HEADER START

+ *

+ * The contents of this file are subject to the terms of the

+ * Common Development and Distribution License (the "License").

+ * You may not use this file except in compliance with the License.

+ *

+ * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

+ * or http://www.opensolaris.org/os/licensing.

+ * See the License for the specific language governing permissions

+ * and limitations under the License.

+ *

+ * When distributing Covered Code, include this CDDL HEADER in each

+ * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

+ * If applicable, add the following below this CDDL HEADER, with the

+ * fields enclosed by brackets "[]" replaced with your own identifying

+ * information: Portions Copyright [yyyy] [name of copyright owner]

+ *

+ * CDDL HEADER END

+ */

+/*

+ * Copyright (c) 2012, 2014, Oracle and/or its affiliates. All rights reserved.

+ */

+

+#include <stdio.h>

+#include <stdlib.h>

+#include <string.h>

+#include <errno.h>

+#include <gelf.h>

+

+#include <Python.h>

+#include <frameobject.h>

+

+#include "libpython34_db.h"

+#if defined(_LP64)

+#include "libpython34_db_32.h"

+#endif /* _LP64 */

+

+/*

+ * Because MDB always runs the debugger in the same datamodel as the target,

+ * only functions that are used by the procfs part of this interface (or shared

+ * between the two) are written as 64->32 aware.

+ */

+typedef struct pydb_arch_ops {

+	ssize_t	(*strobj_readdata)(pydb_agent_t *, uintptr_t, unsigned char *,

+	    size_t);

+	int	(*frameinfo)(pydb_agent_t *, uintptr_t, char *,

+	    size_t, char *, size_t, int *);

+} pydb_arch_ops_t;

+

+struct pydb_agent {

+	struct ps_prochandle *pdb_ph;

+	int pdb_vers;

+	int pdb_is_64bit;

+	int pdb_datamodel;

+	const pydb_arch_ops_t *pdb_ops;

+};

+

+typedef uintptr_t (*pdi_next_cb_t)(pydb_iter_t *);

+

+struct pydb_iter {

+	struct ps_prochandle *pdi_ph;

+	uintptr_t pdi_current;

+	pdi_next_cb_t pdi_nextf;

+};

+

+#define	LIBPYTHON	"libpython3.4.so"

+

+#define	MIN(x, y)	(((x) < (y)) ? (x) : (y))

+

+/* Generic interface to helper functions */

+static ssize_t pydb_strobj_readdata(pydb_agent_t *py, uintptr_t addr,

+    unsigned char *buf, size_t buf_len);

+static int pydb_getlno(pydb_agent_t *py, uintptr_t lnotab_addr, int firstline,

+    int lastinst);

+static int pydb_frameinfo(pydb_agent_t *py, uintptr_t addr, char *funcnm,

+    size_t funcnm_sz, char *filenm, size_t filenm_sz, int *lineno);

+

+/* datamodel specific implementation of helper functions */

+static ssize_t pydb_strobj_readdata_native(pydb_agent_t *py, uintptr_t addr,

+    unsigned char *buf, size_t buf_len);

+static int pydb_frameinfo_native(pydb_agent_t *py, uintptr_t addr, char *funcnm,

+    size_t funcnm_sz, char *filenm, size_t filenm_sz, int *lineno);

+

+#if defined (_LP64)

+static ssize_t pydb_strobj_readdata_32(pydb_agent_t *py, uintptr_t addr,

+    unsigned char *buf, size_t buf_len);

+static int pydb_frameinfo_32(pydb_agent_t *py, uintptr_t addr, char *funcnm,

+    size_t funcnm_sz, char *filenm, size_t filenm_sz, int *lineno);

+#endif /* _LP64 */

+

+static ssize_t pydb_strobj_readstr(pydb_agent_t *py, uintptr_t addr, char *buf,

+    size_t len);

+

+/* Iterator function next routines.  Plugable, configured by iterator init */

+static uintptr_t pydb_frame_iter_next(pydb_iter_t *iter);

+static uintptr_t pydb_interp_iter_next(pydb_iter_t *iter);

+static uintptr_t pydb_thread_iter_next(pydb_iter_t *iter);

+

+static const char *strbasename(const char *s);

+

+static const pydb_arch_ops_t arch_ops_native = {

+	.frameinfo = pydb_frameinfo_native,

+	.strobj_readdata = pydb_strobj_readdata_native,

+};

+

+#if defined (_LP64)

+static const pydb_arch_ops_t arch_ops_32 = {

+	.frameinfo = pydb_frameinfo_32,

+	.strobj_readdata = pydb_strobj_readdata_32,

+};

+#endif /* _LP64 */

+

+static const char *

+strbasename(const char *s)

+{

+	const char *p = strrchr(s, '/');

+

+	if (p == NULL)

+		return (s);

+

+	return (++p);

+}

+

+/* Agent creation / destruction routines */

+

+pydb_agent_t *

+pydb_agent_create(struct ps_prochandle *P, int vers)

+{

+	pydb_agent_t *py;

+	int datamodel;

+

+	if (vers != PYDB_VERSION) {

+		errno = ENOTSUP;

+		return (NULL);

+	}

+

+	if (ps_pdmodel(P, &datamodel) != PS_OK) {

+		return (NULL);

+	}

+

+	py = (pydb_agent_t *)malloc(sizeof (pydb_agent_t));

+	if (py == NULL) {

+		return (NULL);

+	}

+

+	py->pdb_ph = P;

+	py->pdb_vers = vers;

+	py->pdb_datamodel = datamodel;

+	py->pdb_is_64bit = 0;

+	py->pdb_ops = &arch_ops_native;

+

+#if defined (_LP64)

+	py->pdb_is_64bit = (datamodel == PR_MODEL_LP64);

+	if (!py->pdb_is_64bit) {

+		py->pdb_ops = &arch_ops_32;

+	}

+#endif /* _LP64 */

+

+	return (py);

+}

+

+void

+pydb_agent_destroy(pydb_agent_t *py)

+{

+	if (py == NULL) {

+		return;

+	}

+

+	free(py);

+}

+

+/* Helper functions */

+static int

+pydb_getlno(pydb_agent_t *py, uintptr_t lnotab_addr, int firstline,

+    int lastinst)

+{

+	unsigned char lnotab[4096];

+	ssize_t lnotab_len;

+	int addr, line;

+	int i;

+

+	lnotab_len = pydb_strobj_readdata(py, lnotab_addr, lnotab,

+	    sizeof (lnotab));

+	if (lnotab_len < 0) {

+		return (-1);

+	}

+

+	/*

+	 * Python's line number algorithm is arcane. See here for details:

+	 * http://svn.python.org/projects/python/trunk/Objects/lnotab_notes.txt

+	 */

+

+	line = firstline;

+	for (addr = i = 0; i < lnotab_len; i += 2) {

+		if (addr + lnotab[i] > lastinst) {

+			break;

+		}

+		addr += lnotab[i];

+		line += lnotab[i + 1];

+	}

+

+	return (line);

+}

+

+static ssize_t

+pydb_strobj_readdata(pydb_agent_t *py, uintptr_t addr, unsigned char *buf,

+    size_t buf_len)

+{

+	return (py->pdb_ops->strobj_readdata(py, addr, buf, buf_len));

+}

+

+static ssize_t

+pydb_strobj_readdata_native(pydb_agent_t *py, uintptr_t addr,

+    unsigned char *buf, size_t buf_len)

+{

+	PyBytesObject sobj;

+	ssize_t obj_sz;

+	ssize_t read_sz;

+	psaddr_t straddr;

+

+	/*

+	 * PyBytesObject are variable size.  The size of the PyBytesObject

+	 * struct is fixed, and known at compile time; however, the size of the

+	 * associated buffer is variable.  The char[1] element at the end of the

+	 * structure contains the string, and the ob_size of the PyBytesObject

+	 * indicates how much extra space was allocated to contain the string

+	 * buffer at the object's tail.  Read in the fixed size portion of the

+	 * object first, and then read the contents of the data buffer into the

+	 * buffer passed by the caller.

+	 */

+

+	if (ps_pread(py->pdb_ph, addr, &sobj, sizeof (PyBytesObject))

+	    != PS_OK) {

+		return (-1);

+	}

+

+	obj_sz = (ssize_t)PyString_GET_SIZE(&sobj);

+

+	read_sz = MIN(obj_sz, (ssize_t)buf_len);

+	straddr = (psaddr_t)(addr + offsetof(PyBytesObject, ob_sval));

+

+	if (ps_pread(py->pdb_ph, straddr, buf, (size_t)read_sz) != PS_OK) {

+		return (-1);

+	}

+

+	return (read_sz);

+}

+

+#if defined(_LP64)

+static ssize_t

+pydb_strobj_readdata_32(pydb_agent_t *py, uintptr_t addr,

+    unsigned char *buf, size_t buf_len)

+{

+	PyBytesObject32 sobj;

+	ssize_t obj_sz;

+	ssize_t read_sz;

+	psaddr_t straddr;

+

+	/*

+	 * PyBytesObject are variable size.  The size of the PyBytesObject

+	 * struct is fixed, and known at compile time; however, the size of the

+	 * associated buffer is variable.  The char[1] element at the end of the

+	 * structure contains the string, and the ob_size of the PyBytesObject

+	 * indicates how much extra space was allocated to contain the string

+	 * buffer at the object's tail.  Read in the fixed size portion of the

+	 * object first, and then read the contents of the data buffer into the

+	 * buffer passed by the caller.

+	 */

+

+	if (ps_pread(py->pdb_ph, addr, &sobj, sizeof (PyBytesObject32))

+	    != PS_OK) {

+		return (-1);

+	}

+

+	obj_sz = (ssize_t)PyString_GET_SIZE32(&sobj);

+

+	read_sz = MIN(obj_sz, (ssize_t)buf_len);

+	straddr = (psaddr_t)(addr + offsetof(PyBytesObject32, ob_sval));

+

+	if (ps_pread(py->pdb_ph, straddr, buf, (size_t)read_sz) != PS_OK) {

+		return (-1);

+	}

+

+	return (read_sz);

+}

+#endif /* _LP64 */

+

+/*

+ * Most Python PyBytesObject contain strings, as one would expect.  However,

+ * due to some sleazy hackery in parts of the Python code, some string objects

+ * are used as buffers for binary data.  In the general case,

+ * pydb_strobj_readstr() should be used to read strings out of string objects.

+ * It wraps pydb_strobj_readdata(), which should be used by callers only when

+ * trying to retrieve binary data.  (This routine does some string cleanup).

+ */

+static ssize_t

+pydb_strobj_readstr(pydb_agent_t *py, uintptr_t addr, char *buf,

+    size_t buf_len)

+{

+	ssize_t read_sz;

+

+	read_sz = pydb_strobj_readdata(py, addr, (unsigned char *)buf, buf_len);

+

+	if (read_sz >= 0) {

+		if (read_sz >= buf_len) {

+			read_sz = buf_len - 1;

+		}

+

+		buf[read_sz] = '\0';

+	}

+

+	return (read_sz);

+}

+

+

+static int

+pydb_frameinfo(pydb_agent_t *py, uintptr_t addr, char *funcnm,

+    size_t funcnm_sz, char *filenm, size_t filenm_sz, int *lineno)

+{

+	return (py->pdb_ops->frameinfo(py, addr, funcnm, funcnm_sz,

+	    filenm, filenm_sz, lineno));

+}

+

+static int

+pydb_frameinfo_native(pydb_agent_t *py, uintptr_t addr, char *funcnm,

+    size_t funcnm_sz, char *filenm, size_t filenm_sz, int *lineno)

+{

+	PyFrameObject fo;

+	PyCodeObject co;

+	ssize_t rc;

+

+	if (ps_pread(py->pdb_ph, addr, &fo, sizeof (PyFrameObject))

+	    != PS_OK) {

+		return (-1);

+	}

+

+	if (ps_pread(py->pdb_ph, (uintptr_t)fo.f_code, &co,

+	    sizeof (PyCodeObject)) != PS_OK) {

+		return (-1);

+	}

+

+	rc = pydb_strobj_readstr(py, (uintptr_t)co.co_name, funcnm, funcnm_sz);

+	if (rc < 0) {

+		return (-1);

+	}

+

+	rc = pydb_strobj_readstr(py, (uintptr_t)co.co_filename, filenm,

+	    filenm_sz);

+	if (rc < 0) {

+		return (-1);

+	}

+

+	*lineno = pydb_getlno(py, (uintptr_t)co.co_lnotab, co.co_firstlineno,

+	    fo.f_lasti);

+	if (*lineno < 0) {

+		return (-1);

+	}

+

+	return (0);

+}

+

+#if defined (_LP64)

+static int

+pydb_frameinfo_32(pydb_agent_t *py, uintptr_t addr, char *funcnm,

+    size_t funcnm_sz, char *filenm, size_t filenm_sz, int *lineno)

+{

+	PyFrameObject32 fo;

+	PyCodeObject32 co;

+	ssize_t rc;

+

+	if (ps_pread(py->pdb_ph, addr, &fo, sizeof (PyFrameObject32))

+	    != PS_OK) {

+		return (-1);

+	}

+

+	if (ps_pread(py->pdb_ph, (uintptr_t)fo.f_code, &co,

+	    sizeof (PyCodeObject32)) != PS_OK) {

+		return (-1);

+	}

+

+	rc = pydb_strobj_readstr(py, (uintptr_t)co.co_name, funcnm, funcnm_sz);

+	if (rc < 0) {

+		return (-1);

+	}

+

+	rc = pydb_strobj_readstr(py, (uintptr_t)co.co_filename, filenm,

+	    filenm_sz);

+	if (rc < 0) {

+		return (-1);

+	}