| blob | b0dc914cde71e58c7d5314f67badff3e41abe90f |
1 This patch adds Python debugger support. It may be contributed upstream at
2 some point, but the suitability (or lack thereof) has not yet been determined.
4 --- Python-3.7.5/Makefile.pre.in
5 +++ Python-3.7.5/Makefile.pre.in
6 @@ -462,7 +462,7 @@ DTRACE_DEPS = \
7 # Default target
8 all: @DEF_MAKE_ALL_RULE@
9 build_all: check-clean-src $(BUILDPYTHON) oldsharedmods sharedmods gdbhooks \
10 - Programs/_testembed python-config
11 + Programs/_testembed python-config build-py_db
13 # Check that the source is clean when building out of source.
14 check-clean-src:
15 @@ -706,6 +706,15 @@ Makefile Modules/config.c: Makefile.pre
16 @mv config.c Modules
17 @echo "The Makefile was updated, you may need to re-run make."
19 +SHLIB_FLAGS = -shared -fpic
20 +
21 +libpython$(LDVERSION)_db.so.1.0: $(srcdir)/py_db/libpython37_db.c
22 + $(CC) -o $@ $(CFLAGS) $(PY_CPPFLAGS) $(CPPFLAGS) $(SHLIB_FLAGS) $<
23 +
24 +build-py_db: libpython$(LDVERSION)_db.so.1.0
25 +
26 +install-py_db: libpython$(LDVERSION)_db.so.1.0
27 + $(INSTALL_SHARED) libpython$(LDVERSION)_db.so.1.0 $(DESTDIR)$(LIBDIR)
29 Modules/Setup: $(srcdir)/Modules/Setup.dist
30 @if test -f Modules/Setup; then \
31 @@ -1129,7 +1138,7 @@ multisslcompile: build_all
32 multissltest: build_all
33 $(RUNSHARED) ./$(BUILDPYTHON) Tools/ssl/multissltests.py
35 -install: @FRAMEWORKINSTALLFIRST@ commoninstall bininstall maninstall @FRAMEWORKINSTALLLAST@
36 +install: @FRAMEWORKINSTALLFIRST@ commoninstall bininstall maninstall install-py_db @FRAMEWORKINSTALLLAST@
37 if test "x$(ENSUREPIP)" != "xno" ; then \
38 case $(ENSUREPIP) in \
39 upgrade) ensurepip="--upgrade" ;; \
40 --- Python-3.7.5/py_db/libpython37_db.c
41 +++ Python-3.7.5/py_db/libpython37_db.c
42 @@ -0,0 +1,595 @@
43 +/*
44 + * CDDL HEADER START
45 + *
46 + * The contents of this file are subject to the terms of the
47 + * Common Development and Distribution License (the "License").
48 + * You may not use this file except in compliance with the License.
49 + *
50 + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
51 + * or http://www.opensolaris.org/os/licensing.
52 + * See the License for the specific language governing permissions
53 + * and limitations under the License.
54 + *
55 + * When distributing Covered Code, include this CDDL HEADER in each
56 + * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
57 + * If applicable, add the following below this CDDL HEADER, with the
58 + * fields enclosed by brackets "[]" replaced with your own identifying
59 + * information: Portions Copyright [yyyy] [name of copyright owner]
60 + *
61 + * CDDL HEADER END
62 + */
63 +/*
64 + * Copyright (c) 2012, 2020, Oracle and/or its affiliates.
65 + */
66 +
67 +#include <stdio.h>
68 +#include <stdlib.h>
69 +#include <string.h>
70 +#include <errno.h>
71 +#include <gelf.h>
72 +
73 +#define Py_BUILD_CORE
74 +
75 +#include <Python.h>
76 +#include <frameobject.h>
77 +#include "internal/pystate.h"
78 +
79 +#include "libpython37_db.h"
80 +
81 +struct pydb_agent {
82 + struct ps_prochandle *pdb_ph;
83 + int pdb_vers;
84 + int pdb_is_64bit;
85 + int pdb_datamodel;
86 +};
87 +
88 +typedef uintptr_t (*pdi_next_cb_t)(pydb_iter_t *);
89 +
90 +struct pydb_iter {
91 + struct ps_prochandle *pdi_ph;
92 + uintptr_t pdi_current;
93 + pdi_next_cb_t pdi_nextf;
94 +};
95 +
96 +#define LIBPYTHON "libpython3.7m.so"
97 +
98 +#define MIN(x, y) (((x) < (y)) ? (x) : (y))
99 +
100 +/* Generic interface to helper functions */
101 +static ssize_t pydb_strobj_readdata(pydb_agent_t *py, uintptr_t addr,
102 + unsigned char *buf, size_t buf_len);
103 +static int pydb_getlno(pydb_agent_t *py, uintptr_t lnotab_addr, int firstline,
104 + int lastinst);
105 +static int pydb_frameinfo(pydb_agent_t *py, uintptr_t addr, char *funcnm,
106 + size_t funcnm_sz, char *filenm, size_t filenm_sz, int *lineno);
107 +
108 +/* datamodel specific implementation of helper functions */
109 +static ssize_t pydb_strobj_readdata_native(pydb_agent_t *py, uintptr_t addr,
110 + unsigned char *buf, size_t buf_len);
111 +static int pydb_frameinfo_native(pydb_agent_t *py, uintptr_t addr, char *funcnm,
112 + size_t funcnm_sz, char *filenm, size_t filenm_sz, int *lineno);
113 +
114 +static ssize_t pydb_strobj_readstr(pydb_agent_t *py, uintptr_t addr, char *buf,
115 + size_t len);
116 +
117 +/* Iterator function next routines. Plugable, configured by iterator init */
118 +static uintptr_t pydb_frame_iter_next(pydb_iter_t *iter);
119 +static uintptr_t pydb_interp_iter_next(pydb_iter_t *iter);
120 +static uintptr_t pydb_thread_iter_next(pydb_iter_t *iter);
121 +
122 +static const char *strbasename(const char *s);
123 +
124 +static const char *
125 +strbasename(const char *s)
126 +{
127 + const char *p = strrchr(s, '/');
128 +
129 + if (p == NULL)
130 + return (s);
131 +
132 + return (++p);
133 +}
134 +
135 +/* Agent creation / destruction routines */
136 +
137 +pydb_agent_t *
138 +pydb_agent_create(struct ps_prochandle *P, int vers)
139 +{
140 + pydb_agent_t *py;
141 + int datamodel;
142 +
143 + if (vers != PYDB_VERSION) {
144 + errno = ENOTSUP;
145 + return (NULL);
146 + }
147 +
148 + if (ps_pdmodel(P, &datamodel) != PS_OK) {
149 + return (NULL);
150 + }
151 +
152 + py = (pydb_agent_t *)malloc(sizeof (pydb_agent_t));
153 + if (py == NULL) {
154 + return (NULL);
155 + }
156 +
157 + py->pdb_ph = P;
158 + py->pdb_vers = vers;
159 + py->pdb_datamodel = datamodel;
160 + py->pdb_is_64bit = 0;
161 +
162 + return (py);
163 +}
164 +
165 +void
166 +pydb_agent_destroy(pydb_agent_t *py)
167 +{
168 + if (py == NULL) {
169 + return;
170 + }
171 +
172 + free(py);
173 +}
174 +
175 +/* Helper functions */
176 +static int
177 +pydb_getlno(pydb_agent_t *py, uintptr_t lnotab_addr, int firstline,
178 + int lastinst)
179 +{
180 + unsigned char lnotab[4096];
181 + ssize_t lnotab_len;
182 + int addr, line;
183 + int i;
184 +
185 + lnotab_len = pydb_strobj_readdata(py, lnotab_addr, lnotab,
186 + sizeof (lnotab));
187 + if (lnotab_len < 0) {
188 + return (-1);
189 + }
190 +
191 + /*
192 + * Python's line number algorithm is arcane. See here for details:
193 + * http://svn.python.org/projects/python/trunk/Objects/lnotab_notes.txt
194 + */
195 +
196 + line = firstline;
197 + for (addr = i = 0; i < lnotab_len; i += 2) {
198 + if (addr + lnotab[i] > lastinst) {
199 + break;
200 + }
201 + addr += lnotab[i];
202 + line += lnotab[i + 1];
203 + }
204 +
205 + return (line);
206 +}
207 +
208 +static ssize_t
209 +pydb_asciiobj_readdata(pydb_agent_t *py, uintptr_t addr,
210 + unsigned char *buf, size_t buf_len)
211 +{
212 + PyASCIIObject sobj;
213 + ssize_t obj_sz;
214 + ssize_t read_sz;
215 + psaddr_t asciiaddr;
216 +
217 + /*
218 + * PyASCIIObjects are a type of Unicode string. They are identified
219 + * as follows:
220 + * - sobj.state.compact == 1
221 + * - sobj.state.ascii == 1
222 + * - sobj.state.ready == 1
223 + * The length of the string is stored in sobj.length. The string
224 + * itself follows the PyASCIIObject.
225 + */
226 +
227 + if (ps_pread(py->pdb_ph, addr, &sobj, sizeof (PyASCIIObject))
228 + != PS_OK) {
229 + return (-1);
230 + }
231 +
232 + if (!sobj.state.compact || !sobj.state.ascii || !sobj.state.ready) {
233 + return (-1);
234 + }
235 +
236 + obj_sz = (ssize_t)sobj.length;
237 +
238 + read_sz = MIN(obj_sz, (ssize_t)buf_len);
239 + asciiaddr = (psaddr_t)(addr + sizeof (PyASCIIObject));
240 +
241 + if (ps_pread(py->pdb_ph, asciiaddr, buf, (size_t)read_sz) != PS_OK) {
242 + return (-1);
243 + }
244 +
245 + return (read_sz);
246 +}
247 +
248 +static ssize_t
249 +pydb_asciiobj_readstr(pydb_agent_t *py, uintptr_t addr, char *buf,
250 + size_t buf_len)
251 +{
252 + ssize_t read_sz;
253 +
254 + read_sz = pydb_asciiobj_readdata(py, addr, (unsigned char *)buf,
255 + buf_len);
256 +
257 + if (read_sz >= 0) {
258 + if (read_sz >= buf_len) {
259 + read_sz = buf_len - 1;
260 + }
261 +
262 + buf[read_sz] = '\0';
263 + }
264 +
265 + return (read_sz);
266 +}
267 +
268 +static ssize_t
269 +pydb_strobj_readdata(pydb_agent_t *py, uintptr_t addr,
270 + unsigned char *buf, size_t buf_len)
271 +{
272 + PyBytesObject sobj;
273 + ssize_t obj_sz;
274 + ssize_t read_sz;
275 + psaddr_t straddr;
276 +
277 + /*
278 + * PyBytesObject are variable size. The size of the PyBytesObject
279 + * struct is fixed, and known at compile time; however, the size of the
280 + * associated buffer is variable. The char[1] element at the end of the
281 + * structure contains the string, and the ob_size of the PyBytesObject
282 + * indicates how much extra space was allocated to contain the string
283 + * buffer at the object's tail. Read in the fixed size portion of the
284 + * object first, and then read the contents of the data buffer into the
285 + * buffer passed by the caller.
286 + */
287 +
288 + if (ps_pread(py->pdb_ph, addr, &sobj, sizeof (PyBytesObject))
289 + != PS_OK) {
290 + return (-1);
291 + }
292 +
293 + /*
294 + * If we want to emulate PyBytes_GET_SIZE() instead of just calling
295 + * Py_SIZE() directly, we need to do a ps_pread() of Py_TYPE(&sobj).
296 + * PyBytes_Check() will try to access the type structure, but the
297 + * address is not in the debugger's address space.
298 + */
299 + obj_sz = (ssize_t)Py_SIZE(&sobj);
300 +
301 + read_sz = MIN(obj_sz, (ssize_t)buf_len);
302 + straddr = (psaddr_t)(addr + offsetof(PyBytesObject, ob_sval));
303 +
304 + if (ps_pread(py->pdb_ph, straddr, buf, (size_t)read_sz) != PS_OK) {
305 + return (-1);
306 + }
307 +
308 + return (read_sz);
309 +}
310 +
311 +/*
312 + * Most Python PyBytesObject contain strings, as one would expect. However,
313 + * due to some sleazy hackery in parts of the Python code, some string objects
314 + * are used as buffers for binary data. In the general case,
315 + * pydb_strobj_readstr() should be used to read strings out of string objects.
316 + * It wraps pydb_strobj_readdata(), which should be used by callers only when
317 + * trying to retrieve binary data. (This routine does some string cleanup).
318 + */
319 +static ssize_t
320 +pydb_strobj_readstr(pydb_agent_t *py, uintptr_t addr, char *buf,
321 + size_t buf_len)
322 +{
323 + ssize_t read_sz;
324 +
325 + read_sz = pydb_strobj_readdata(py, addr, (unsigned char *)buf, buf_len);
326 +
327 + if (read_sz >= 0) {
328 + if (read_sz >= buf_len) {
329 + read_sz = buf_len - 1;
330 + }
331 +
332 + buf[read_sz] = '\0';
333 + }
334 +
335 + return (read_sz);
336 +}
337 +
338 +
339 +static int
340 +pydb_frameinfo(pydb_agent_t *py, uintptr_t addr, char *funcnm,
341 + size_t funcnm_sz, char *filenm, size_t filenm_sz, int *lineno)
342 +{
343 + PyFrameObject fo;
344 + PyCodeObject co;
345 + ssize_t rc;
346 +
347 + if (ps_pread(py->pdb_ph, addr, &fo, sizeof (PyFrameObject))
348 + != PS_OK) {
349 + return (-1);
350 + }
351 +
352 + if (ps_pread(py->pdb_ph, (uintptr_t)fo.f_code, &co,
353 + sizeof (PyCodeObject)) != PS_OK) {
354 + return (-1);
355 + }
356 +
357 + rc = pydb_asciiobj_readstr(py, (uintptr_t)co.co_name, funcnm,
358 + funcnm_sz);
359 + if (rc < 0) {
360 + return (-1);
361 + }
362 +
363 + rc = pydb_asciiobj_readstr(py, (uintptr_t)co.co_filename, filenm,
364 + filenm_sz);
365 + if (rc < 0) {
366 + return (-1);
367 + }
368 +
369 + *lineno = pydb_getlno(py, (uintptr_t)co.co_lnotab, co.co_firstlineno,
370 + fo.f_lasti);
371 + if (*lineno < 0) {
372 + return (-1);
373 + }
374 +
375 + return (0);
376 +}
377 +
378 +/* Functions that are part of the library's interface */
379 +
380 +/*
381 + * Given the address of a PyFrameObject, and a buffer of a known size,
382 + * fill the buffer with a description of the frame.
383 + */
384 +int
385 +pydb_get_frameinfo(pydb_agent_t *py, uintptr_t frame_addr, char *fbuf,
386 + size_t bufsz, int verbose)
387 +{
388 + char funcname[1024];
389 + char filename[1024];
390 + char *fn;
391 + int lineno;
392 + int length = (py->pdb_is_64bit ? 16 : 8);
393 + int rc;
394 +
395 + rc = pydb_frameinfo(py, frame_addr, funcname, sizeof (funcname),
396 + filename, sizeof (filename), &lineno);
397 + if (rc < 0) {
398 + return (-1);
399 + }
400 +
401 + if (!verbose) {
402 + fn = (char *)strbasename(filename);
403 + } else {
404 + fn = filename;
405 + }
406 +
407 + (void) snprintf(fbuf, bufsz, "%0.*lx %s:%d %s()\n", length,
408 + frame_addr, fn, lineno, funcname);
409 +
410 + return (0);
411 +}
412 +
413 +/*
414 + * Return a description about a PyFrameObject, if the object is
415 + * actually a PyFrameObject. In this case, the pc argument is checked
416 + * to make sure that it came from a function that takes a PyFrameObject
417 + * as its first (argv[0]) argument.
418 + */
419 +int
420 +pydb_pc_frameinfo(pydb_agent_t *py, uintptr_t pc, uintptr_t frame_addr,
421 + char *fbuf, size_t bufsz)
422 +{
423 + char funcname[1024];
424 + char filename[1024];
425 + int lineno;
426 + int rc;
427 + ps_sym_t psym;
428 +
429 + /*
430 + * If PC doesn't match PyEval_EvalFrameEx in either libpython
431 + * or the executable, don't decode it.
432 + */
433 + if (ps_pglobal_sym(py->pdb_ph, LIBPYTHON, "PyEval_EvalFrameEx", &psym)
434 + != PS_OK) {
435 + return (-1);
436 + }
437 +
438 + /* If symbol found, ensure that PC falls within PyEval_EvalFrameEx. */
439 + if (pc < psym.st_value || pc > psym.st_value + psym.st_size) {
440 + return (-1);
441 + }
442 +
443 + rc = pydb_frameinfo(py, frame_addr, funcname, sizeof (funcname),
444 + filename, sizeof (filename), &lineno);
445 + if (rc < 0) {
446 + return (-1);
447 + }
448 +
449 + (void) snprintf(fbuf, bufsz, "[ %s:%d (%s) ]\n", filename, lineno,
450 + funcname);
451 +
452 + return (0);
453 +}
454 +
455 +/*
456 + * Walks the list of PyInterpreterState objects. If caller doesn't
457 + * supply address of list, this method will look it up.
458 + */
459 +pydb_iter_t *
460 +pydb_interp_iter_init(pydb_agent_t *py, uintptr_t addr)
461 +{
462 + pydb_iter_t *itr;
463 + _PyRuntimeState st;
464 + uintptr_t i_addr;
465 + int rc;
466 +
467 + if (addr == 0) {
468 + rc = ps_pglobal_lookup(py->pdb_ph, LIBPYTHON, "_PyRuntime",
469 + (psaddr_t *)&addr);
470 + if (rc != PS_OK) {
471 + return (NULL);
472 + }
473 +
474 + if (ps_pread(py->pdb_ph, (uintptr_t)addr, &st, sizeof (_PyRuntimeState))
475 + != PS_OK) {
476 + return (NULL);
477 + }
478 +
479 + i_addr = (uintptr_t)st.interpreters.head;
480 +
481 + } else {
482 + if (ps_pread(py->pdb_ph, (uintptr_t)addr, &i_addr, sizeof (uintptr_t))
483 + != PS_OK) {
484 + return (NULL);
485 + }
486 + }
487 +
488 + itr = malloc(sizeof (pydb_iter_t));
489 + if (itr == NULL) {
490 + return (NULL);
491 + }
492 +
493 + itr->pdi_ph = py->pdb_ph;
494 + itr->pdi_current = i_addr;
495 + itr->pdi_nextf = pydb_interp_iter_next;
496 +
497 + return (itr);
498 +}
499 +
500 +static uintptr_t
501 +pydb_interp_iter_next(pydb_iter_t *iter)
502 +{
503 + PyInterpreterState st;
504 + uintptr_t cur;
505 +
506 + cur = iter->pdi_current;
507 +
508 + if (cur == 0) {
509 + return (cur);
510 + }
511 +
512 + if (ps_pread(iter->pdi_ph, cur, &st, sizeof (PyInterpreterState))
513 + != PS_OK) {
514 + iter->pdi_current = 0;
515 + return (0);
516 + }
517 +
518 + iter->pdi_current = (uintptr_t)st.next;
519 +
520 + return (cur);
521 +}
522 +
523 +/*
524 + * Walk a list of Python PyFrameObjects. The addr argument must be
525 + * the address of a valid PyThreadState object.
526 + */
527 +pydb_iter_t *
528 +pydb_frame_iter_init(pydb_agent_t *py, uintptr_t addr)
529 +{
530 + pydb_iter_t *itr;
531 + PyThreadState ts;
532 +
533 + if (ps_pread(py->pdb_ph, (uintptr_t)addr, &ts, sizeof (PyThreadState))
534 + != PS_OK) {
535 + return (NULL);
536 + }
537 +
538 + itr = malloc(sizeof (pydb_iter_t));
539 + if (itr == NULL) {
540 + return (NULL);
541 + }
542 +
543 + itr->pdi_ph = py->pdb_ph;
544 + itr->pdi_current = (uintptr_t)ts.frame;
545 + itr->pdi_nextf = pydb_frame_iter_next;
546 +
547 + return (itr);
548 +}
549 +
550 +static uintptr_t
551 +pydb_frame_iter_next(pydb_iter_t *iter)
552 +{
553 + PyFrameObject fo;
554 + uintptr_t cur;
555 +
556 + cur = iter->pdi_current;
557 +
558 + if (cur == 0) {
559 + return (cur);
560 + }
561 +
562 + if (ps_pread(iter->pdi_ph, cur, &fo, sizeof (PyFrameObject))
563 + != PS_OK) {
564 + iter->pdi_current = 0;
565 + return (0);
566 + }
567 +
568 + iter->pdi_current = (uintptr_t)fo.f_back;
569 +
570 + return (cur);
571 +}
572 +
573 +/*
574 + * Walk a list of Python PyThreadState objects. The addr argument must be
575 + * the address of a valid PyInterpreterState object.
576 + */
577 +pydb_iter_t *
578 +pydb_thread_iter_init(pydb_agent_t *py, uintptr_t addr)
579 +{
580 + pydb_iter_t *itr;
581 + PyInterpreterState is;
582 +
583 + if (ps_pread(py->pdb_ph, (uintptr_t)addr, &is,
584 + sizeof (PyInterpreterState)) != PS_OK) {
585 + return (NULL);
586 + }
587 +
588 + itr = malloc(sizeof (pydb_iter_t));
589 + if (itr == NULL) {
590 + return (NULL);
591 + }
592 +
593 + itr->pdi_ph = py->pdb_ph;
594 + itr->pdi_current = (uintptr_t)is.tstate_head;
595 + itr->pdi_nextf = pydb_thread_iter_next;
596 +
597 + return (itr);
598 +}
599 +
600 +static uintptr_t
601 +pydb_thread_iter_next(pydb_iter_t *iter)
602 +{
603 + PyThreadState ts;
604 + uintptr_t cur;
605 +
606 + cur = iter->pdi_current;
607 +
608 + if (cur == 0) {
609 + return (cur);
610 + }
611 +
612 + if (ps_pread(iter->pdi_ph, cur, &ts, sizeof (PyThreadState)) != PS_OK) {
613 + iter->pdi_current = 0;
614 + return (0);
615 + }
616 +
617 + iter->pdi_current = (uintptr_t)ts.next;
618 +
619 + return (cur);
620 +}
621 +
622 +
623 +uintptr_t
624 +pydb_iter_next(pydb_iter_t *iter)
625 +{
626 + return (iter->pdi_nextf(iter));
627 +}
628 +
629 +void
630 +pydb_iter_fini(pydb_iter_t *iter)
631 +{
632 + if (iter == NULL) {
633 + return;
634 + }
635 +
636 + free(iter);
637 +}
638 --- Python-3.7.5/py_db/libpython37_db.h
639 +++ Python-3.7.5/py_db/libpython37_db.h
640 @@ -0,0 +1,73 @@
641 +/*
642 + * CDDL HEADER START
643 + *
644 + * The contents of this file are subject to the terms of the
645 + * Common Development and Distribution License (the "License").
646 + * You may not use this file except in compliance with the License.
647 + *
648 + * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
649 + * or http://www.opensolaris.org/os/licensing.
650 + * See the License for the specific language governing permissions
651 + * and limitations under the License.
652 + *
653 + * When distributing Covered Code, include this CDDL HEADER in each
654 + * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
655 + * If applicable, add the following below this CDDL HEADER, with the
656 + * fields enclosed by brackets "[]" replaced with your own identifying
657 + * information: Portions Copyright [yyyy] [name of copyright owner]
658 + *
659 + * CDDL HEADER END
660 + */
661 +/*
662 + * Copyright (c) 2012, 2020, Oracle and/or its affiliates.
663 + */
664 +
665 +#ifndef _LIBPYTHON37_DB_H
666 +#define _LIBPYTHON37_DB_H
667 +
668 +#include <proc_service.h>
669 +
670 +#ifdef __cplusplus
671 +extern "C" {
672 +#endif
673 +
674 +/* Agent is opaque to library's consumers. */
675 +typedef struct pydb_agent pydb_agent_t;
676 +
677 +/*
678 + * Library's debug version is 1. Changes to interface should increase this
679 + * number.
680 + */
681 +#define PYDB_VERSION 1
682 +
683 +/* Agent creation/destruction routines */
684 +extern pydb_agent_t *pydb_agent_create(struct ps_prochandle *P, int vers);
685 +extern void pydb_agent_destroy(pydb_agent_t *py);
686 +
687 +/* Used by callers that know they are looking at a PyFrameObject */
688 +extern int pydb_get_frameinfo(pydb_agent_t *py, uintptr_t frame_addr,
689 + char *fbuf, size_t bufsz, int verbose);
690 +
691 +/*
692 + * Used by callers that don't know if they're looking at PyFrameObject.
693 + * Checks PC for traceable functions.
694 + */
695 +extern int pydb_pc_frameinfo(pydb_agent_t *py, uintptr_t pc,
696 + uintptr_t frame_addr, char *fbuf, size_t bufsz);
697 +
698 +/* Iterator functions */
699 +typedef struct pydb_iter pydb_iter_t;
700 +
701 +extern pydb_iter_t *pydb_frame_iter_init(pydb_agent_t *py, uintptr_t addr);
702 +extern pydb_iter_t *pydb_interp_iter_init(pydb_agent_t *py,
703 + uintptr_t addr);
704 +extern pydb_iter_t *pydb_thread_iter_init(pydb_agent_t *py,
705 + uintptr_t addr);
706 +extern void pydb_iter_fini(pydb_iter_t *iter);
707 +extern uintptr_t pydb_iter_next(pydb_iter_t *iter);
708 +
709 +#ifdef __cplusplus
710 +}
711 +#endif
712 +
713 +#endif /* _LIBPYTHON37_DB_H */
714 --- Python-3.7.5/py_db/mapfile-vers
715 +++ Python-3.7.5/py_db/mapfile-vers
716 @@ -0,0 +1,39 @@
717 +#
718 +# CDDL HEADER START
719 +#
720 +# The contents of this file are subject to the terms of the
721 +# Common Development and Distribution License (the "License").
722 +# You may not use this file except in compliance with the License.
723 +#
724 +# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
725 +# or http://www.opensolaris.org/os/licensing.
726 +# See the License for the specific language governing permissions
727 +# and limitations under the License.
728 +#
729 +# When distributing Covered Code, include this CDDL HEADER in each
730 +# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
731 +# If applicable, add the following below this CDDL HEADER, with the
732 +# fields enclosed by brackets "[]" replaced with your own identifying
733 +# information: Portions Copyright [yyyy] [name of copyright owner]
734 +#
735 +# CDDL HEADER END
736 +#
737 +
738 +#
739 +# Copyright (c) 2012, 2020, Oracle and/or its affiliates.
740 +#
741 +
742 +SUNWprivate_1.1 {
743 + global:
744 + pydb_agent_create;
745 + pydb_agent_destroy;
746 + pydb_frame_iter_init;
747 + pydb_get_frameinfo;
748 + pydb_pc_frameinfo;
749 + pydb_interp_iter_init;
750 + pydb_thread_iter_init;
751 + pydb_iter_fini;
752 + pydb_iter_next;
753 + local:
754 + *;
755 +};