GDB (xrefs)
Loading...
Searching...
No Matches
py-linetable.c
Go to the documentation of this file.
1/* Python interface to line tables.
2
3 Copyright (C) 2013-2023 Free Software Foundation, Inc.
4
5 This file is part of GDB.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20#include "defs.h"
21#include "python-internal.h"
22
24 PyObject_HEAD
25 /* The line table source line. */
26 int line;
27 /* The pc associated with the source line. */
28 CORE_ADDR pc;
29};
30
31extern PyTypeObject linetable_entry_object_type
32 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("linetable_entry_object");
33
35 PyObject_HEAD
36 /* The symtab python object. We store the Python object here as the
37 underlying symtab can become invalid, and we have to run validity
38 checks on it. */
40};
41
42extern PyTypeObject linetable_object_type
44
46 PyObject_HEAD
47 /* The current entry in the line table for the iterator */
49 /* Pointer back to the original source line table object. Needed to
50 check if the line table is still valid, and has not been invalidated
51 when an object file has been freed. */
53};
54
55extern PyTypeObject ltpy_iterator_object_type
56 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("ltpy_iterator_object");
57
58/* Internal helper function to extract gdb.Symtab from a gdb.LineTable
59 object. */
60
61static PyObject *
63{
65
66 return lt->symtab;
67}
68
69#define LTPY_REQUIRE_VALID(lt_obj, symtab) \
70 do { \
71 symtab = symtab_object_to_symtab (get_symtab (lt_obj)); \
72 if (symtab == NULL) \
73 { \
74 PyErr_SetString (PyExc_RuntimeError, \
75 _("Symbol Table in line table is invalid."));\
76 return NULL; \
77 } \
78 } while (0)
79
80
81/* Helper function to create a line table object that wraps a
82 gdb.Symtab object. */
83
86{
87 linetable_object *ltable;
88
89 ltable = PyObject_New (linetable_object, &linetable_object_type);
90 if (ltable != NULL)
91 {
92 ltable->symtab = symtab;
93 Py_INCREF (symtab);
94 }
95 return (PyObject *) ltable;
96}
97
98/* Internal helper function to build a line table object from a line
99 and an address. */
100
101static PyObject *
102build_linetable_entry (int line, CORE_ADDR address)
103{
105
106 obj = PyObject_New (linetable_entry_object,
108 if (obj != NULL)
109 {
110 obj->line = line;
111 obj->pc = address;
112 }
113
114 return (PyObject *) obj;
115}
116
117/* Internal helper function to build a Python Tuple from a vector.
118 A line table entry can have multiple PCs for a given source line.
119 Construct a Tuple of all entries for the given source line, LINE
120 from the line table PCS. Construct one line table entry object per
121 address. */
122
123static PyObject *
124build_line_table_tuple_from_pcs (int line, const std::vector<CORE_ADDR> &pcs)
125{
126 int i;
127
128 if (pcs.size () < 1)
129 Py_RETURN_NONE;
130
131 gdbpy_ref<> tuple (PyTuple_New (pcs.size ()));
132
133 if (tuple == NULL)
134 return NULL;
135
136 for (i = 0; i < pcs.size (); ++i)
137 {
138 CORE_ADDR pc = pcs[i];
139 gdbpy_ref<> obj (build_linetable_entry (line, pc));
140
141 if (obj == NULL)
142 return NULL;
143 else if (PyTuple_SetItem (tuple.get (), i, obj.release ()) != 0)
144 return NULL;
145 }
146
147 return tuple.release ();
148}
149
150/* Implementation of gdb.LineTable.line (self) -> Tuple. Returns a
151 tuple of LineTableEntry objects associated with this line from the
152 in the line table. */
153
154static PyObject *
156{
157 struct symtab *symtab;
158 gdb_py_longest py_line;
159 struct linetable_entry *best_entry = NULL;
160 std::vector<CORE_ADDR> pcs;
161
163
164 if (! PyArg_ParseTuple (args, GDB_PY_LL_ARG, &py_line))
165 return NULL;
166
167 try
168 {
169 pcs = find_pcs_for_symtab_line (symtab, py_line, &best_entry);
170 }
171 catch (const gdb_exception &except)
172 {
174 }
175
176 return build_line_table_tuple_from_pcs (py_line, pcs);
177}
178
179/* Implementation of gdb.LineTable.has_line (self, line) -> Boolean.
180 Returns a Python Boolean indicating whether a source line has any
181 line table entries corresponding to it. */
182
183static PyObject *
185{
186 struct symtab *symtab;
187 gdb_py_longest py_line;
188 int index;
189
191
192 if (! PyArg_ParseTuple (args, GDB_PY_LL_ARG, &py_line))
193 return NULL;
194
195 if (symtab->linetable () == NULL)
196 {
197 PyErr_SetString (PyExc_RuntimeError,
198 _("Linetable information not found in symbol table"));
199 return NULL;
200 }
201
202 for (index = 0; index < symtab->linetable ()->nitems; index++)
203 {
204 struct linetable_entry *item = &(symtab->linetable ()->item[index]);
205 if (item->line == py_line)
206 Py_RETURN_TRUE;
207 }
208
209 Py_RETURN_FALSE;
210}
211
212/* Implementation of gdb.LineTable.source_lines (self) -> List.
213 Returns a Python List that contains source line entries in the
214 line table. This function will just return the source lines
215 without corresponding addresses. */
216
217static PyObject *
219{
220 struct symtab *symtab;
221 Py_ssize_t index;
222 struct linetable_entry *item;
223
225
226 if (symtab->linetable () == NULL)
227 {
228 PyErr_SetString (PyExc_RuntimeError,
229 _("Linetable information not found in symbol table"));
230 return NULL;
231 }
232
233 gdbpy_ref<> source_dict (PyDict_New ());
234 if (source_dict == NULL)
235 return NULL;
236
237 for (index = 0; index < symtab->linetable ()->nitems; index++)
238 {
239 item = &(symtab->linetable ()->item[index]);
240
241 /* 0 is used to signify end of line table information. Do not
242 include in the source set. */
243 if (item->line > 0)
244 {
246
247 if (line == NULL)
248 return NULL;
249
250 if (PyDict_SetItem (source_dict.get (), line.get (), Py_None) == -1)
251 return NULL;
252 }
253 }
254
255 return PyDict_Keys (source_dict.get ());
256}
257
258/* Implementation of gdb.LineTable.is_valid (self) -> Boolean.
259 Returns True if this line table object still exists in GDB. */
260
261static PyObject *
263{
264 struct symtab *symtab = NULL;
265
267
268 if (symtab == NULL)
269 Py_RETURN_FALSE;
270
271 Py_RETURN_TRUE;
272}
273
274/* Deconstructor for the line table object. Decrement the reference
275 to the symbol table object before calling the default free. */
276
277static void
279{
280 linetable_object *obj = (linetable_object *) self;
281
282 Py_DECREF (obj->symtab);
283 Py_TYPE (self)->tp_free (self);
284}
285
286/* Initialize LineTable, LineTableEntry and LineTableIterator
287 objects. */
288
289int
291{
292 if (PyType_Ready (&linetable_object_type) < 0)
293 return -1;
294 if (PyType_Ready (&linetable_entry_object_type) < 0)
295 return -1;
296 if (PyType_Ready (&ltpy_iterator_object_type) < 0)
297 return -1;
298
299 Py_INCREF (&linetable_object_type);
300 Py_INCREF (&linetable_entry_object_type);
301 Py_INCREF (&ltpy_iterator_object_type);
302
303 if (gdb_pymodule_addobject (gdb_module, "LineTable",
305 return -1;
306
307 if (gdb_pymodule_addobject (gdb_module, "LineTableEntry",
309 return -1;
310
311 if (gdb_pymodule_addobject (gdb_module, "LineTableIterator",
313 return -1;
314
315 return 0;
316}
317
318/* LineTable entry object get functions. */
319
320/* Implementation of gdb.LineTableEntry.line (self) -> Long. Returns
321 a long integer associated with the line table entry. */
322
323static PyObject *
324ltpy_entry_get_line (PyObject *self, void *closure)
325{
327
328 return gdb_py_object_from_longest (obj->line).release ();
329}
330
331/* Implementation of gdb.LineTableEntry.pc (self) -> Long. Returns a
332 a long integer associated with the PC of the line table entry. */
333
334static PyObject *
335ltpy_entry_get_pc (PyObject *self, void *closure)
336{
338
339 return gdb_py_object_from_ulongest (obj->pc).release ();
340}
341
342/* LineTable iterator functions. */
343
344/* Return a new line table iterator. */
345
346static PyObject *
348{
349 ltpy_iterator_object *ltpy_iter_obj;
350 struct symtab *symtab = NULL;
351
353
354 ltpy_iter_obj = PyObject_New (ltpy_iterator_object,
356 if (ltpy_iter_obj == NULL)
357 return NULL;
358
359 ltpy_iter_obj->current_index = 0;
360 ltpy_iter_obj->source = self;
361
362 Py_INCREF (self);
363 return (PyObject *) ltpy_iter_obj;
364}
365
366static void
368{
369 ltpy_iterator_object *iter_obj = (ltpy_iterator_object *) obj;
370
371 Py_DECREF (iter_obj->source);
372 Py_TYPE (obj)->tp_free (obj);
373}
374
375/* Return a reference to the line table iterator. */
376
377static PyObject *
379{
380 ltpy_iterator_object *iter_obj = (ltpy_iterator_object *) self;
381 struct symtab *symtab;
382
383 LTPY_REQUIRE_VALID (iter_obj->source, symtab);
384
385 Py_INCREF (self);
386 return self;
387}
388
389/* Return the next line table entry in the iteration through the line
390 table data structure. */
391
392static PyObject *
394{
395 ltpy_iterator_object *iter_obj = (ltpy_iterator_object *) self;
396 struct symtab *symtab;
397 PyObject *obj;
398 struct linetable_entry *item;
399
400 LTPY_REQUIRE_VALID (iter_obj->source, symtab);
401
402 if (iter_obj->current_index >= symtab->linetable ()->nitems)
403 {
404 PyErr_SetNone (PyExc_StopIteration);
405 return NULL;
406 }
407
408 item = &(symtab->linetable ()->item[iter_obj->current_index]);
409
410 /* Skip over internal entries such as 0. 0 signifies the end of
411 line table data and is not useful to the API user. */
412 while (item->line < 1)
413 {
414 iter_obj->current_index++;
415
416 /* Exit if the internal value is the last item in the line table. */
417 if (iter_obj->current_index >= symtab->linetable ()->nitems)
418 {
419 PyErr_SetNone (PyExc_StopIteration);
420 return NULL;
421 }
422 item = &(symtab->linetable ()->item[iter_obj->current_index]);
423 }
424
425 obj = build_linetable_entry (item->line, item->pc);
426 iter_obj->current_index++;
427
428 return obj;
429}
430
431/* Implementation of gdb.LineTableIterator.is_valid (self) -> Boolean.
432 Returns True if this line table iterator object still exists in
433 GDB. */
434
435static PyObject *
437{
438 struct symtab *symtab = NULL;
439 ltpy_iterator_object *iter_obj = (ltpy_iterator_object *) self;
440
442
443 if (symtab == NULL)
444 Py_RETURN_FALSE;
445
446 Py_RETURN_TRUE;
447}
448
449
450
451static PyMethodDef linetable_object_methods[] = {
452 { "line", ltpy_get_pcs_for_line, METH_VARARGS,
453 "line (lineno) -> Tuple\n\
454Return executable locations for a given source line." },
455 { "has_line", ltpy_has_line, METH_VARARGS,
456 "has_line (lineno) -> Boolean\n\
457Return TRUE if this line has executable information, FALSE if not." },
458 { "source_lines", ltpy_get_all_source_lines, METH_NOARGS,
459 "source_lines () -> List\n\
460Return a list of all executable source lines." },
461 { "is_valid", ltpy_is_valid, METH_NOARGS,
462 "is_valid () -> Boolean.\n\
463Return True if this LineTable is valid, False if not." },
464 {NULL} /* Sentinel */
465};
466
467PyTypeObject linetable_object_type = {
468 PyVarObject_HEAD_INIT (NULL, 0)
469 "gdb.LineTable", /*tp_name*/
470 sizeof (linetable_object), /*tp_basicsize*/
471 0, /*tp_itemsize*/
472 ltpy_dealloc, /*tp_dealloc*/
473 0, /*tp_print*/
474 0, /*tp_getattr*/
475 0, /*tp_setattr*/
476 0, /*tp_compare*/
477 0, /*tp_repr*/
478 0, /*tp_as_number*/
479 0, /*tp_as_sequence*/
480 0, /*tp_as_mapping*/
481 0, /*tp_hash */
482 0, /*tp_call*/
483 0, /*tp_str*/
484 0, /*tp_getattro*/
485 0, /*tp_setattro*/
486 0, /*tp_as_buffer*/
487 Py_TPFLAGS_DEFAULT, /*tp_flags*/
488 "GDB line table object", /* tp_doc */
489 0, /* tp_traverse */
490 0, /* tp_clear */
491 0, /* tp_richcompare */
492 0, /* tp_weaklistoffset */
493 ltpy_iter, /* tp_iter */
494 0, /* tp_iternext */
495 linetable_object_methods, /* tp_methods */
496 0, /* tp_members */
497 0, /* tp_getset */
498 0, /* tp_base */
499 0, /* tp_dict */
500 0, /* tp_descr_get */
501 0, /* tp_descr_set */
502 0, /* tp_dictoffset */
503 0, /* tp_init */
504 0, /* tp_alloc */
505};
506
507static PyMethodDef ltpy_iterator_methods[] = {
508 { "is_valid", ltpy_iter_is_valid, METH_NOARGS,
509 "is_valid () -> Boolean.\n\
510Return True if this LineTable iterator is valid, False if not." },
511 {NULL} /* Sentinel */
512};
513
515 PyVarObject_HEAD_INIT (NULL, 0)
516 "gdb.LineTableIterator", /*tp_name*/
517 sizeof (ltpy_iterator_object), /*tp_basicsize*/
518 0, /*tp_itemsize*/
519 ltpy_iterator_dealloc, /*tp_dealloc*/
520 0, /*tp_print*/
521 0, /*tp_getattr*/
522 0, /*tp_setattr*/
523 0, /*tp_compare*/
524 0, /*tp_repr*/
525 0, /*tp_as_number*/
526 0, /*tp_as_sequence*/
527 0, /*tp_as_mapping*/
528 0, /*tp_hash */
529 0, /*tp_call*/
530 0, /*tp_str*/
531 0, /*tp_getattro*/
532 0, /*tp_setattro*/
533 0, /*tp_as_buffer*/
534 Py_TPFLAGS_DEFAULT, /*tp_flags*/
535 "GDB line table iterator object", /*tp_doc */
536 0, /*tp_traverse */
537 0, /*tp_clear */
538 0, /*tp_richcompare */
539 0, /*tp_weaklistoffset */
540 ltpy_iterator, /*tp_iter */
541 ltpy_iternext, /*tp_iternext */
542 ltpy_iterator_methods /*tp_methods */
543};
544
545
547 { "line", ltpy_entry_get_line, NULL,
548 "The line number in the source file.", NULL },
549 { "pc", ltpy_entry_get_pc, NULL,
550 "The memory address for this line number.", NULL },
551 { NULL } /* Sentinel */
552};
553
555 PyVarObject_HEAD_INIT (NULL, 0)
556 "gdb.LineTableEntry", /*tp_name*/
557 sizeof (linetable_entry_object), /*tp_basicsize*/
558 0, /*tp_itemsize*/
559 0, /*tp_dealloc*/
560 0, /*tp_print*/
561 0, /*tp_getattr*/
562 0, /*tp_setattr*/
563 0, /*tp_compare*/
564 0, /*tp_repr*/
565 0, /*tp_as_number*/
566 0, /*tp_as_sequence*/
567 0, /*tp_as_mapping*/
568 0, /*tp_hash */
569 0, /*tp_call*/
570 0, /*tp_str*/
571 0, /*tp_getattro*/
572 0, /*tp_setattro*/
573 0, /*tp_as_buffer*/
574 Py_TPFLAGS_DEFAULT, /*tp_flags*/
575 "GDB line table entry object", /* tp_doc */
576 0, /* tp_traverse */
577 0, /* tp_clear */
578 0, /* tp_richcompare */
579 0, /* tp_weaklistoffset */
580 0, /* tp_iter */
581 0, /* tp_iternext */
582 0, /* tp_methods */
583 0, /* tp_members */
584 linetable_entry_object_getset, /* tp_getset */
585 0, /* tp_base */
586 0, /* tp_dict */
587 0, /* tp_descr_get */
588 0, /* tp_descr_set */
589 0, /* tp_dictoffset */
590 0, /* tp_init */
591 0, /* tp_alloc */
592};
@ lt
Definition 1.cc:35
static PyObject * ltpy_entry_get_pc(PyObject *self, void *closure)
static PyObject * ltpy_iterator(PyObject *self)
#define LTPY_REQUIRE_VALID(lt_obj, symtab)
PyObject * symtab_to_linetable_object(PyObject *symtab)
static void ltpy_dealloc(PyObject *self)
PyTypeObject linetable_object_type
static void ltpy_iterator_dealloc(PyObject *obj)
static PyMethodDef ltpy_iterator_methods[]
static PyObject * ltpy_get_all_source_lines(PyObject *self, PyObject *args)
static PyObject * get_symtab(PyObject *linetable)
static gdb_PyGetSetDef linetable_entry_object_getset[]
static PyObject * ltpy_iter(PyObject *self)
static PyObject * ltpy_get_pcs_for_line(PyObject *self, PyObject *args)
static PyObject * build_linetable_entry(int line, CORE_ADDR address)
static PyObject * ltpy_is_valid(PyObject *self, PyObject *args)
static PyObject * ltpy_iter_is_valid(PyObject *self, PyObject *args)
static PyMethodDef linetable_object_methods[]
static PyObject * ltpy_entry_get_line(PyObject *self, void *closure)
static PyObject * ltpy_has_line(PyObject *self, PyObject *args)
static PyObject * ltpy_iternext(PyObject *self)
PyTypeObject linetable_entry_object_type
PyTypeObject ltpy_iterator_object_type
static PyObject * build_line_table_tuple_from_pcs(int line, const std::vector< CORE_ADDR > &pcs)
int gdbpy_initialize_linetable(void)
gdb::ref_ptr< T, gdbpy_ref_policy< T > > gdbpy_ref
Definition py-ref.h:43
struct symtab * symtab_object_to_symtab(PyObject *obj)
Definition py-symtab.c:505
gdbpy_ref gdb_py_object_from_longest(LONGEST l)
Definition py-utils.c:279
int gdb_pymodule_addobject(PyObject *module, const char *name, PyObject *object)
Definition py-utils.c:331
gdbpy_ref gdb_py_object_from_ulongest(ULONGEST l)
Definition py-utils.c:290
PyObject * gdb_module
long gdb_py_longest
#define CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF(ARG)
#define GDB_PY_LL_ARG
#define GDB_PY_HANDLE_EXCEPTION(Exception)
PyObject_HEAD int line
CORE_ADDR pc
Definition symtab.h:1548
int line
Definition symtab.h:1550
CORE_ADDR pc
Definition symtab.h:1560
PyObject_HEAD PyObject * symtab
int nitems
Definition symtab.h:1582
struct linetable_entry item[1]
Definition symtab.h:1587
PyObject_HEAD int current_index
struct linetable * linetable() const
Definition symtab.h:1613
std::vector< CORE_ADDR > find_pcs_for_symtab_line(struct symtab *symtab, int line, struct linetable_entry **best_item)
Definition symtab.c:3432
int PyObject
Definition varobj.c:41