Sort objects in gdb and gdbserver Makefiles
[deliverable/binutils-gdb.git] / gdb / python / py-inferior.c
CommitLineData
595939de
PM
1/* Python interface to inferiors.
2
e2882c85 3 Copyright (C) 2009-2018 Free Software Foundation, Inc.
595939de
PM
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"
595939de
PM
21#include "gdbcore.h"
22#include "gdbthread.h"
23#include "inferior.h"
20c168b5 24#include "objfiles.h"
76727919 25#include "observable.h"
595939de
PM
26#include "python-internal.h"
27#include "arch-utils.h"
28#include "language.h"
505500db
SW
29#include "gdb_signals.h"
30#include "py-event.h"
31#include "py-stopevent.h"
595939de
PM
32
33struct threadlist_entry {
34 thread_object *thread_obj;
35 struct threadlist_entry *next;
36};
37
00431a78 38struct inferior_object
595939de
PM
39{
40 PyObject_HEAD
41
42 /* The inferior we represent. */
43 struct inferior *inferior;
44
45 /* thread_object instances under this inferior. This list owns a
46 reference to each object it contains. */
47 struct threadlist_entry *threads;
48
49 /* Number of threads in the list. */
50 int nthreads;
00431a78 51};
595939de 52
e36122e9 53extern PyTypeObject inferior_object_type
62eec1a5 54 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("inferior_object");
595939de
PM
55
56static const struct inferior_data *infpy_inf_data_key;
57
58typedef struct {
59 PyObject_HEAD
60 void *buffer;
61
62 /* These are kept just for mbpy_str. */
63 CORE_ADDR addr;
64 CORE_ADDR length;
65} membuf_object;
66
e36122e9 67extern PyTypeObject membuf_object_type
62eec1a5 68 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("membuf_object");
595939de
PM
69
70/* Require that INFERIOR be a valid inferior ID. */
71#define INFPY_REQUIRE_VALID(Inferior) \
72 do { \
73 if (!Inferior->inferior) \
74 { \
75 PyErr_SetString (PyExc_RuntimeError, \
76 _("Inferior no longer exists.")); \
77 return NULL; \
78 } \
79 } while (0)
80
505500db
SW
81static void
82python_on_normal_stop (struct bpstats *bs, int print_frame)
83{
2ea28649 84 enum gdb_signal stop_signal;
505500db 85
0646da15
TT
86 if (!gdb_python_initialized)
87 return;
88
505500db
SW
89 if (!find_thread_ptid (inferior_ptid))
90 return;
91
92 stop_signal = inferior_thread ()->suspend.stop_signal;
93
07bc7329 94 gdbpy_enter enter_py (get_current_arch (), current_language);
505500db
SW
95
96 if (emit_stop_event (bs, stop_signal) < 0)
97 gdbpy_print_stack ();
505500db
SW
98}
99
100static void
101python_on_resume (ptid_t ptid)
102{
0646da15
TT
103 if (!gdb_python_initialized)
104 return;
105
07bc7329 106 gdbpy_enter enter_py (target_gdbarch (), current_language);
505500db
SW
107
108 if (emit_continue_event (ptid) < 0)
109 gdbpy_print_stack ();
505500db
SW
110}
111
162078c8
NB
112/* Callback, registered as an observer, that notifies Python listeners
113 when an inferior function call is about to be made. */
114
115static void
116python_on_inferior_call_pre (ptid_t thread, CORE_ADDR address)
117{
07bc7329 118 gdbpy_enter enter_py (target_gdbarch (), current_language);
162078c8
NB
119
120 if (emit_inferior_call_event (INFERIOR_CALL_PRE, thread, address) < 0)
121 gdbpy_print_stack ();
162078c8
NB
122}
123
124/* Callback, registered as an observer, that notifies Python listeners
125 when an inferior function call has completed. */
126
127static void
128python_on_inferior_call_post (ptid_t thread, CORE_ADDR address)
129{
07bc7329 130 gdbpy_enter enter_py (target_gdbarch (), current_language);
162078c8
NB
131
132 if (emit_inferior_call_event (INFERIOR_CALL_POST, thread, address) < 0)
133 gdbpy_print_stack ();
162078c8
NB
134}
135
136/* Callback, registered as an observer, that notifies Python listeners
137 when a part of memory has been modified by user action (eg via a
138 'set' command). */
139
140static void
141python_on_memory_change (struct inferior *inferior, CORE_ADDR addr, ssize_t len, const bfd_byte *data)
142{
07bc7329 143 gdbpy_enter enter_py (target_gdbarch (), current_language);
162078c8
NB
144
145 if (emit_memory_changed_event (addr, len) < 0)
146 gdbpy_print_stack ();
162078c8
NB
147}
148
149/* Callback, registered as an observer, that notifies Python listeners
150 when a register has been modified by user action (eg via a 'set'
151 command). */
152
153static void
154python_on_register_change (struct frame_info *frame, int regnum)
155{
07bc7329 156 gdbpy_enter enter_py (target_gdbarch (), current_language);
162078c8
NB
157
158 if (emit_register_changed_event (frame, regnum) < 0)
159 gdbpy_print_stack ();
162078c8
NB
160}
161
505500db
SW
162static void
163python_inferior_exit (struct inferior *inf)
164{
8cf64490 165 const LONGEST *exit_code = NULL;
505500db 166
0646da15
TT
167 if (!gdb_python_initialized)
168 return;
169
07bc7329 170 gdbpy_enter enter_py (target_gdbarch (), current_language);
505500db 171
8cf64490
TT
172 if (inf->has_exit_code)
173 exit_code = &inf->exit_code;
505500db 174
cb6be26b 175 if (emit_exited_event (exit_code, inf) < 0)
505500db 176 gdbpy_print_stack ();
505500db
SW
177}
178
20c168b5 179/* Callback used to notify Python listeners about new objfiles loaded in the
4ffbba72
DE
180 inferior. OBJFILE may be NULL which means that the objfile list has been
181 cleared (emptied). */
20c168b5
KP
182
183static void
184python_new_objfile (struct objfile *objfile)
185{
0646da15
TT
186 if (!gdb_python_initialized)
187 return;
188
07bc7329
TT
189 gdbpy_enter enter_py (objfile != NULL
190 ? get_objfile_arch (objfile)
191 : target_gdbarch (),
192 current_language);
20c168b5 193
4ffbba72
DE
194 if (objfile == NULL)
195 {
196 if (emit_clear_objfiles_event () < 0)
197 gdbpy_print_stack ();
198 }
199 else
200 {
201 if (emit_new_objfile_event (objfile) < 0)
202 gdbpy_print_stack ();
203 }
20c168b5
KP
204}
205
754eadd1 206/* Return a reference to the Python object of type Inferior
595939de 207 representing INFERIOR. If the object has already been created,
754eadd1
PM
208 return it and increment the reference count, otherwise, create it.
209 Return NULL on failure. */
00431a78
PA
210
211inferior_object *
595939de
PM
212inferior_to_inferior_object (struct inferior *inferior)
213{
214 inferior_object *inf_obj;
215
19ba03f4 216 inf_obj = (inferior_object *) inferior_data (inferior, infpy_inf_data_key);
595939de
PM
217 if (!inf_obj)
218 {
595939de
PM
219 inf_obj = PyObject_New (inferior_object, &inferior_object_type);
220 if (!inf_obj)
595939de 221 return NULL;
595939de
PM
222
223 inf_obj->inferior = inferior;
224 inf_obj->threads = NULL;
225 inf_obj->nthreads = 0;
226
72bc1d24
SM
227 /* PyObject_New initializes the new object with a refcount of 1. This
228 counts for the reference we are keeping in the inferior data. */
595939de
PM
229 set_inferior_data (inferior, infpy_inf_data_key, inf_obj);
230
595939de 231 }
72bc1d24
SM
232
233 /* We are returning a new reference. */
234 Py_INCREF ((PyObject *)inf_obj);
595939de 235
00431a78 236 return inf_obj;
595939de
PM
237}
238
7c96f8c1
TT
239/* Called when a new inferior is created. Notifies any Python event
240 listeners. */
241static void
242python_new_inferior (struct inferior *inf)
243{
244 if (!gdb_python_initialized)
245 return;
246
247 gdbpy_enter enter_py (python_gdbarch, python_language);
248
249 if (evregpy_no_listeners_p (gdb_py_events.new_inferior))
250 return;
251
00431a78 252 gdbpy_ref<inferior_object> inf_obj (inferior_to_inferior_object (inf));
7c96f8c1
TT
253 if (inf_obj == NULL)
254 {
255 gdbpy_print_stack ();
256 return;
257 }
258
d98fc15b 259 gdbpy_ref<> event = create_event_object (&new_inferior_event_object_type);
7c96f8c1 260 if (event == NULL
00431a78
PA
261 || evpy_add_attribute (event.get (), "inferior",
262 (PyObject *) inf_obj.get ()) < 0
7c96f8c1
TT
263 || evpy_emit_event (event.get (), gdb_py_events.new_inferior) < 0)
264 gdbpy_print_stack ();
265}
266
267/* Called when an inferior is removed. Notifies any Python event
268 listeners. */
269static void
270python_inferior_deleted (struct inferior *inf)
271{
272 if (!gdb_python_initialized)
273 return;
274
275 gdbpy_enter enter_py (python_gdbarch, python_language);
276
277 if (evregpy_no_listeners_p (gdb_py_events.inferior_deleted))
278 return;
279
00431a78 280 gdbpy_ref<inferior_object> inf_obj (inferior_to_inferior_object (inf));
7c96f8c1
TT
281 if (inf_obj == NULL)
282 {
283 gdbpy_print_stack ();
284 return;
285 }
286
d98fc15b 287 gdbpy_ref<> event = create_event_object (&inferior_deleted_event_object_type);
7c96f8c1 288 if (event == NULL
00431a78
PA
289 || evpy_add_attribute (event.get (), "inferior",
290 (PyObject *) inf_obj.get ()) < 0
7c96f8c1
TT
291 || evpy_emit_event (event.get (), gdb_py_events.inferior_deleted) < 0)
292 gdbpy_print_stack ();
293}
294
595939de 295/* Finds the Python Inferior object for the given PID. Returns a
754eadd1 296 reference, or NULL if PID does not match any inferior object. */
505500db 297
595939de
PM
298PyObject *
299find_inferior_object (int pid)
300{
595939de
PM
301 struct inferior *inf = find_inferior_pid (pid);
302
303 if (inf)
00431a78 304 return (PyObject *) inferior_to_inferior_object (inf);
595939de
PM
305
306 return NULL;
307}
308
db1337cc 309gdbpy_ref<>
00431a78 310thread_to_thread_object (thread_info *thr)
595939de 311{
00431a78 312 gdbpy_ref<inferior_object> inf_obj (inferior_to_inferior_object (thr->inf));
9205649a 313 if (inf_obj == NULL)
754eadd1
PM
314 return NULL;
315
00431a78
PA
316 for (threadlist_entry *thread = inf_obj->threads;
317 thread != NULL;
754eadd1 318 thread = thread->next)
00431a78 319 if (thread->thread_obj->thread == thr)
db1337cc 320 return gdbpy_ref<>::new_reference ((PyObject *) thread->thread_obj);
595939de
PM
321
322 return NULL;
323}
324
325static void
326add_thread_object (struct thread_info *tp)
327{
595939de
PM
328 thread_object *thread_obj;
329 inferior_object *inf_obj;
330 struct threadlist_entry *entry;
331
0646da15
TT
332 if (!gdb_python_initialized)
333 return;
334
07bc7329 335 gdbpy_enter enter_py (python_gdbarch, python_language);
595939de
PM
336
337 thread_obj = create_thread_object (tp);
338 if (!thread_obj)
339 {
340 gdbpy_print_stack ();
595939de
PM
341 return;
342 }
343
344 inf_obj = (inferior_object *) thread_obj->inf_obj;
345
8d749320 346 entry = XNEW (struct threadlist_entry);
595939de
PM
347 entry->thread_obj = thread_obj;
348 entry->next = inf_obj->threads;
349
350 inf_obj->threads = entry;
351 inf_obj->nthreads++;
7c96f8c1
TT
352
353 if (evregpy_no_listeners_p (gdb_py_events.new_thread))
354 return;
355
d98fc15b
PA
356 gdbpy_ref<> event = create_thread_event_object (&new_thread_event_object_type,
357 (PyObject *) thread_obj);
7c96f8c1
TT
358 if (event == NULL
359 || evpy_emit_event (event.get (), gdb_py_events.new_thread) < 0)
360 gdbpy_print_stack ();
595939de
PM
361}
362
363static void
364delete_thread_object (struct thread_info *tp, int ignore)
365{
595939de 366 struct threadlist_entry **entry, *tmp;
256458bc 367
0646da15
TT
368 if (!gdb_python_initialized)
369 return;
370
07bc7329 371 gdbpy_enter enter_py (python_gdbarch, python_language);
595939de 372
88b6faea 373 gdbpy_ref<inferior_object> inf_obj
00431a78 374 ((inferior_object *) inferior_to_inferior_object (tp->inf));
88b6faea 375 if (inf_obj == NULL)
07bc7329 376 return;
595939de
PM
377
378 /* Find thread entry in its inferior's thread_list. */
379 for (entry = &inf_obj->threads; *entry != NULL; entry =
380 &(*entry)->next)
381 if ((*entry)->thread_obj->thread == tp)
382 break;
383
384 if (!*entry)
88b6faea 385 return;
595939de 386
595939de
PM
387 tmp = *entry;
388 tmp->thread_obj->thread = NULL;
389
390 *entry = (*entry)->next;
391 inf_obj->nthreads--;
392
393 Py_DECREF (tmp->thread_obj);
394 xfree (tmp);
595939de
PM
395}
396
397static PyObject *
398infpy_threads (PyObject *self, PyObject *args)
399{
400 int i;
401 struct threadlist_entry *entry;
402 inferior_object *inf_obj = (inferior_object *) self;
403 PyObject *tuple;
404
405 INFPY_REQUIRE_VALID (inf_obj);
406
492d29ea
PA
407 TRY
408 {
409 update_thread_list ();
410 }
411 CATCH (except, RETURN_MASK_ALL)
412 {
413 GDB_PY_HANDLE_EXCEPTION (except);
414 }
415 END_CATCH
f66713d2 416
595939de
PM
417 tuple = PyTuple_New (inf_obj->nthreads);
418 if (!tuple)
419 return NULL;
420
421 for (i = 0, entry = inf_obj->threads; i < inf_obj->nthreads;
422 i++, entry = entry->next)
423 {
424 Py_INCREF (entry->thread_obj);
425 PyTuple_SET_ITEM (tuple, i, (PyObject *) entry->thread_obj);
426 }
427
428 return tuple;
429}
430
431static PyObject *
432infpy_get_num (PyObject *self, void *closure)
433{
434 inferior_object *inf = (inferior_object *) self;
435
436 INFPY_REQUIRE_VALID (inf);
437
438 return PyLong_FromLong (inf->inferior->num);
439}
440
441static PyObject *
442infpy_get_pid (PyObject *self, void *closure)
443{
444 inferior_object *inf = (inferior_object *) self;
445
446 INFPY_REQUIRE_VALID (inf);
447
448 return PyLong_FromLong (inf->inferior->pid);
449}
450
451static PyObject *
452infpy_get_was_attached (PyObject *self, void *closure)
453{
454 inferior_object *inf = (inferior_object *) self;
455
456 INFPY_REQUIRE_VALID (inf);
457 if (inf->inferior->attach_flag)
458 Py_RETURN_TRUE;
459 Py_RETURN_FALSE;
460}
461
a40bf0c2
SM
462/* Getter of gdb.Inferior.progspace. */
463
464static PyObject *
465infpy_get_progspace (PyObject *self, void *closure)
466{
467 inferior_object *inf = (inferior_object *) self;
468
469 INFPY_REQUIRE_VALID (inf);
470
471 program_space *pspace = inf->inferior->pspace;
472 gdb_assert (pspace != nullptr);
473
3c7aa307 474 return pspace_to_pspace_object (pspace).release ();
a40bf0c2
SM
475}
476
595939de
PM
477static int
478build_inferior_list (struct inferior *inf, void *arg)
479{
19ba03f4 480 PyObject *list = (PyObject *) arg;
00431a78 481 gdbpy_ref<inferior_object> inferior (inferior_to_inferior_object (inf));
754eadd1 482
00431a78 483 if (inferior == NULL)
754eadd1
PM
484 return 0;
485
00431a78 486 return PyList_Append (list, (PyObject *) inferior.get ()) ? 1 : 0;
595939de
PM
487}
488
489/* Implementation of gdb.inferiors () -> (gdb.Inferior, ...).
490 Returns a tuple of all inferiors. */
491PyObject *
492gdbpy_inferiors (PyObject *unused, PyObject *unused2)
493{
7780f186 494 gdbpy_ref<> list (PyList_New (0));
f59fe7f8 495 if (list == NULL)
595939de
PM
496 return NULL;
497
f59fe7f8
TT
498 if (iterate_over_inferiors (build_inferior_list, list.get ()))
499 return NULL;
27ca1a5b 500
f59fe7f8 501 return PyList_AsTuple (list.get ());
595939de
PM
502}
503
504/* Membuf and memory manipulation. */
505
2678e2af 506/* Implementation of Inferior.read_memory (address, length).
595939de 507 Returns a Python buffer object with LENGTH bytes of the inferior's
8dc78533
JK
508 memory at ADDRESS. Both arguments are integers. Returns NULL on error,
509 with a python exception set. */
595939de
PM
510static PyObject *
511infpy_read_memory (PyObject *self, PyObject *args, PyObject *kw)
512{
595939de 513 CORE_ADDR addr, length;
7c543f7b 514 gdb_byte *buffer = NULL;
cc0265cd 515 PyObject *addr_obj, *length_obj, *result;
2adadf51 516 static const char *keywords[] = { "address", "length", NULL };
595939de 517
2adadf51
PA
518 if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "OO", keywords,
519 &addr_obj, &length_obj))
595939de
PM
520 return NULL;
521
b86af38a
TT
522 if (get_addr_from_python (addr_obj, &addr) < 0
523 || get_addr_from_python (length_obj, &length) < 0)
524 return NULL;
525
492d29ea 526 TRY
595939de 527 {
7c543f7b 528 buffer = (gdb_byte *) xmalloc (length);
595939de
PM
529
530 read_memory (addr, buffer, length);
531 }
492d29ea 532 CATCH (except, RETURN_MASK_ALL)
595939de 533 {
cc0265cd 534 xfree (buffer);
595939de
PM
535 GDB_PY_HANDLE_EXCEPTION (except);
536 }
492d29ea 537 END_CATCH
595939de 538
88b6faea
TT
539 gdbpy_ref<membuf_object> membuf_obj (PyObject_New (membuf_object,
540 &membuf_object_type));
595939de
PM
541 if (membuf_obj == NULL)
542 {
cc0265cd 543 xfree (buffer);
595939de
PM
544 return NULL;
545 }
546
595939de
PM
547 membuf_obj->buffer = buffer;
548 membuf_obj->addr = addr;
549 membuf_obj->length = length;
550
9a27f2c6 551#ifdef IS_PY3K
88b6faea 552 result = PyMemoryView_FromObject ((PyObject *) membuf_obj.get ());
9a27f2c6 553#else
88b6faea 554 result = PyBuffer_FromReadWriteObject ((PyObject *) membuf_obj.get (), 0,
cc0265cd 555 Py_END_OF_BUFFER);
9a27f2c6 556#endif
9a27f2c6 557
cc0265cd 558 return result;
595939de
PM
559}
560
2678e2af 561/* Implementation of Inferior.write_memory (address, buffer [, length]).
595939de
PM
562 Writes the contents of BUFFER (a Python object supporting the read
563 buffer protocol) at ADDRESS in the inferior's memory. Write LENGTH
564 bytes from BUFFER, or its entire contents if the argument is not
8dc78533
JK
565 provided. The function returns nothing. Returns NULL on error, with
566 a python exception set. */
595939de
PM
567static PyObject *
568infpy_write_memory (PyObject *self, PyObject *args, PyObject *kw)
569{
492d29ea 570 struct gdb_exception except = exception_none;
ddd49eee 571 Py_ssize_t buf_len;
7c543f7b 572 const gdb_byte *buffer;
595939de
PM
573 CORE_ADDR addr, length;
574 PyObject *addr_obj, *length_obj = NULL;
2adadf51 575 static const char *keywords[] = { "address", "buffer", "length", NULL };
9a27f2c6
PK
576#ifdef IS_PY3K
577 Py_buffer pybuf;
595939de 578
2adadf51
PA
579 if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "Os*|O", keywords,
580 &addr_obj, &pybuf, &length_obj))
9a27f2c6 581 return NULL;
595939de 582
7c543f7b 583 buffer = (const gdb_byte *) pybuf.buf;
9a27f2c6
PK
584 buf_len = pybuf.len;
585#else
2adadf51
PA
586 if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "Os#|O", keywords,
587 &addr_obj, &buffer, &buf_len,
588 &length_obj))
595939de 589 return NULL;
7c543f7b
SM
590
591 buffer = (const gdb_byte *) buffer;
9a27f2c6 592#endif
595939de 593
b86af38a
TT
594 if (get_addr_from_python (addr_obj, &addr) < 0)
595 goto fail;
596
597 if (!length_obj)
598 length = buf_len;
599 else if (get_addr_from_python (length_obj, &length) < 0)
600 goto fail;
601
492d29ea 602 TRY
595939de 603 {
7c543f7b 604 write_memory_with_notification (addr, buffer, length);
595939de 605 }
492d29ea
PA
606 CATCH (ex, RETURN_MASK_ALL)
607 {
608 except = ex;
609 }
610 END_CATCH
611
9a27f2c6
PK
612#ifdef IS_PY3K
613 PyBuffer_Release (&pybuf);
614#endif
595939de
PM
615 GDB_PY_HANDLE_EXCEPTION (except);
616
595939de 617 Py_RETURN_NONE;
b86af38a
TT
618
619 fail:
620#ifdef IS_PY3K
621 PyBuffer_Release (&pybuf);
622#endif
623 return NULL;
595939de
PM
624}
625
626/* Destructor of Membuf objects. */
627static void
628mbpy_dealloc (PyObject *self)
629{
630 xfree (((membuf_object *) self)->buffer);
9a27f2c6 631 Py_TYPE (self)->tp_free (self);
595939de
PM
632}
633
634/* Return a description of the Membuf object. */
635static PyObject *
636mbpy_str (PyObject *self)
637{
638 membuf_object *membuf_obj = (membuf_object *) self;
639
640 return PyString_FromFormat (_("Memory buffer for address %s, \
641which is %s bytes long."),
642 paddress (python_gdbarch, membuf_obj->addr),
643 pulongest (membuf_obj->length));
644}
645
9a27f2c6
PK
646#ifdef IS_PY3K
647
648static int
649get_buffer (PyObject *self, Py_buffer *buf, int flags)
650{
651 membuf_object *membuf_obj = (membuf_object *) self;
652 int ret;
256458bc 653
9a27f2c6 654 ret = PyBuffer_FillInfo (buf, self, membuf_obj->buffer,
256458bc 655 membuf_obj->length, 0,
9a27f2c6 656 PyBUF_CONTIG);
a121b7c1
PA
657
658 /* Despite the documentation saying this field is a "const char *",
659 in Python 3.4 at least, it's really a "char *". */
660 buf->format = (char *) "c";
9a27f2c6
PK
661
662 return ret;
663}
664
665#else
666
595939de
PM
667static Py_ssize_t
668get_read_buffer (PyObject *self, Py_ssize_t segment, void **ptrptr)
669{
670 membuf_object *membuf_obj = (membuf_object *) self;
671
672 if (segment)
673 {
674 PyErr_SetString (PyExc_SystemError,
675 _("The memory buffer supports only one segment."));
676 return -1;
677 }
678
679 *ptrptr = membuf_obj->buffer;
680
681 return membuf_obj->length;
682}
683
684static Py_ssize_t
685get_write_buffer (PyObject *self, Py_ssize_t segment, void **ptrptr)
686{
687 return get_read_buffer (self, segment, ptrptr);
688}
689
690static Py_ssize_t
691get_seg_count (PyObject *self, Py_ssize_t *lenp)
692{
693 if (lenp)
694 *lenp = ((membuf_object *) self)->length;
695
696 return 1;
697}
698
699static Py_ssize_t
700get_char_buffer (PyObject *self, Py_ssize_t segment, char **ptrptr)
701{
702 void *ptr = NULL;
703 Py_ssize_t ret;
704
705 ret = get_read_buffer (self, segment, &ptr);
706 *ptrptr = (char *) ptr;
707
708 return ret;
709}
710
9a27f2c6
PK
711#endif /* IS_PY3K */
712
595939de
PM
713/* Implementation of
714 gdb.search_memory (address, length, pattern). ADDRESS is the
715 address to start the search. LENGTH specifies the scope of the
716 search from ADDRESS. PATTERN is the pattern to search for (and
717 must be a Python object supporting the buffer protocol).
718 Returns a Python Long object holding the address where the pattern
8dc78533
JK
719 was located, or if the pattern was not found, returns None. Returns NULL
720 on error, with a python exception set. */
595939de
PM
721static PyObject *
722infpy_search_memory (PyObject *self, PyObject *args, PyObject *kw)
723{
492d29ea 724 struct gdb_exception except = exception_none;
595939de 725 CORE_ADDR start_addr, length;
2adadf51 726 static const char *keywords[] = { "address", "length", "pattern", NULL };
9a27f2c6 727 PyObject *start_addr_obj, *length_obj;
595939de 728 Py_ssize_t pattern_size;
7c543f7b 729 const gdb_byte *buffer;
595939de
PM
730 CORE_ADDR found_addr;
731 int found = 0;
9a27f2c6
PK
732#ifdef IS_PY3K
733 Py_buffer pybuf;
595939de 734
2adadf51
PA
735 if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "OOs*", keywords,
736 &start_addr_obj, &length_obj,
737 &pybuf))
9a27f2c6
PK
738 return NULL;
739
7c543f7b 740 buffer = (const gdb_byte *) pybuf.buf;
9a27f2c6
PK
741 pattern_size = pybuf.len;
742#else
743 PyObject *pattern;
7c543f7b 744 const void *vbuffer;
256458bc 745
2adadf51
PA
746 if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "OOO", keywords,
747 &start_addr_obj, &length_obj,
748 &pattern))
9a27f2c6
PK
749 return NULL;
750
751 if (!PyObject_CheckReadBuffer (pattern))
752 {
753 PyErr_SetString (PyExc_RuntimeError,
754 _("The pattern is not a Python buffer."));
755
756 return NULL;
757 }
758
7c543f7b 759 if (PyObject_AsReadBuffer (pattern, &vbuffer, &pattern_size) == -1)
595939de 760 return NULL;
7c543f7b
SM
761
762 buffer = (const gdb_byte *) vbuffer;
9a27f2c6 763#endif
595939de 764
b86af38a
TT
765 if (get_addr_from_python (start_addr_obj, &start_addr) < 0)
766 goto fail;
256458bc 767
b86af38a
TT
768 if (get_addr_from_python (length_obj, &length) < 0)
769 goto fail;
9a27f2c6 770
b86af38a
TT
771 if (!length)
772 {
773 PyErr_SetString (PyExc_ValueError,
774 _("Search range is empty."));
775 goto fail;
776 }
777 /* Watch for overflows. */
778 else if (length > CORE_ADDR_MAX
779 || (start_addr + length - 1) < start_addr)
780 {
781 PyErr_SetString (PyExc_ValueError,
782 _("The search range is too large."));
783 goto fail;
595939de 784 }
595939de 785
492d29ea 786 TRY
595939de
PM
787 {
788 found = target_search_memory (start_addr, length,
789 buffer, pattern_size,
790 &found_addr);
791 }
492d29ea
PA
792 CATCH (ex, RETURN_MASK_ALL)
793 {
794 except = ex;
795 }
796 END_CATCH
797
9a27f2c6
PK
798#ifdef IS_PY3K
799 PyBuffer_Release (&pybuf);
800#endif
b86af38a 801 GDB_PY_HANDLE_EXCEPTION (except);
9a27f2c6 802
595939de
PM
803 if (found)
804 return PyLong_FromLong (found_addr);
805 else
806 Py_RETURN_NONE;
b86af38a
TT
807
808 fail:
809#ifdef IS_PY3K
810 PyBuffer_Release (&pybuf);
811#endif
812 return NULL;
595939de
PM
813}
814
29703da4
PM
815/* Implementation of gdb.Inferior.is_valid (self) -> Boolean.
816 Returns True if this inferior object still exists in GDB. */
817
818static PyObject *
819infpy_is_valid (PyObject *self, PyObject *args)
820{
821 inferior_object *inf = (inferior_object *) self;
822
823 if (! inf->inferior)
824 Py_RETURN_FALSE;
825
826 Py_RETURN_TRUE;
827}
828
fbbe5337
KB
829/* Implementation of gdb.Inferior.thread_from_thread_handle (self, handle)
830 -> gdb.InferiorThread. */
831
7d221512 832static PyObject *
fbbe5337
KB
833infpy_thread_from_thread_handle (PyObject *self, PyObject *args, PyObject *kw)
834{
db1337cc 835 PyObject *handle_obj;
fbbe5337
KB
836 inferior_object *inf_obj = (inferior_object *) self;
837 static const char *keywords[] = { "thread_handle", NULL };
838
839 INFPY_REQUIRE_VALID (inf_obj);
840
841 if (! gdb_PyArg_ParseTupleAndKeywords (args, kw, "O", keywords, &handle_obj))
842 return NULL;
843
fbbe5337
KB
844 if (!gdbpy_is_value_object (handle_obj))
845 {
846 PyErr_SetString (PyExc_TypeError,
847 _("Argument 'handle_obj' must be a thread handle object."));
848
849 return NULL;
850 }
db1337cc
TT
851
852 gdbpy_ref<> result;
853 TRY
854 {
855 struct thread_info *thread_info;
856 struct value *val = value_object_to_value (handle_obj);
857
858 thread_info = find_thread_by_handle (val, inf_obj->inferior);
859 if (thread_info != NULL)
860 result = thread_to_thread_object (thread_info);
861 }
862 CATCH (except, RETURN_MASK_ALL)
fbbe5337 863 {
db1337cc 864 GDB_PY_HANDLE_EXCEPTION (except);
fbbe5337 865 }
db1337cc 866 END_CATCH
fbbe5337 867
db1337cc
TT
868 if (result == NULL)
869 result = gdbpy_ref<>::new_reference (Py_None);
870
871 return result.release ();
fbbe5337
KB
872}
873
1256af7d
SM
874/* Implement repr() for gdb.Inferior. */
875
876static PyObject *
877infpy_repr (PyObject *obj)
878{
879 inferior_object *self = (inferior_object *) obj;
880 inferior *inf = self->inferior;
881
882 if (inf == nullptr)
883 return PyString_FromString ("<gdb.Inferior (invalid)>");
884
885 return PyString_FromFormat ("<gdb.Inferior num=%d, pid=%d>",
886 inf->num, inf->pid);
887}
888
fbbe5337 889
754eadd1
PM
890static void
891infpy_dealloc (PyObject *obj)
892{
893 inferior_object *inf_obj = (inferior_object *) obj;
894 struct inferior *inf = inf_obj->inferior;
895
896 if (! inf)
897 return;
898
899 set_inferior_data (inf, infpy_inf_data_key, NULL);
900}
595939de
PM
901
902/* Clear the INFERIOR pointer in an Inferior object and clear the
903 thread list. */
904static void
905py_free_inferior (struct inferior *inf, void *datum)
906{
88b6faea 907 gdbpy_ref<inferior_object> inf_obj ((inferior_object *) datum);
595939de
PM
908 struct threadlist_entry *th_entry, *th_tmp;
909
0646da15
TT
910 if (!gdb_python_initialized)
911 return;
912
07bc7329 913 gdbpy_enter enter_py (python_gdbarch, python_language);
595939de
PM
914
915 inf_obj->inferior = NULL;
916
917 /* Deallocate threads list. */
918 for (th_entry = inf_obj->threads; th_entry != NULL;)
919 {
920 Py_DECREF (th_entry->thread_obj);
921
922 th_tmp = th_entry;
923 th_entry = th_entry->next;
924 xfree (th_tmp);
925 }
926
927 inf_obj->nthreads = 0;
595939de
PM
928}
929
2aa48337
KP
930/* Implementation of gdb.selected_inferior() -> gdb.Inferior.
931 Returns the current inferior object. */
932
933PyObject *
934gdbpy_selected_inferior (PyObject *self, PyObject *args)
935{
00431a78 936 return (PyObject *) inferior_to_inferior_object (current_inferior ());
2aa48337
KP
937}
938
999633ed 939int
595939de
PM
940gdbpy_initialize_inferior (void)
941{
942 if (PyType_Ready (&inferior_object_type) < 0)
999633ed 943 return -1;
595939de 944
aa36459a
TT
945 if (gdb_pymodule_addobject (gdb_module, "Inferior",
946 (PyObject *) &inferior_object_type) < 0)
999633ed 947 return -1;
595939de
PM
948
949 infpy_inf_data_key =
8e260fc0 950 register_inferior_data_with_cleanup (NULL, py_free_inferior);
595939de 951
76727919
TT
952 gdb::observers::new_thread.attach (add_thread_object);
953 gdb::observers::thread_exit.attach (delete_thread_object);
954 gdb::observers::normal_stop.attach (python_on_normal_stop);
955 gdb::observers::target_resumed.attach (python_on_resume);
956 gdb::observers::inferior_call_pre.attach (python_on_inferior_call_pre);
957 gdb::observers::inferior_call_post.attach (python_on_inferior_call_post);
958 gdb::observers::memory_changed.attach (python_on_memory_change);
959 gdb::observers::register_changed.attach (python_on_register_change);
960 gdb::observers::inferior_exit.attach (python_inferior_exit);
961 gdb::observers::new_objfile.attach (python_new_objfile);
962 gdb::observers::inferior_added.attach (python_new_inferior);
963 gdb::observers::inferior_removed.attach (python_inferior_deleted);
595939de 964
6a1b1664 965 membuf_object_type.tp_new = PyType_GenericNew;
595939de 966 if (PyType_Ready (&membuf_object_type) < 0)
999633ed 967 return -1;
595939de 968
aa36459a
TT
969 return gdb_pymodule_addobject (gdb_module, "Membuf", (PyObject *)
970 &membuf_object_type);
595939de
PM
971}
972
0d1f4ceb 973static gdb_PyGetSetDef inferior_object_getset[] =
595939de
PM
974{
975 { "num", infpy_get_num, NULL, "ID of inferior, as assigned by GDB.", NULL },
976 { "pid", infpy_get_pid, NULL, "PID of inferior, as assigned by the OS.",
977 NULL },
978 { "was_attached", infpy_get_was_attached, NULL,
979 "True if the inferior was created using 'attach'.", NULL },
a40bf0c2 980 { "progspace", infpy_get_progspace, NULL, "Program space of this inferior" },
595939de
PM
981 { NULL }
982};
983
984static PyMethodDef inferior_object_methods[] =
985{
29703da4
PM
986 { "is_valid", infpy_is_valid, METH_NOARGS,
987 "is_valid () -> Boolean.\n\
988Return true if this inferior is valid, false if not." },
595939de
PM
989 { "threads", infpy_threads, METH_NOARGS,
990 "Return all the threads of this inferior." },
991 { "read_memory", (PyCFunction) infpy_read_memory,
992 METH_VARARGS | METH_KEYWORDS,
993 "read_memory (address, length) -> buffer\n\
994Return a buffer object for reading from the inferior's memory." },
995 { "write_memory", (PyCFunction) infpy_write_memory,
996 METH_VARARGS | METH_KEYWORDS,
997 "write_memory (address, buffer [, length])\n\
998Write the given buffer object to the inferior's memory." },
999 { "search_memory", (PyCFunction) infpy_search_memory,
1000 METH_VARARGS | METH_KEYWORDS,
1001 "search_memory (address, length, pattern) -> long\n\
1002Return a long with the address of a match, or None." },
fbbe5337
KB
1003 { "thread_from_thread_handle", (PyCFunction) infpy_thread_from_thread_handle,
1004 METH_VARARGS | METH_KEYWORDS,
1005 "thread_from_thread_handle (handle) -> gdb.InferiorThread.\n\
1006Return thread object corresponding to thread handle." },
595939de
PM
1007 { NULL }
1008};
1009
e36122e9 1010PyTypeObject inferior_object_type =
595939de 1011{
9a27f2c6 1012 PyVarObject_HEAD_INIT (NULL, 0)
595939de
PM
1013 "gdb.Inferior", /* tp_name */
1014 sizeof (inferior_object), /* tp_basicsize */
1015 0, /* tp_itemsize */
754eadd1 1016 infpy_dealloc, /* tp_dealloc */
595939de
PM
1017 0, /* tp_print */
1018 0, /* tp_getattr */
1019 0, /* tp_setattr */
1020 0, /* tp_compare */
1256af7d 1021 infpy_repr, /* tp_repr */
595939de
PM
1022 0, /* tp_as_number */
1023 0, /* tp_as_sequence */
1024 0, /* tp_as_mapping */
1025 0, /* tp_hash */
1026 0, /* tp_call */
1027 0, /* tp_str */
1028 0, /* tp_getattro */
1029 0, /* tp_setattro */
1030 0, /* tp_as_buffer */
1031 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER, /* tp_flags */
1032 "GDB inferior object", /* tp_doc */
1033 0, /* tp_traverse */
1034 0, /* tp_clear */
1035 0, /* tp_richcompare */
1036 0, /* tp_weaklistoffset */
1037 0, /* tp_iter */
1038 0, /* tp_iternext */
1039 inferior_object_methods, /* tp_methods */
1040 0, /* tp_members */
1041 inferior_object_getset, /* tp_getset */
1042 0, /* tp_base */
1043 0, /* tp_dict */
1044 0, /* tp_descr_get */
1045 0, /* tp_descr_set */
1046 0, /* tp_dictoffset */
1047 0, /* tp_init */
1048 0 /* tp_alloc */
1049};
1050
9a27f2c6
PK
1051#ifdef IS_PY3K
1052
1053static PyBufferProcs buffer_procs =
1054{
1055 get_buffer
1056};
1057
1058#else
1059
595939de
PM
1060/* Python doesn't provide a decent way to get compatibility here. */
1061#if HAVE_LIBPYTHON2_4
1062#define CHARBUFFERPROC_NAME getcharbufferproc
1063#else
1064#define CHARBUFFERPROC_NAME charbufferproc
1065#endif
1066
1067static PyBufferProcs buffer_procs = {
1068 get_read_buffer,
1069 get_write_buffer,
1070 get_seg_count,
1071 /* The cast here works around a difference between Python 2.4 and
1072 Python 2.5. */
1073 (CHARBUFFERPROC_NAME) get_char_buffer
1074};
9a27f2c6 1075#endif /* IS_PY3K */
595939de 1076
e36122e9 1077PyTypeObject membuf_object_type = {
9a27f2c6 1078 PyVarObject_HEAD_INIT (NULL, 0)
595939de
PM
1079 "gdb.Membuf", /*tp_name*/
1080 sizeof (membuf_object), /*tp_basicsize*/
1081 0, /*tp_itemsize*/
1082 mbpy_dealloc, /*tp_dealloc*/
1083 0, /*tp_print*/
1084 0, /*tp_getattr*/
1085 0, /*tp_setattr*/
1086 0, /*tp_compare*/
1087 0, /*tp_repr*/
1088 0, /*tp_as_number*/
1089 0, /*tp_as_sequence*/
1090 0, /*tp_as_mapping*/
1091 0, /*tp_hash */
1092 0, /*tp_call*/
1093 mbpy_str, /*tp_str*/
1094 0, /*tp_getattro*/
1095 0, /*tp_setattro*/
1096 &buffer_procs, /*tp_as_buffer*/
1097 Py_TPFLAGS_DEFAULT, /*tp_flags*/
1098 "GDB memory buffer object", /*tp_doc*/
1099 0, /* tp_traverse */
1100 0, /* tp_clear */
1101 0, /* tp_richcompare */
1102 0, /* tp_weaklistoffset */
1103 0, /* tp_iter */
1104 0, /* tp_iternext */
1105 0, /* tp_methods */
1106 0, /* tp_members */
1107 0, /* tp_getset */
1108 0, /* tp_base */
1109 0, /* tp_dict */
1110 0, /* tp_descr_get */
1111 0, /* tp_descr_set */
1112 0, /* tp_dictoffset */
1113 0, /* tp_init */
1114 0, /* tp_alloc */
595939de 1115};
This page took 0.864342 seconds and 4 git commands to generate.