Commit | Line | Data |
---|---|---|
bea883fd SCR |
1 | /* Python interface to architecture |
2 | ||
618f726f | 3 | Copyright (C) 2013-2016 Free Software Foundation, Inc. |
bea883fd SCR |
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 "gdbarch.h" | |
22 | #include "arch-utils.h" | |
9f44fbc0 | 23 | #include "disasm.h" |
bea883fd SCR |
24 | #include "python-internal.h" |
25 | ||
26 | typedef struct arch_object_type_object { | |
27 | PyObject_HEAD | |
28 | struct gdbarch *gdbarch; | |
29 | } arch_object; | |
30 | ||
31 | static struct gdbarch_data *arch_object_data = NULL; | |
62eec1a5 | 32 | |
96d9056e PM |
33 | /* Require a valid Architecture. */ |
34 | #define ARCHPY_REQUIRE_VALID(arch_obj, arch) \ | |
35 | do { \ | |
36 | arch = arch_object_to_gdbarch (arch_obj); \ | |
37 | if (arch == NULL) \ | |
38 | { \ | |
39 | PyErr_SetString (PyExc_RuntimeError, \ | |
40 | _("Architecture is invalid.")); \ | |
41 | return NULL; \ | |
42 | } \ | |
43 | } while (0) | |
44 | ||
e36122e9 | 45 | extern PyTypeObject arch_object_type |
62eec1a5 | 46 | CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("arch_object"); |
bea883fd SCR |
47 | |
48 | /* Associates an arch_object with GDBARCH as gdbarch_data via the gdbarch | |
49 | post init registration mechanism (gdbarch_data_register_post_init). */ | |
50 | ||
51 | static void * | |
52 | arch_object_data_init (struct gdbarch *gdbarch) | |
53 | { | |
54 | arch_object *arch_obj = PyObject_New (arch_object, &arch_object_type); | |
55 | ||
56 | if (arch_obj == NULL) | |
57 | return NULL; | |
58 | ||
59 | arch_obj->gdbarch = gdbarch; | |
60 | ||
61 | return (void *) arch_obj; | |
62 | } | |
63 | ||
64 | /* Returns the struct gdbarch value corresponding to the given Python | |
65 | architecture object OBJ. */ | |
66 | ||
67 | struct gdbarch * | |
68 | arch_object_to_gdbarch (PyObject *obj) | |
69 | { | |
70 | arch_object *py_arch = (arch_object *) obj; | |
71 | ||
72 | return py_arch->gdbarch; | |
73 | } | |
74 | ||
75 | /* Returns the Python architecture object corresponding to GDBARCH. | |
76 | Returns a new reference to the arch_object associated as data with | |
77 | GDBARCH. */ | |
78 | ||
79 | PyObject * | |
80 | gdbarch_to_arch_object (struct gdbarch *gdbarch) | |
81 | { | |
82 | PyObject *new_ref = (PyObject *) gdbarch_data (gdbarch, arch_object_data); | |
83 | ||
84 | /* new_ref could be NULL if registration of arch_object with GDBARCH failed | |
85 | in arch_object_data_init. */ | |
86 | Py_XINCREF (new_ref); | |
87 | ||
88 | return new_ref; | |
89 | } | |
90 | ||
91 | /* Implementation of gdb.Architecture.name (self) -> String. | |
92 | Returns the name of the architecture as a string value. */ | |
93 | ||
94 | static PyObject * | |
95 | archpy_name (PyObject *self, PyObject *args) | |
96 | { | |
96d9056e PM |
97 | struct gdbarch *gdbarch = NULL; |
98 | const char *name; | |
99 | PyObject *py_name; | |
100 | ||
101 | ARCHPY_REQUIRE_VALID (self, gdbarch); | |
102 | ||
103 | name = (gdbarch_bfd_arch_info (gdbarch))->printable_name; | |
104 | py_name = PyString_FromString (name); | |
bea883fd SCR |
105 | |
106 | return py_name; | |
107 | } | |
108 | ||
9f44fbc0 SCR |
109 | /* Implementation of |
110 | gdb.Architecture.disassemble (self, start_pc [, end_pc [,count]]) -> List. | |
111 | Returns a list of instructions in a memory address range. Each instruction | |
112 | in the list is a Python dict object. | |
113 | */ | |
114 | ||
115 | static PyObject * | |
116 | archpy_disassemble (PyObject *self, PyObject *args, PyObject *kw) | |
117 | { | |
118 | static char *keywords[] = { "start_pc", "end_pc", "count", NULL }; | |
119 | CORE_ADDR start, end = 0; | |
120 | CORE_ADDR pc; | |
121 | gdb_py_ulongest start_temp; | |
122 | long count = 0, i; | |
123 | PyObject *result_list, *end_obj = NULL, *count_obj = NULL; | |
96d9056e PM |
124 | struct gdbarch *gdbarch = NULL; |
125 | ||
126 | ARCHPY_REQUIRE_VALID (self, gdbarch); | |
9f44fbc0 SCR |
127 | |
128 | if (!PyArg_ParseTupleAndKeywords (args, kw, GDB_PY_LLU_ARG "|OO", keywords, | |
129 | &start_temp, &end_obj, &count_obj)) | |
130 | return NULL; | |
131 | ||
132 | start = start_temp; | |
133 | if (end_obj) | |
134 | { | |
06ab7b19 PM |
135 | /* Make a long logic check first. In Python 3.x, internally, |
136 | all integers are represented as longs. In Python 2.x, there | |
137 | is still a differentiation internally between a PyInt and a | |
138 | PyLong. Explicitly do this long check conversion first. In | |
139 | GDB, for Python 3.x, we #ifdef PyInt = PyLong. This check has | |
140 | to be done first to ensure we do not lose information in the | |
141 | conversion process. */ | |
ddb08e9c TT |
142 | if (PyLong_Check (end_obj)) |
143 | end = PyLong_AsUnsignedLongLong (end_obj); | |
12c58cd4 | 144 | #if PY_MAJOR_VERSION == 2 |
ddb08e9c | 145 | else if (PyInt_Check (end_obj)) |
9f44fbc0 SCR |
146 | /* If the end_pc value is specified without a trailing 'L', end_obj will |
147 | be an integer and not a long integer. */ | |
148 | end = PyInt_AsLong (end_obj); | |
12c58cd4 | 149 | #endif |
9f44fbc0 SCR |
150 | else |
151 | { | |
152 | Py_DECREF (end_obj); | |
153 | Py_XDECREF (count_obj); | |
154 | PyErr_SetString (PyExc_TypeError, | |
155 | _("Argument 'end_pc' should be a (long) integer.")); | |
156 | ||
157 | return NULL; | |
158 | } | |
159 | ||
160 | if (end < start) | |
161 | { | |
162 | Py_DECREF (end_obj); | |
163 | Py_XDECREF (count_obj); | |
164 | PyErr_SetString (PyExc_ValueError, | |
165 | _("Argument 'end_pc' should be greater than or " | |
166 | "equal to the argument 'start_pc'.")); | |
167 | ||
168 | return NULL; | |
169 | } | |
170 | } | |
171 | if (count_obj) | |
172 | { | |
173 | count = PyInt_AsLong (count_obj); | |
174 | if (PyErr_Occurred () || count < 0) | |
175 | { | |
176 | Py_DECREF (count_obj); | |
177 | Py_XDECREF (end_obj); | |
178 | PyErr_SetString (PyExc_TypeError, | |
179 | _("Argument 'count' should be an non-negative " | |
180 | "integer.")); | |
181 | ||
182 | return NULL; | |
183 | } | |
184 | } | |
185 | ||
186 | result_list = PyList_New (0); | |
187 | if (result_list == NULL) | |
188 | return NULL; | |
189 | ||
190 | for (pc = start, i = 0; | |
191 | /* All args are specified. */ | |
192 | (end_obj && count_obj && pc <= end && i < count) | |
193 | /* end_pc is specified, but no count. */ | |
194 | || (end_obj && count_obj == NULL && pc <= end) | |
195 | /* end_pc is not specified, but a count is. */ | |
196 | || (end_obj == NULL && count_obj && i < count) | |
197 | /* Both end_pc and count are not specified. */ | |
198 | || (end_obj == NULL && count_obj == NULL && pc == start);) | |
199 | { | |
200 | int insn_len = 0; | |
201 | char *as = NULL; | |
202 | struct ui_file *memfile = mem_fileopen (); | |
203 | PyObject *insn_dict = PyDict_New (); | |
9f44fbc0 SCR |
204 | |
205 | if (insn_dict == NULL) | |
206 | { | |
207 | Py_DECREF (result_list); | |
208 | ui_file_delete (memfile); | |
209 | ||
210 | return NULL; | |
211 | } | |
212 | if (PyList_Append (result_list, insn_dict)) | |
213 | { | |
214 | Py_DECREF (result_list); | |
215 | Py_DECREF (insn_dict); | |
216 | ui_file_delete (memfile); | |
217 | ||
218 | return NULL; /* PyList_Append Sets the exception. */ | |
219 | } | |
220 | ||
492d29ea | 221 | TRY |
9f44fbc0 SCR |
222 | { |
223 | insn_len = gdb_print_insn (gdbarch, pc, memfile, NULL); | |
224 | } | |
492d29ea | 225 | CATCH (except, RETURN_MASK_ALL) |
9f44fbc0 SCR |
226 | { |
227 | Py_DECREF (result_list); | |
228 | ui_file_delete (memfile); | |
229 | ||
56cc411c TT |
230 | gdbpy_convert_exception (except); |
231 | return NULL; | |
9f44fbc0 | 232 | } |
492d29ea | 233 | END_CATCH |
9f44fbc0 SCR |
234 | |
235 | as = ui_file_xstrdup (memfile, NULL); | |
236 | if (PyDict_SetItemString (insn_dict, "addr", | |
237 | gdb_py_long_from_ulongest (pc)) | |
238 | || PyDict_SetItemString (insn_dict, "asm", | |
239 | PyString_FromString (*as ? as : "<unknown>")) | |
240 | || PyDict_SetItemString (insn_dict, "length", | |
241 | PyInt_FromLong (insn_len))) | |
242 | { | |
243 | Py_DECREF (result_list); | |
244 | ||
245 | ui_file_delete (memfile); | |
246 | xfree (as); | |
247 | ||
248 | return NULL; | |
249 | } | |
250 | ||
251 | pc += insn_len; | |
252 | i++; | |
253 | ui_file_delete (memfile); | |
254 | xfree (as); | |
255 | } | |
256 | ||
257 | return result_list; | |
258 | } | |
259 | ||
bea883fd SCR |
260 | /* Initializes the Architecture class in the gdb module. */ |
261 | ||
999633ed | 262 | int |
bea883fd SCR |
263 | gdbpy_initialize_arch (void) |
264 | { | |
265 | arch_object_data = gdbarch_data_register_post_init (arch_object_data_init); | |
266 | arch_object_type.tp_new = PyType_GenericNew; | |
267 | if (PyType_Ready (&arch_object_type) < 0) | |
999633ed | 268 | return -1; |
bea883fd | 269 | |
aa36459a TT |
270 | return gdb_pymodule_addobject (gdb_module, "Architecture", |
271 | (PyObject *) &arch_object_type); | |
bea883fd SCR |
272 | } |
273 | ||
274 | static PyMethodDef arch_object_methods [] = { | |
275 | { "name", archpy_name, METH_NOARGS, | |
276 | "name () -> String.\n\ | |
277 | Return the name of the architecture as a string value." }, | |
9f44fbc0 SCR |
278 | { "disassemble", (PyCFunction) archpy_disassemble, |
279 | METH_VARARGS | METH_KEYWORDS, | |
280 | "disassemble (start_pc [, end_pc [, count]]) -> List.\n\ | |
281 | Return a list of at most COUNT disassembled instructions from START_PC to\n\ | |
282 | END_PC." }, | |
bea883fd SCR |
283 | {NULL} /* Sentinel */ |
284 | }; | |
285 | ||
e36122e9 | 286 | PyTypeObject arch_object_type = { |
bea883fd SCR |
287 | PyVarObject_HEAD_INIT (NULL, 0) |
288 | "gdb.Architecture", /* tp_name */ | |
289 | sizeof (arch_object), /* tp_basicsize */ | |
290 | 0, /* tp_itemsize */ | |
291 | 0, /* tp_dealloc */ | |
292 | 0, /* tp_print */ | |
293 | 0, /* tp_getattr */ | |
294 | 0, /* tp_setattr */ | |
295 | 0, /* tp_compare */ | |
296 | 0, /* tp_repr */ | |
297 | 0, /* tp_as_number */ | |
298 | 0, /* tp_as_sequence */ | |
299 | 0, /* tp_as_mapping */ | |
300 | 0, /* tp_hash */ | |
301 | 0, /* tp_call */ | |
302 | 0, /* tp_str */ | |
303 | 0, /* tp_getattro */ | |
304 | 0, /* tp_setattro */ | |
305 | 0, /* tp_as_buffer */ | |
306 | Py_TPFLAGS_DEFAULT, /* tp_flags */ | |
307 | "GDB architecture object", /* tp_doc */ | |
308 | 0, /* tp_traverse */ | |
309 | 0, /* tp_clear */ | |
310 | 0, /* tp_richcompare */ | |
311 | 0, /* tp_weaklistoffset */ | |
312 | 0, /* tp_iter */ | |
313 | 0, /* tp_iternext */ | |
314 | arch_object_methods, /* tp_methods */ | |
315 | 0, /* tp_members */ | |
316 | 0, /* tp_getset */ | |
317 | 0, /* tp_base */ | |
318 | 0, /* tp_dict */ | |
319 | 0, /* tp_descr_get */ | |
320 | 0, /* tp_descr_set */ | |
321 | 0, /* tp_dictoffset */ | |
322 | 0, /* tp_init */ | |
323 | 0, /* tp_alloc */ | |
324 | }; |