Repository navigation
Expand file tree
/
Copy pathpython.c
More file actions
2116 lines (1747 loc) · 58.8 KB
/
Copy pathpython.c
File metadata and controls
2116 lines (1747 loc) · 58.8 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
/* General python/gdb code
Copyright (C) 2008-2019 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "defs.h"
#include "arch-utils.h"
#include "command.h"
#include "ui-out.h"
#include "cli/cli-script.h"
#include "gdbcmd.h"
#include "progspace.h"
#include "objfiles.h"
#include "value.h"
#include "language.h"
#include "event-loop.h"
#include "serial.h"
#include "readline/tilde.h"
#include "python.h"
#include "extension-priv.h"
#include "cli/cli-utils.h"
#include <ctype.h>
#include "location.h"
#include "ser-event.h"
/* Declared constants and enum for python stack printing. */
static const char python_excp_none[] = "none";
static const char python_excp_full[] = "full";
static const char python_excp_message[] = "message";
/* "set python print-stack" choices. */
static const char *const python_excp_enums[] =
{
python_excp_none,
python_excp_full,
python_excp_message,
NULL
};
/* The exception printing variable. 'full' if we want to print the
error message and stack, 'none' if we want to print nothing, and
'message' if we only want to print the error message. 'message' is
the default. */
static const char *gdbpy_should_print_stack = python_excp_message;
#ifdef HAVE_PYTHON
/* Forward decls, these are defined later. */
extern const struct extension_language_script_ops python_extension_script_ops;
extern const struct extension_language_ops python_extension_ops;
#endif
/* The main struct describing GDB's interface to the Python
extension language. */
const struct extension_language_defn extension_language_python =
{
EXT_LANG_PYTHON,
"python",
"Python",
".py",
"-gdb.py",
python_control,
#ifdef HAVE_PYTHON
&python_extension_script_ops,
&python_extension_ops
#else
NULL,
NULL
#endif
};
#ifdef HAVE_PYTHON
#include "cli/cli-decode.h"
#include "charset.h"
#include "top.h"
#include "python-internal.h"
#include "linespec.h"
#include "source.h"
#include "version.h"
#include "target.h"
#include "gdbthread.h"
#include "interps.h"
#include "event-top.h"
#include "py-event.h"
/* True if Python has been successfully initialized, false
otherwise. */
int gdb_python_initialized;
extern PyMethodDef python_GdbMethods[];
#ifdef IS_PY3K
extern struct PyModuleDef python_GdbModuleDef;
#endif
PyObject *gdb_module;
PyObject *gdb_python_module;
/* Some string constants we may wish to use. */
PyObject *gdbpy_to_string_cst;
PyObject *gdbpy_children_cst;
PyObject *gdbpy_display_hint_cst;
PyObject *gdbpy_doc_cst;
PyObject *gdbpy_enabled_cst;
PyObject *gdbpy_value_cst;
/* The GdbError exception. */
PyObject *gdbpy_gdberror_exc;
/* The `gdb.error' base class. */
PyObject *gdbpy_gdb_error;
/* The `gdb.MemoryError' exception. */
PyObject *gdbpy_gdb_memory_error;
static script_sourcer_func gdbpy_source_script;
static objfile_script_sourcer_func gdbpy_source_objfile_script;
static objfile_script_executor_func gdbpy_execute_objfile_script;
static void gdbpy_finish_initialization
(const struct extension_language_defn *);
static int gdbpy_initialized (const struct extension_language_defn *);
static void gdbpy_eval_from_control_command
(const struct extension_language_defn *, struct command_line *cmd);
static void gdbpy_start_type_printers (const struct extension_language_defn *,
struct ext_lang_type_printers *);
static enum ext_lang_rc gdbpy_apply_type_printers
(const struct extension_language_defn *,
const struct ext_lang_type_printers *, struct type *, char **);
static void gdbpy_free_type_printers (const struct extension_language_defn *,
struct ext_lang_type_printers *);
static void gdbpy_set_quit_flag (const struct extension_language_defn *);
static int gdbpy_check_quit_flag (const struct extension_language_defn *);
static enum ext_lang_rc gdbpy_before_prompt_hook
(const struct extension_language_defn *, const char *current_gdb_prompt);
/* The interface between gdb proper and loading of python scripts. */
const struct extension_language_script_ops python_extension_script_ops =
{
gdbpy_source_script,
gdbpy_source_objfile_script,
gdbpy_execute_objfile_script,
gdbpy_auto_load_enabled
};
/* The interface between gdb proper and python extensions. */
const struct extension_language_ops python_extension_ops =
{
gdbpy_finish_initialization,
gdbpy_initialized,
gdbpy_eval_from_control_command,
gdbpy_start_type_printers,
gdbpy_apply_type_printers,
gdbpy_free_type_printers,
gdbpy_apply_val_pretty_printer,
gdbpy_apply_frame_filter,
gdbpy_preserve_values,
gdbpy_breakpoint_has_cond,
gdbpy_breakpoint_cond_says_stop,
gdbpy_set_quit_flag,
gdbpy_check_quit_flag,
gdbpy_before_prompt_hook,
gdbpy_get_matching_xmethod_workers,
};
/* Architecture and language to be used in callbacks from
the Python interpreter. */
struct gdbarch *python_gdbarch;
const struct language_defn *python_language;
gdbpy_enter::gdbpy_enter (struct gdbarch *gdbarch,
const struct language_defn *language)
: m_gdbarch (python_gdbarch),
m_language (python_language)
{
/* We should not ever enter Python unless initialized. */
if (!gdb_python_initialized)
error (_("Python not initialized"));
m_previous_active = set_active_ext_lang (&extension_language_python);
m_state = PyGILState_Ensure ();
python_gdbarch = gdbarch;
python_language = language;
/* Save it and ensure ! PyErr_Occurred () afterwards. */
m_error.emplace ();
}
gdbpy_enter::~gdbpy_enter ()
{
/* Leftover Python error is forbidden by Python Exception Handling. */
if (PyErr_Occurred ())
{
/* This order is similar to the one calling error afterwards. */
gdbpy_print_stack ();
warning (_("internal error: Unhandled Python exception"));
}
m_error->restore ();
PyGILState_Release (m_state);
python_gdbarch = m_gdbarch;
python_language = m_language;
restore_active_ext_lang (m_previous_active);
}
/* Set the quit flag. */
static void
gdbpy_set_quit_flag (const struct extension_language_defn *extlang)
{
PyErr_SetInterrupt ();
}
/* Return true if the quit flag has been set, false otherwise. */
static int
gdbpy_check_quit_flag (const struct extension_language_defn *extlang)
{
return PyOS_InterruptOccurred ();
}
/* Evaluate a Python command like PyRun_SimpleString, but uses
Py_single_input which prints the result of expressions, and does
not automatically print the stack on errors. */
static int
eval_python_command (const char *command)
{
PyObject *m, *d;
m = PyImport_AddModule ("__main__");
if (m == NULL)
return -1;
d = PyModule_GetDict (m);
if (d == NULL)
return -1;
gdbpy_ref<> v (PyRun_StringFlags (command, Py_single_input, d, d, NULL));
if (v == NULL)
return -1;
#ifndef IS_PY3K
if (Py_FlushLine ())
PyErr_Clear ();
#endif
return 0;
}
/* Implementation of the gdb "python-interactive" command. */
static void
python_interactive_command (const char *arg, int from_tty)
{
struct ui *ui = current_ui;
int err;
scoped_restore save_async = make_scoped_restore (¤t_ui->async, 0);
arg = skip_spaces (arg);
gdbpy_enter enter_py (get_current_arch (), current_language);
if (arg && *arg)
{
std::string script = std::string (arg) + "\n";
err = eval_python_command (script.c_str ());
}
else
{
err = PyRun_InteractiveLoop (ui->instream, "<stdin>");
dont_repeat ();
}
if (err)
{
gdbpy_print_stack ();
error (_("Error while executing Python code."));
}
}
/* A wrapper around PyRun_SimpleFile. FILE is the Python script to run
named FILENAME.
On Windows hosts few users would build Python themselves (this is no
trivial task on this platform), and thus use binaries built by
someone else instead. There may happen situation where the Python
library and GDB are using two different versions of the C runtime
library. Python, being built with VC, would use one version of the
msvcr DLL (Eg. msvcr100.dll), while MinGW uses msvcrt.dll.
A FILE * from one runtime does not necessarily operate correctly in
the other runtime.
To work around this potential issue, we create on Windows hosts the
FILE object using Python routines, thus making sure that it is
compatible with the Python library. */
static void
python_run_simple_file (FILE *file, const char *filename)
{
#ifndef _WIN32
PyRun_SimpleFile (file, filename);
#else /* _WIN32 */
/* Because we have a string for a filename, and are using Python to
open the file, we need to expand any tilde in the path first. */
gdb::unique_xmalloc_ptr<char> full_path (tilde_expand (filename));
gdbpy_ref<> python_file (PyFile_FromString (full_path.get (), (char *) "r"));
if (python_file == NULL)
{
gdbpy_print_stack ();
error (_("Error while opening file: %s"), full_path.get ());
}
PyRun_SimpleFile (PyFile_AsFile (python_file.get ()), filename);
#endif /* _WIN32 */
}
/* Given a command_line, return a command string suitable for passing
to Python. Lines in the string are separated by newlines. */
static std::string
compute_python_string (struct command_line *l)
{
struct command_line *iter;
std::string script;
for (iter = l; iter; iter = iter->next)
{
script += iter->line;
script += '\n';
}
return script;
}
/* Take a command line structure representing a 'python' command, and
evaluate its body using the Python interpreter. */
static void
gdbpy_eval_from_control_command (const struct extension_language_defn *extlang,
struct command_line *cmd)
{
int ret;
if (cmd->body_list_1 != nullptr)
error (_("Invalid \"python\" block structure."));
gdbpy_enter enter_py (get_current_arch (), current_language);
std::string script = compute_python_string (cmd->body_list_0.get ());
ret = PyRun_SimpleString (script.c_str ());
if (ret)
error (_("Error while executing Python code."));
}
/* Implementation of the gdb "python" command. */
static void
python_command (const char *arg, int from_tty)
{
gdbpy_enter enter_py (get_current_arch (), current_language);
scoped_restore save_async = make_scoped_restore (¤t_ui->async, 0);
arg = skip_spaces (arg);
if (arg && *arg)
{
if (PyRun_SimpleString (arg))
error (_("Error while executing Python code."));
}
else
{
counted_command_line l = get_command_line (python_control, "");
execute_control_command_untraced (l.get ());
}
}
/* Transform a gdb parameters's value into a Python value. May return
NULL (and set a Python exception) on error. Helper function for
get_parameter. */
PyObject *
gdbpy_parameter_value (enum var_types type, void *var)
{
switch (type)
{
case var_string:
case var_string_noescape:
case var_optional_filename:
case var_filename:
case var_enum:
{
const char *str = *(char **) var;
if (! str)
str = "";
return host_string_to_python_string (str).release ();
}
case var_boolean:
{
if (* (int *) var)
Py_RETURN_TRUE;
else
Py_RETURN_FALSE;
}
case var_auto_boolean:
{
enum auto_boolean ab = * (enum auto_boolean *) var;
if (ab == AUTO_BOOLEAN_TRUE)
Py_RETURN_TRUE;
else if (ab == AUTO_BOOLEAN_FALSE)
Py_RETURN_FALSE;
else
Py_RETURN_NONE;
}
case var_integer:
if ((* (int *) var) == INT_MAX)
Py_RETURN_NONE;
/* Fall through. */
case var_zinteger:
case var_zuinteger_unlimited:
return PyLong_FromLong (* (int *) var);
case var_uinteger:
{
unsigned int val = * (unsigned int *) var;
if (val == UINT_MAX)
Py_RETURN_NONE;
return PyLong_FromUnsignedLong (val);
}
case var_zuinteger:
{
unsigned int val = * (unsigned int *) var;
return PyLong_FromUnsignedLong (val);
}
}
return PyErr_Format (PyExc_RuntimeError,
_("Programmer error: unhandled type."));
}
/* A Python function which returns a gdb parameter's value as a Python
value. */
static PyObject *
gdbpy_parameter (PyObject *self, PyObject *args)
{
struct cmd_list_element *alias, *prefix, *cmd;
const char *arg;
int found = -1;
if (! PyArg_ParseTuple (args, "s", &arg))
return NULL;
std::string newarg = std::string ("show ") + arg;
TRY
{
found = lookup_cmd_composition (newarg.c_str (), &alias, &prefix, &cmd);
}
CATCH (ex, RETURN_MASK_ALL)
{
GDB_PY_HANDLE_EXCEPTION (ex);
}
END_CATCH
if (!found)
return PyErr_Format (PyExc_RuntimeError,
_("Could not find parameter `%s'."), arg);
if (! cmd->var)
return PyErr_Format (PyExc_RuntimeError,
_("`%s' is not a parameter."), arg);
return gdbpy_parameter_value (cmd->var_type, cmd->var);
}
/* Wrapper for target_charset. */
static PyObject *
gdbpy_target_charset (PyObject *self, PyObject *args)
{
const char *cset = target_charset (python_gdbarch);
return PyUnicode_Decode (cset, strlen (cset), host_charset (), NULL);
}
/* Wrapper for target_wide_charset. */
static PyObject *
gdbpy_target_wide_charset (PyObject *self, PyObject *args)
{
const char *cset = target_wide_charset (python_gdbarch);
return PyUnicode_Decode (cset, strlen (cset), host_charset (), NULL);
}
/* A Python function which evaluates a string using the gdb CLI. */
static PyObject *
execute_gdb_command (PyObject *self, PyObject *args, PyObject *kw)
{
const char *arg;
PyObject *from_tty_obj = NULL, *to_string_obj = NULL;
int from_tty, to_string;
static const char *keywords[] = { "command", "from_tty", "to_string", NULL };
if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "s|O!O!", keywords, &arg,
&PyBool_Type, &from_tty_obj,
&PyBool_Type, &to_string_obj))
return NULL;
from_tty = 0;
if (from_tty_obj)
{
int cmp = PyObject_IsTrue (from_tty_obj);
if (cmp < 0)
return NULL;
from_tty = cmp;
}
to_string = 0;
if (to_string_obj)
{
int cmp = PyObject_IsTrue (to_string_obj);
if (cmp < 0)
return NULL;
to_string = cmp;
}
std::string to_string_res;
scoped_restore preventer = prevent_dont_repeat ();
TRY
{
struct interp *interp;
std::string arg_copy = arg;
bool first = true;
char *save_ptr = nullptr;
auto reader
= [&] ()
{
const char *result = strtok_r (first ? &arg_copy[0] : nullptr,
"\n", &save_ptr);
first = false;
return result;
};
counted_command_line lines = read_command_lines_1 (reader, 1, nullptr);
{
scoped_restore save_async = make_scoped_restore (¤t_ui->async,
0);
scoped_restore save_uiout = make_scoped_restore (¤t_uiout);
/* Use the console interpreter uiout to have the same print format
for console or MI. */
interp = interp_lookup (current_ui, "console");
current_uiout = interp->interp_ui_out ();
if (to_string)
to_string_res = execute_control_commands_to_string (lines.get (),
from_tty);
else
execute_control_commands (lines.get (), from_tty);
}
/* Do any commands attached to breakpoint we stopped at. */
bpstat_do_actions ();
}
CATCH (except, RETURN_MASK_ALL)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
END_CATCH
if (to_string)
return PyString_FromString (to_string_res.c_str ());
Py_RETURN_NONE;
}
/* Implementation of Python rbreak command. Take a REGEX and
optionally a MINSYMS, THROTTLE and SYMTABS keyword and return a
Python list that contains newly set breakpoints that match that
criteria. REGEX refers to a GDB format standard regex pattern of
symbols names to search; MINSYMS is an optional boolean (default
False) that indicates if the function should search GDB's minimal
symbols; THROTTLE is an optional integer (default unlimited) that
indicates the maximum amount of breakpoints allowable before the
function exits (note, if the throttle bound is passed, no
breakpoints will be set and a runtime error returned); SYMTABS is
an optional Python iterable that contains a set of gdb.Symtabs to
constrain the search within. */
static PyObject *
gdbpy_rbreak (PyObject *self, PyObject *args, PyObject *kw)
{
/* A simple type to ensure clean up of a vector of allocated strings
when a C interface demands a const char *array[] type
interface. */
struct symtab_list_type
{
~symtab_list_type ()
{
for (const char *elem: vec)
xfree ((void *) elem);
}
std::vector<const char *> vec;
};
char *regex = NULL;
std::vector<symbol_search> symbols;
unsigned long count = 0;
PyObject *symtab_list = NULL;
PyObject *minsyms_p_obj = NULL;
int minsyms_p = 0;
unsigned int throttle = 0;
static const char *keywords[] = {"regex","minsyms", "throttle",
"symtabs", NULL};
symtab_list_type symtab_paths;
if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "s|O!IO", keywords,
®ex, &PyBool_Type,
&minsyms_p_obj, &throttle,
&symtab_list))
return NULL;
/* Parse minsyms keyword. */
if (minsyms_p_obj != NULL)
{
int cmp = PyObject_IsTrue (minsyms_p_obj);
if (cmp < 0)
return NULL;
minsyms_p = cmp;
}
/* The "symtabs" keyword is any Python iterable object that returns
a gdb.Symtab on each iteration. If specified, iterate through
the provided gdb.Symtabs and extract their full path. As
python_string_to_target_string returns a
gdb::unique_xmalloc_ptr<char> and a vector containing these types
cannot be coerced to a const char **p[] via the vector.data call,
release the value from the unique_xmalloc_ptr and place it in a
simple type symtab_list_type (which holds the vector and a
destructor that frees the contents of the allocated strings. */
if (symtab_list != NULL)
{
gdbpy_ref<> iter (PyObject_GetIter (symtab_list));
if (iter == NULL)
return NULL;
while (true)
{
gdbpy_ref<> next (PyIter_Next (iter.get ()));
if (next == NULL)
{
if (PyErr_Occurred ())
return NULL;
break;
}
gdbpy_ref<> obj_name (PyObject_GetAttrString (next.get (),
"filename"));
if (obj_name == NULL)
return NULL;
/* Is the object file still valid? */
if (obj_name == Py_None)
continue;
gdb::unique_xmalloc_ptr<char> filename =
python_string_to_target_string (obj_name.get ());
if (filename == NULL)
return NULL;
/* Make sure there is a definite place to store the value of
filename before it is released. */
symtab_paths.vec.push_back (nullptr);
symtab_paths.vec.back () = filename.release ();
}
}
if (symtab_list)
{
const char **files = symtab_paths.vec.data ();
symbols = search_symbols (regex, FUNCTIONS_DOMAIN, NULL,
symtab_paths.vec.size (), files);
}
else
symbols = search_symbols (regex, FUNCTIONS_DOMAIN, NULL, 0, NULL);
/* Count the number of symbols (both symbols and optionally minimal
symbols) so we can correctly check the throttle limit. */
for (const symbol_search &p : symbols)
{
/* Minimal symbols included? */
if (minsyms_p)
{
if (p.msymbol.minsym != NULL)
count++;
}
if (p.symbol != NULL)
count++;
}
/* Check throttle bounds and exit if in excess. */
if (throttle != 0 && count > throttle)
{
PyErr_SetString (PyExc_RuntimeError,
_("Number of breakpoints exceeds throttled maximum."));
return NULL;
}
gdbpy_ref<> return_list (PyList_New (0));
if (return_list == NULL)
return NULL;
/* Construct full path names for symbols and call the Python
breakpoint constructor on the resulting names. Be tolerant of
individual breakpoint failures. */
for (const symbol_search &p : symbols)
{
std::string symbol_name;
/* Skipping minimal symbols? */
if (minsyms_p == 0)
if (p.msymbol.minsym != NULL)
continue;
if (p.msymbol.minsym == NULL)
{
struct symtab *symtab = symbol_symtab (p.symbol);
const char *fullname = symtab_to_fullname (symtab);
symbol_name = fullname;
symbol_name += ":";
symbol_name += SYMBOL_LINKAGE_NAME (p.symbol);
}
else
symbol_name = MSYMBOL_LINKAGE_NAME (p.msymbol.minsym);
gdbpy_ref<> argList (Py_BuildValue("(s)", symbol_name.c_str ()));
gdbpy_ref<> obj (PyObject_CallObject ((PyObject *)
&breakpoint_object_type,
argList.get ()));
/* Tolerate individual breakpoint failures. */
if (obj == NULL)
gdbpy_print_stack ();
else
{
if (PyList_Append (return_list.get (), obj.get ()) == -1)
return NULL;
}
}
return return_list.release ();
}
/* A Python function which is a wrapper for decode_line_1. */
static PyObject *
gdbpy_decode_line (PyObject *self, PyObject *args)
{
const char *arg = NULL;
gdbpy_ref<> result;
gdbpy_ref<> unparsed;
event_location_up location;
if (! PyArg_ParseTuple (args, "|s", &arg))
return NULL;
if (arg != NULL)
location = string_to_event_location_basic (&arg, python_language,
symbol_name_match_type::WILD);
std::vector<symtab_and_line> decoded_sals;
symtab_and_line def_sal;
gdb::array_view<symtab_and_line> sals;
TRY
{
if (location != NULL)
{
decoded_sals = decode_line_1 (location.get (), 0, NULL, NULL, 0);
sals = decoded_sals;
}
else
{
set_default_source_symtab_and_line ();
def_sal = get_current_source_symtab_and_line ();
sals = def_sal;
}
}
CATCH (ex, RETURN_MASK_ALL)
{
/* We know this will always throw. */
gdbpy_convert_exception (ex);
return NULL;
}
END_CATCH
if (!sals.empty ())
{
result.reset (PyTuple_New (sals.size ()));
if (result == NULL)
return NULL;
for (size_t i = 0; i < sals.size (); ++i)
{
PyObject *obj = symtab_and_line_to_sal_object (sals[i]);
if (obj == NULL)
return NULL;
PyTuple_SetItem (result.get (), i, obj);
}
}
else
result = gdbpy_ref<>::new_reference (Py_None);
gdbpy_ref<> return_result (PyTuple_New (2));
if (return_result == NULL)
return NULL;
if (arg != NULL && strlen (arg) > 0)
{
unparsed.reset (PyString_FromString (arg));
if (unparsed == NULL)
return NULL;
}
else
unparsed = gdbpy_ref<>::new_reference (Py_None);
PyTuple_SetItem (return_result.get (), 0, unparsed.release ());
PyTuple_SetItem (return_result.get (), 1, result.release ());
return return_result.release ();
}
/* Parse a string and evaluate it as an expression. */
static PyObject *
gdbpy_parse_and_eval (PyObject *self, PyObject *args)
{
const char *expr_str;
struct value *result = NULL;
if (!PyArg_ParseTuple (args, "s", &expr_str))
return NULL;
TRY
{
result = parse_and_eval (expr_str);
}
CATCH (except, RETURN_MASK_ALL)
{
GDB_PY_HANDLE_EXCEPTION (except);
}
END_CATCH
return value_to_value_object (result);
}
/* Implementation of gdb.invalidate_cached_frames. */
static PyObject *
gdbpy_invalidate_cached_frames (PyObject *self, PyObject *args)
{
reinit_frame_cache ();
Py_RETURN_NONE;
}
/* Read a file as Python code.
This is the extension_language_script_ops.script_sourcer "method".
FILE is the file to load. FILENAME is name of the file FILE.
This does not throw any errors. If an exception occurs python will print
the traceback and clear the error indicator. */
static void
gdbpy_source_script (const struct extension_language_defn *extlang,
FILE *file, const char *filename)
{
gdbpy_enter enter_py (get_current_arch (), current_language);
python_run_simple_file (file, filename);
}
/* Posting and handling events. */
/* A single event. */
struct gdbpy_event
{
/* The Python event. This is just a callable object. */
PyObject *event;
/* The next event. */
struct gdbpy_event *next;
};
/* All pending events. */
static struct gdbpy_event *gdbpy_event_list;
/* The final link of the event list. */
static struct gdbpy_event **gdbpy_event_list_end;
/* So that we can wake up the main thread even when it is blocked in
poll(). */
static struct serial_event *gdbpy_serial_event;
/* The file handler callback. This reads from the internal pipe, and
then processes the Python event queue. This will always be run in
the main gdb thread. */
static void
gdbpy_run_events (int error, gdb_client_data client_data)
{
gdbpy_enter enter_py (get_current_arch (), current_language);
/* Clear the event fd. Do this before flushing the events list, so
that any new event post afterwards is sure to re-awake the event
loop. */
serial_event_clear (gdbpy_serial_event);
while (gdbpy_event_list)
{
/* Dispatching the event might push a new element onto the event
loop, so we update here "atomically enough". */
struct gdbpy_event *item = gdbpy_event_list;
gdbpy_event_list = gdbpy_event_list->next;
if (gdbpy_event_list == NULL)
gdbpy_event_list_end = &gdbpy_event_list;
gdbpy_ref<> call_result (PyObject_CallObject (item->event, NULL));
if (call_result == NULL)
gdbpy_print_stack ();
Py_DECREF (item->event);
xfree (item);
}
}
/* Submit an event to the gdb thread. */
static PyObject *
gdbpy_post_event (PyObject *self, PyObject *args)
{
struct gdbpy_event *event;
PyObject *func;
int wakeup;
if (!PyArg_ParseTuple (args, "O", &func))
return NULL;
if (!PyCallable_Check (func))