Automatic date update in version.in
[deliverable/binutils-gdb.git] / gdb / python / py-frame.c
CommitLineData
f8f6f20b
TJB
1/* Python interface to stack frames
2
618f726f 3 Copyright (C) 2008-2016 Free Software Foundation, Inc.
f8f6f20b
TJB
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 "charset.h"
22#include "block.h"
23#include "frame.h"
f8f6f20b
TJB
24#include "symtab.h"
25#include "stack.h"
26#include "value.h"
27#include "python-internal.h"
f3e9a817
PM
28#include "symfile.h"
29#include "objfiles.h"
5f3b99cf 30#include "user-regs.h"
f8f6f20b
TJB
31
32typedef struct {
33 PyObject_HEAD
34 struct frame_id frame_id;
35 struct gdbarch *gdbarch;
36
37 /* Marks that the FRAME_ID member actually holds the ID of the frame next
38 to this, and not this frames' ID itself. This is a hack to permit Python
39 frame objects which represent invalid frames (i.e., the last frame_info
40 in a corrupt stack). The problem arises from the fact that this code
41 relies on FRAME_ID to uniquely identify a frame, which is not always true
42 for the last "frame" in a corrupt stack (it can have a null ID, or the same
43 ID as the previous frame). Whenever get_prev_frame returns NULL, we
44 record the frame_id of the next frame and set FRAME_ID_IS_NEXT to 1. */
45 int frame_id_is_next;
46} frame_object;
47
48/* Require a valid frame. This must be called inside a TRY_CATCH, or
49 another context in which a gdb exception is allowed. */
50#define FRAPY_REQUIRE_VALID(frame_obj, frame) \
51 do { \
52 frame = frame_object_to_frame_info (frame_obj); \
53 if (frame == NULL) \
044c0f87 54 error (_("Frame is invalid.")); \
f8f6f20b
TJB
55 } while (0)
56
f8f6f20b
TJB
57/* Returns the frame_info object corresponding to the given Python Frame
58 object. If the frame doesn't exist anymore (the frame id doesn't
59 correspond to any frame in the inferior), returns NULL. */
60
cc72b2a2
KP
61struct frame_info *
62frame_object_to_frame_info (PyObject *obj)
f8f6f20b 63{
256458bc 64 frame_object *frame_obj = (frame_object *) obj;
f8f6f20b
TJB
65 struct frame_info *frame;
66
67 frame = frame_find_by_id (frame_obj->frame_id);
68 if (frame == NULL)
69 return NULL;
70
71 if (frame_obj->frame_id_is_next)
72 frame = get_prev_frame (frame);
73
74 return frame;
75}
76
77/* Called by the Python interpreter to obtain string representation
78 of the object. */
79
80static PyObject *
81frapy_str (PyObject *self)
82{
f8f6f20b
TJB
83 PyObject *result;
84 struct ui_file *strfile;
85
86 strfile = mem_fileopen ();
87 fprint_frame_id (strfile, ((frame_object *) self)->frame_id);
c92aed16
PA
88 std::string s = ui_file_as_string (strfile);
89 return PyString_FromString (s.c_str ());
f8f6f20b
TJB
90}
91
92/* Implementation of gdb.Frame.is_valid (self) -> Boolean.
93 Returns True if the frame corresponding to the frame_id of this
94 object still exists in the inferior. */
95
96static PyObject *
97frapy_is_valid (PyObject *self, PyObject *args)
98{
76dce0be 99 struct frame_info *frame = NULL;
76dce0be 100
492d29ea 101 TRY
76dce0be 102 {
cc72b2a2 103 frame = frame_object_to_frame_info (self);
76dce0be 104 }
492d29ea
PA
105 CATCH (except, RETURN_MASK_ALL)
106 {
107 GDB_PY_HANDLE_EXCEPTION (except);
108 }
109 END_CATCH
f8f6f20b 110
f8f6f20b
TJB
111 if (frame == NULL)
112 Py_RETURN_FALSE;
113
114 Py_RETURN_TRUE;
115}
116
117/* Implementation of gdb.Frame.name (self) -> String.
118 Returns the name of the function corresponding to this frame. */
119
120static PyObject *
121frapy_name (PyObject *self, PyObject *args)
122{
123 struct frame_info *frame;
55b87a52 124 char *name = NULL;
f8f6f20b
TJB
125 enum language lang;
126 PyObject *result;
f8f6f20b 127
492d29ea 128 TRY
f8f6f20b 129 {
cc72b2a2 130 FRAPY_REQUIRE_VALID (self, frame);
f8f6f20b 131
e9e07ba6 132 find_frame_funname (frame, &name, &lang, NULL);
f8f6f20b 133 }
492d29ea
PA
134 CATCH (except, RETURN_MASK_ALL)
135 {
136 xfree (name);
137 GDB_PY_HANDLE_EXCEPTION (except);
138 }
139 END_CATCH
f8f6f20b
TJB
140
141 if (name)
55b87a52
KS
142 {
143 result = PyUnicode_Decode (name, strlen (name), host_charset (), NULL);
144 xfree (name);
145 }
f8f6f20b
TJB
146 else
147 {
148 result = Py_None;
149 Py_INCREF (Py_None);
150 }
151
152 return result;
153}
154
155/* Implementation of gdb.Frame.type (self) -> Integer.
156 Returns the frame type, namely one of the gdb.*_FRAME constants. */
157
158static PyObject *
159frapy_type (PyObject *self, PyObject *args)
160{
161 struct frame_info *frame;
162 enum frame_type type = NORMAL_FRAME;/* Initialize to appease gcc warning. */
f8f6f20b 163
492d29ea 164 TRY
f8f6f20b 165 {
cc72b2a2 166 FRAPY_REQUIRE_VALID (self, frame);
f8f6f20b
TJB
167
168 type = get_frame_type (frame);
169 }
492d29ea
PA
170 CATCH (except, RETURN_MASK_ALL)
171 {
172 GDB_PY_HANDLE_EXCEPTION (except);
173 }
174 END_CATCH
f8f6f20b
TJB
175
176 return PyInt_FromLong (type);
177}
178
bea883fd
SCR
179/* Implementation of gdb.Frame.architecture (self) -> gdb.Architecture.
180 Returns the frame's architecture as a gdb.Architecture object. */
181
182static PyObject *
183frapy_arch (PyObject *self, PyObject *args)
184{
185 struct frame_info *frame = NULL; /* Initialize to appease gcc warning. */
186 frame_object *obj = (frame_object *) self;
bea883fd 187
492d29ea 188 TRY
bea883fd
SCR
189 {
190 FRAPY_REQUIRE_VALID (self, frame);
191 }
492d29ea
PA
192 CATCH (except, RETURN_MASK_ALL)
193 {
194 GDB_PY_HANDLE_EXCEPTION (except);
195 }
196 END_CATCH
bea883fd
SCR
197
198 return gdbarch_to_arch_object (obj->gdbarch);
199}
200
f8f6f20b
TJB
201/* Implementation of gdb.Frame.unwind_stop_reason (self) -> Integer.
202 Returns one of the gdb.FRAME_UNWIND_* constants. */
203
204static PyObject *
205frapy_unwind_stop_reason (PyObject *self, PyObject *args)
206{
207 struct frame_info *frame = NULL; /* Initialize to appease gcc warning. */
f8f6f20b
TJB
208 enum unwind_stop_reason stop_reason;
209
492d29ea 210 TRY
f8f6f20b 211 {
cc72b2a2 212 FRAPY_REQUIRE_VALID (self, frame);
f8f6f20b 213 }
492d29ea
PA
214 CATCH (except, RETURN_MASK_ALL)
215 {
216 GDB_PY_HANDLE_EXCEPTION (except);
217 }
218 END_CATCH
f8f6f20b
TJB
219
220 stop_reason = get_frame_unwind_stop_reason (frame);
221
222 return PyInt_FromLong (stop_reason);
223}
224
225/* Implementation of gdb.Frame.pc (self) -> Long.
226 Returns the frame's resume address. */
227
228static PyObject *
229frapy_pc (PyObject *self, PyObject *args)
230{
231 CORE_ADDR pc = 0; /* Initialize to appease gcc warning. */
232 struct frame_info *frame;
f8f6f20b 233
492d29ea 234 TRY
f8f6f20b 235 {
cc72b2a2 236 FRAPY_REQUIRE_VALID (self, frame);
f8f6f20b
TJB
237
238 pc = get_frame_pc (frame);
239 }
492d29ea
PA
240 CATCH (except, RETURN_MASK_ALL)
241 {
242 GDB_PY_HANDLE_EXCEPTION (except);
243 }
244 END_CATCH
f8f6f20b 245
74aedc46 246 return gdb_py_long_from_ulongest (pc);
f8f6f20b
TJB
247}
248
5f3b99cf
SS
249/* Implementation of gdb.Frame.read_register (self, register) -> gdb.Value.
250 Returns the value of a register in this frame. */
251
252static PyObject *
253frapy_read_register (PyObject *self, PyObject *args)
254{
5f3b99cf
SS
255 const char *regnum_str;
256 struct value *val = NULL;
257
258 if (!PyArg_ParseTuple (args, "s", &regnum_str))
259 return NULL;
260
492d29ea 261 TRY
5f3b99cf
SS
262 {
263 struct frame_info *frame;
264 int regnum;
265
266 FRAPY_REQUIRE_VALID (self, frame);
267
268 regnum = user_reg_map_name_to_regnum (get_frame_arch (frame),
269 regnum_str,
270 strlen (regnum_str));
271 if (regnum >= 0)
272 val = value_of_register (regnum, frame);
273
274 if (val == NULL)
275 PyErr_SetString (PyExc_ValueError, _("Unknown register."));
276 }
492d29ea
PA
277 CATCH (except, RETURN_MASK_ALL)
278 {
279 GDB_PY_HANDLE_EXCEPTION (except);
280 }
281 END_CATCH
5f3b99cf
SS
282
283 return val == NULL ? NULL : value_to_value_object (val);
284}
285
f3e9a817
PM
286/* Implementation of gdb.Frame.block (self) -> gdb.Block.
287 Returns the frame's code block. */
288
289static PyObject *
290frapy_block (PyObject *self, PyObject *args)
291{
292 struct frame_info *frame;
3977b71f 293 const struct block *block = NULL, *fn_block;
f3e9a817 294
492d29ea 295 TRY
f3e9a817 296 {
cc72b2a2 297 FRAPY_REQUIRE_VALID (self, frame);
57126e4a 298 block = get_frame_block (frame, NULL);
f3e9a817 299 }
492d29ea
PA
300 CATCH (except, RETURN_MASK_ALL)
301 {
302 GDB_PY_HANDLE_EXCEPTION (except);
303 }
304 END_CATCH
f3e9a817 305
57126e4a
TT
306 for (fn_block = block;
307 fn_block != NULL && BLOCK_FUNCTION (fn_block) == NULL;
308 fn_block = BLOCK_SUPERBLOCK (fn_block))
309 ;
310
311 if (block == NULL || fn_block == NULL || BLOCK_FUNCTION (fn_block) == NULL)
f3e9a817
PM
312 {
313 PyErr_SetString (PyExc_RuntimeError,
1e1d6920 314 _("Cannot locate block for frame."));
f3e9a817
PM
315 return NULL;
316 }
317
318 if (block)
57126e4a 319 {
08be3fe3
DE
320 return block_to_block_object
321 (block, symbol_objfile (BLOCK_FUNCTION (fn_block)));
57126e4a 322 }
f3e9a817
PM
323
324 Py_RETURN_NONE;
325}
326
327
328/* Implementation of gdb.Frame.function (self) -> gdb.Symbol.
329 Returns the symbol for the function corresponding to this frame. */
330
331static PyObject *
332frapy_function (PyObject *self, PyObject *args)
333{
334 struct symbol *sym = NULL;
335 struct frame_info *frame;
f3e9a817 336
492d29ea 337 TRY
f3e9a817 338 {
282a0691
TT
339 char *funname;
340 enum language funlang;
341
cc72b2a2 342 FRAPY_REQUIRE_VALID (self, frame);
f3e9a817 343
282a0691
TT
344 find_frame_funname (frame, &funname, &funlang, &sym);
345 xfree (funname);
f3e9a817 346 }
492d29ea
PA
347 CATCH (except, RETURN_MASK_ALL)
348 {
349 GDB_PY_HANDLE_EXCEPTION (except);
350 }
351 END_CATCH
f3e9a817
PM
352
353 if (sym)
354 return symbol_to_symbol_object (sym);
355
356 Py_RETURN_NONE;
357}
358
f8f6f20b
TJB
359/* Convert a frame_info struct to a Python Frame object.
360 Sets a Python exception and returns NULL on error. */
361
595939de 362PyObject *
f8f6f20b
TJB
363frame_info_to_frame_object (struct frame_info *frame)
364{
365 frame_object *frame_obj;
366
367 frame_obj = PyObject_New (frame_object, &frame_object_type);
368 if (frame_obj == NULL)
6cbc7c3d 369 return NULL;
f8f6f20b 370
492d29ea 371 TRY
f8f6f20b 372 {
f8f6f20b 373
76dce0be
PM
374 /* Try to get the previous frame, to determine if this is the last frame
375 in a corrupt stack. If so, we need to store the frame_id of the next
376 frame and not of this one (which is possibly invalid). */
377 if (get_prev_frame (frame) == NULL
378 && get_frame_unwind_stop_reason (frame) != UNWIND_NO_REASON
379 && get_next_frame (frame) != NULL)
380 {
381 frame_obj->frame_id = get_frame_id (get_next_frame (frame));
382 frame_obj->frame_id_is_next = 1;
383 }
384 else
385 {
386 frame_obj->frame_id = get_frame_id (frame);
387 frame_obj->frame_id_is_next = 0;
388 }
389 frame_obj->gdbarch = get_frame_arch (frame);
390 }
492d29ea 391 CATCH (except, RETURN_MASK_ALL)
1efd7661
PM
392 {
393 Py_DECREF (frame_obj);
394 gdbpy_convert_exception (except);
395 return NULL;
396 }
492d29ea
PA
397 END_CATCH
398
595939de 399 return (PyObject *) frame_obj;
f8f6f20b
TJB
400}
401
402/* Implementation of gdb.Frame.older (self) -> gdb.Frame.
403 Returns the frame immediately older (outer) to this frame, or None if
404 there isn't one. */
405
406static PyObject *
407frapy_older (PyObject *self, PyObject *args)
408{
dcf87832 409 struct frame_info *frame, *prev = NULL;
f8f6f20b
TJB
410 PyObject *prev_obj = NULL; /* Initialize to appease gcc warning. */
411
492d29ea 412 TRY
f8f6f20b 413 {
cc72b2a2 414 FRAPY_REQUIRE_VALID (self, frame);
f8f6f20b
TJB
415
416 prev = get_prev_frame (frame);
f8f6f20b 417 }
492d29ea
PA
418 CATCH (except, RETURN_MASK_ALL)
419 {
420 GDB_PY_HANDLE_EXCEPTION (except);
421 }
422 END_CATCH
f8f6f20b 423
dcf87832
TT
424 if (prev)
425 prev_obj = (PyObject *) frame_info_to_frame_object (prev);
426 else
427 {
428 Py_INCREF (Py_None);
429 prev_obj = Py_None;
430 }
431
f8f6f20b
TJB
432 return prev_obj;
433}
434
435/* Implementation of gdb.Frame.newer (self) -> gdb.Frame.
436 Returns the frame immediately newer (inner) to this frame, or None if
437 there isn't one. */
438
439static PyObject *
440frapy_newer (PyObject *self, PyObject *args)
441{
dcf87832 442 struct frame_info *frame, *next = NULL;
f8f6f20b
TJB
443 PyObject *next_obj = NULL; /* Initialize to appease gcc warning. */
444
492d29ea 445 TRY
f8f6f20b 446 {
cc72b2a2 447 FRAPY_REQUIRE_VALID (self, frame);
f8f6f20b
TJB
448
449 next = get_next_frame (frame);
f8f6f20b 450 }
492d29ea
PA
451 CATCH (except, RETURN_MASK_ALL)
452 {
453 GDB_PY_HANDLE_EXCEPTION (except);
454 }
455 END_CATCH
f8f6f20b 456
dcf87832
TT
457 if (next)
458 next_obj = (PyObject *) frame_info_to_frame_object (next);
459 else
460 {
461 Py_INCREF (Py_None);
462 next_obj = Py_None;
463 }
464
f8f6f20b
TJB
465 return next_obj;
466}
467
f3e9a817
PM
468/* Implementation of gdb.Frame.find_sal (self) -> gdb.Symtab_and_line.
469 Returns the frame's symtab and line. */
470
471static PyObject *
472frapy_find_sal (PyObject *self, PyObject *args)
473{
474 struct frame_info *frame;
475 struct symtab_and_line sal;
f3e9a817
PM
476 PyObject *sal_obj = NULL; /* Initialize to appease gcc warning. */
477
492d29ea 478 TRY
f3e9a817 479 {
cc72b2a2 480 FRAPY_REQUIRE_VALID (self, frame);
f3e9a817
PM
481
482 find_frame_sal (frame, &sal);
483 sal_obj = symtab_and_line_to_sal_object (sal);
484 }
492d29ea
PA
485 CATCH (except, RETURN_MASK_ALL)
486 {
487 GDB_PY_HANDLE_EXCEPTION (except);
488 }
489 END_CATCH
f3e9a817
PM
490
491 return sal_obj;
492}
493
dc00d89f
PM
494/* Implementation of gdb.Frame.read_var_value (self, variable,
495 [block]) -> gdb.Value. If the optional block argument is provided
496 start the search from that block, otherwise search from the frame's
497 current block (determined by examining the resume address of the
498 frame). The variable argument must be a string or an instance of a
8dc78533
JK
499 gdb.Symbol. The block argument must be an instance of gdb.Block. Returns
500 NULL on error, with a python exception set. */
f8f6f20b
TJB
501static PyObject *
502frapy_read_var (PyObject *self, PyObject *args)
503{
504 struct frame_info *frame;
dc00d89f 505 PyObject *sym_obj, *block_obj = NULL;
f8f6f20b 506 struct symbol *var = NULL; /* gcc-4.3.2 false warning. */
63e43d3a 507 const struct block *block = NULL;
f8f6f20b 508 struct value *val = NULL;
f8f6f20b 509
dc00d89f 510 if (!PyArg_ParseTuple (args, "O|O", &sym_obj, &block_obj))
f8f6f20b
TJB
511 return NULL;
512
f3e9a817
PM
513 if (PyObject_TypeCheck (sym_obj, &symbol_object_type))
514 var = symbol_object_to_symbol (sym_obj);
515 else if (gdbpy_is_string (sym_obj))
f8f6f20b
TJB
516 {
517 char *var_name;
f8f6f20b 518 struct cleanup *cleanup;
f8f6f20b
TJB
519
520 var_name = python_string_to_target_string (sym_obj);
521 if (!var_name)
522 return NULL;
523 cleanup = make_cleanup (xfree, var_name);
524
dc00d89f
PM
525 if (block_obj)
526 {
527 block = block_object_to_block (block_obj);
528 if (!block)
529 {
530 PyErr_SetString (PyExc_RuntimeError,
531 _("Second argument must be block."));
af1c6971 532 do_cleanups (cleanup);
dc00d89f
PM
533 return NULL;
534 }
535 }
536
492d29ea 537 TRY
f8f6f20b 538 {
63e43d3a 539 struct block_symbol lookup_sym;
cc72b2a2 540 FRAPY_REQUIRE_VALID (self, frame);
f8f6f20b 541
dc00d89f 542 if (!block)
626e7282 543 block = get_frame_block (frame, NULL);
63e43d3a
PMR
544 lookup_sym = lookup_symbol (var_name, block, VAR_DOMAIN, NULL);
545 var = lookup_sym.symbol;
546 block = lookup_sym.block;
f8f6f20b 547 }
492d29ea 548 CATCH (except, RETURN_MASK_ALL)
af1c6971
TT
549 {
550 do_cleanups (cleanup);
f3300387
TT
551 gdbpy_convert_exception (except);
552 return NULL;
af1c6971 553 }
492d29ea 554 END_CATCH
f8f6f20b
TJB
555
556 if (!var)
557 {
558 PyErr_Format (PyExc_ValueError,
044c0f87 559 _("Variable '%s' not found."), var_name);
f8f6f20b
TJB
560 do_cleanups (cleanup);
561
562 return NULL;
563 }
564
565 do_cleanups (cleanup);
566 }
567 else
568 {
569 PyErr_SetString (PyExc_TypeError,
044c0f87 570 _("Argument must be a symbol or string."));
f8f6f20b
TJB
571 return NULL;
572 }
573
492d29ea 574 TRY
f8f6f20b 575 {
cc72b2a2 576 FRAPY_REQUIRE_VALID (self, frame);
f8f6f20b 577
63e43d3a 578 val = read_var_value (var, block, frame);
f8f6f20b 579 }
492d29ea
PA
580 CATCH (except, RETURN_MASK_ALL)
581 {
582 GDB_PY_HANDLE_EXCEPTION (except);
583 }
584 END_CATCH
f8f6f20b 585
dc00d89f 586 return value_to_value_object (val);
f8f6f20b
TJB
587}
588
f3e9a817
PM
589/* Select this frame. */
590
591static PyObject *
592frapy_select (PyObject *self, PyObject *args)
593{
594 struct frame_info *fi;
f3e9a817 595
492d29ea 596 TRY
f3e9a817 597 {
cc72b2a2 598 FRAPY_REQUIRE_VALID (self, fi);
f3e9a817
PM
599
600 select_frame (fi);
601 }
492d29ea
PA
602 CATCH (except, RETURN_MASK_ALL)
603 {
604 GDB_PY_HANDLE_EXCEPTION (except);
605 }
606 END_CATCH
f3e9a817
PM
607
608 Py_RETURN_NONE;
609}
610
d8e22779
TT
611/* Implementation of gdb.newest_frame () -> gdb.Frame.
612 Returns the newest frame object. */
613
614PyObject *
615gdbpy_newest_frame (PyObject *self, PyObject *args)
616{
dcf87832 617 struct frame_info *frame = NULL;
d8e22779 618
492d29ea 619 TRY
d8e22779
TT
620 {
621 frame = get_current_frame ();
d8e22779 622 }
492d29ea
PA
623 CATCH (except, RETURN_MASK_ALL)
624 {
625 GDB_PY_HANDLE_EXCEPTION (except);
626 }
627 END_CATCH
d8e22779 628
dcf87832 629 return frame_info_to_frame_object (frame);
d8e22779
TT
630}
631
f8f6f20b
TJB
632/* Implementation of gdb.selected_frame () -> gdb.Frame.
633 Returns the selected frame object. */
634
635PyObject *
636gdbpy_selected_frame (PyObject *self, PyObject *args)
637{
dcf87832 638 struct frame_info *frame = NULL;
f8f6f20b 639
492d29ea 640 TRY
f8f6f20b
TJB
641 {
642 frame = get_selected_frame ("No frame is currently selected.");
f8f6f20b 643 }
492d29ea
PA
644 CATCH (except, RETURN_MASK_ALL)
645 {
646 GDB_PY_HANDLE_EXCEPTION (except);
647 }
648 END_CATCH
f8f6f20b 649
dcf87832 650 return frame_info_to_frame_object (frame);
f8f6f20b
TJB
651}
652
653/* Implementation of gdb.stop_reason_string (Integer) -> String.
654 Return a string explaining the unwind stop reason. */
655
656PyObject *
657gdbpy_frame_stop_reason_string (PyObject *self, PyObject *args)
658{
659 int reason;
660 const char *str;
661
662 if (!PyArg_ParseTuple (args, "i", &reason))
663 return NULL;
664
2231f1fb 665 if (reason < UNWIND_FIRST || reason > UNWIND_LAST)
f8f6f20b 666 {
256458bc 667 PyErr_SetString (PyExc_ValueError,
044c0f87 668 _("Invalid frame stop reason."));
f8f6f20b
TJB
669 return NULL;
670 }
671
aead7601 672 str = unwind_stop_reason_to_string ((enum unwind_stop_reason) reason);
f8f6f20b
TJB
673 return PyUnicode_Decode (str, strlen (str), host_charset (), NULL);
674}
675
676/* Implements the equality comparison for Frame objects.
677 All other comparison operators will throw a TypeError Python exception,
678 as they aren't valid for frames. */
679
680static PyObject *
681frapy_richcompare (PyObject *self, PyObject *other, int op)
682{
18e8c3bc
TT
683 int result;
684
685 if (!PyObject_TypeCheck (other, &frame_object_type)
686 || (op != Py_EQ && op != Py_NE))
f8f6f20b 687 {
18e8c3bc
TT
688 Py_INCREF (Py_NotImplemented);
689 return Py_NotImplemented;
f8f6f20b
TJB
690 }
691
692 if (frame_id_eq (((frame_object *) self)->frame_id,
693 ((frame_object *) other)->frame_id))
18e8c3bc
TT
694 result = Py_EQ;
695 else
696 result = Py_NE;
f8f6f20b 697
18e8c3bc
TT
698 if (op == result)
699 Py_RETURN_TRUE;
f8f6f20b
TJB
700 Py_RETURN_FALSE;
701}
702
703/* Sets up the Frame API in the gdb module. */
704
999633ed 705int
f8f6f20b
TJB
706gdbpy_initialize_frames (void)
707{
6a1b1664 708 frame_object_type.tp_new = PyType_GenericNew;
f8f6f20b 709 if (PyType_Ready (&frame_object_type) < 0)
999633ed 710 return -1;
f8f6f20b 711
9a2b4c1b
MS
712 /* Note: These would probably be best exposed as class attributes of
713 Frame, but I don't know how to do it except by messing with the
714 type's dictionary. That seems too messy. */
999633ed
TT
715 if (PyModule_AddIntConstant (gdb_module, "NORMAL_FRAME", NORMAL_FRAME) < 0
716 || PyModule_AddIntConstant (gdb_module, "DUMMY_FRAME", DUMMY_FRAME) < 0
717 || PyModule_AddIntConstant (gdb_module, "INLINE_FRAME", INLINE_FRAME) < 0
718 || PyModule_AddIntConstant (gdb_module, "TAILCALL_FRAME",
719 TAILCALL_FRAME) < 0
720 || PyModule_AddIntConstant (gdb_module, "SIGTRAMP_FRAME",
721 SIGTRAMP_FRAME) < 0
722 || PyModule_AddIntConstant (gdb_module, "ARCH_FRAME", ARCH_FRAME) < 0
723 || PyModule_AddIntConstant (gdb_module, "SENTINEL_FRAME",
724 SENTINEL_FRAME) < 0)
725 return -1;
2231f1fb
KP
726
727#define SET(name, description) \
999633ed
TT
728 if (PyModule_AddIntConstant (gdb_module, "FRAME_"#name, name) < 0) \
729 return -1;
2231f1fb
KP
730#include "unwind_stop_reasons.def"
731#undef SET
f8f6f20b 732
aa36459a
TT
733 return gdb_pymodule_addobject (gdb_module, "Frame",
734 (PyObject *) &frame_object_type);
f8f6f20b
TJB
735}
736
737\f
738
739static PyMethodDef frame_object_methods[] = {
740 { "is_valid", frapy_is_valid, METH_NOARGS,
741 "is_valid () -> Boolean.\n\
742Return true if this frame is valid, false if not." },
743 { "name", frapy_name, METH_NOARGS,
744 "name () -> String.\n\
745Return the function name of the frame, or None if it can't be determined." },
746 { "type", frapy_type, METH_NOARGS,
747 "type () -> Integer.\n\
748Return the type of the frame." },
bea883fd
SCR
749 { "architecture", frapy_arch, METH_NOARGS,
750 "architecture () -> gdb.Architecture.\n\
751Return the architecture of the frame." },
f8f6f20b
TJB
752 { "unwind_stop_reason", frapy_unwind_stop_reason, METH_NOARGS,
753 "unwind_stop_reason () -> Integer.\n\
754Return the reason why it's not possible to find frames older than this." },
755 { "pc", frapy_pc, METH_NOARGS,
756 "pc () -> Long.\n\
757Return the frame's resume address." },
5f3b99cf
SS
758 { "read_register", frapy_read_register, METH_VARARGS,
759 "read_register (register_name) -> gdb.Value\n\
760Return the value of the register in the frame." },
f3e9a817
PM
761 { "block", frapy_block, METH_NOARGS,
762 "block () -> gdb.Block.\n\
763Return the frame's code block." },
764 { "function", frapy_function, METH_NOARGS,
765 "function () -> gdb.Symbol.\n\
766Returns the symbol for the function corresponding to this frame." },
f8f6f20b
TJB
767 { "older", frapy_older, METH_NOARGS,
768 "older () -> gdb.Frame.\n\
769Return the frame that called this frame." },
770 { "newer", frapy_newer, METH_NOARGS,
771 "newer () -> gdb.Frame.\n\
772Return the frame called by this frame." },
f3e9a817
PM
773 { "find_sal", frapy_find_sal, METH_NOARGS,
774 "find_sal () -> gdb.Symtab_and_line.\n\
775Return the frame's symtab and line." },
f8f6f20b
TJB
776 { "read_var", frapy_read_var, METH_VARARGS,
777 "read_var (variable) -> gdb.Value.\n\
778Return the value of the variable in this frame." },
f3e9a817
PM
779 { "select", frapy_select, METH_NOARGS,
780 "Select this frame as the user's current frame." },
f8f6f20b
TJB
781 {NULL} /* Sentinel */
782};
783
f0823d2c 784PyTypeObject frame_object_type = {
9a27f2c6 785 PyVarObject_HEAD_INIT (NULL, 0)
f8f6f20b
TJB
786 "gdb.Frame", /* tp_name */
787 sizeof (frame_object), /* tp_basicsize */
788 0, /* tp_itemsize */
789 0, /* tp_dealloc */
790 0, /* tp_print */
791 0, /* tp_getattr */
792 0, /* tp_setattr */
793 0, /* tp_compare */
794 0, /* tp_repr */
795 0, /* tp_as_number */
796 0, /* tp_as_sequence */
797 0, /* tp_as_mapping */
798 0, /* tp_hash */
799 0, /* tp_call */
800 frapy_str, /* tp_str */
801 0, /* tp_getattro */
802 0, /* tp_setattro */
803 0, /* tp_as_buffer */
804 Py_TPFLAGS_DEFAULT, /* tp_flags */
805 "GDB frame object", /* tp_doc */
806 0, /* tp_traverse */
807 0, /* tp_clear */
808 frapy_richcompare, /* tp_richcompare */
809 0, /* tp_weaklistoffset */
810 0, /* tp_iter */
811 0, /* tp_iternext */
812 frame_object_methods, /* tp_methods */
813 0, /* tp_members */
814 0, /* tp_getset */
815 0, /* tp_base */
816 0, /* tp_dict */
817 0, /* tp_descr_get */
818 0, /* tp_descr_set */
819 0, /* tp_dictoffset */
820 0, /* tp_init */
821 0, /* tp_alloc */
f8f6f20b 822};
This page took 1.222787 seconds and 4 git commands to generate.