1 /* Python interface to architecture 2 3 Copyright (C) 2013-2020 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 7 This program is free software; you can redistribute it and/or modify 8 it under the terms of the GNU General Public License as published by 9 the Free Software Foundation; either version 3 of the License, or 10 (at your option) any later version. 11 12 This program is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15 GNU General Public License for more details. 16 17 You should have received a copy of the GNU General Public License 18 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 19 20 #include "defs.h" 21 #include "gdbarch.h" 22 #include "arch-utils.h" 23 #include "disasm.h" 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; 32 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 45 extern PyTypeObject arch_object_type 46 CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("arch_object"); 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 { 97 struct gdbarch *gdbarch = NULL; 98 const char *name; 99 100 ARCHPY_REQUIRE_VALID (self, gdbarch); 101 102 name = (gdbarch_bfd_arch_info (gdbarch))->printable_name; 103 return PyString_FromString (name); 104 } 105 106 /* Implementation of 107 gdb.Architecture.disassemble (self, start_pc [, end_pc [,count]]) -> List. 108 Returns a list of instructions in a memory address range. Each instruction 109 in the list is a Python dict object. 110 */ 111 112 static PyObject * 113 archpy_disassemble (PyObject *self, PyObject *args, PyObject *kw) 114 { 115 static const char *keywords[] = { "start_pc", "end_pc", "count", NULL }; 116 CORE_ADDR start, end = 0; 117 CORE_ADDR pc; 118 gdb_py_ulongest start_temp; 119 long count = 0, i; 120 PyObject *end_obj = NULL, *count_obj = NULL; 121 struct gdbarch *gdbarch = NULL; 122 123 ARCHPY_REQUIRE_VALID (self, gdbarch); 124 125 if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, GDB_PY_LLU_ARG "|OO", 126 keywords, &start_temp, &end_obj, 127 &count_obj)) 128 return NULL; 129 130 start = start_temp; 131 if (end_obj) 132 { 133 /* Make a long logic check first. In Python 3.x, internally, 134 all integers are represented as longs. In Python 2.x, there 135 is still a differentiation internally between a PyInt and a 136 PyLong. Explicitly do this long check conversion first. In 137 GDB, for Python 3.x, we #ifdef PyInt = PyLong. This check has 138 to be done first to ensure we do not lose information in the 139 conversion process. */ 140 if (PyLong_Check (end_obj)) 141 end = PyLong_AsUnsignedLongLong (end_obj); 142 #if PY_MAJOR_VERSION == 2 143 else if (PyInt_Check (end_obj)) 144 /* If the end_pc value is specified without a trailing 'L', end_obj will 145 be an integer and not a long integer. */ 146 end = PyInt_AsLong (end_obj); 147 #endif 148 else 149 { 150 PyErr_SetString (PyExc_TypeError, 151 _("Argument 'end_pc' should be a (long) integer.")); 152 153 return NULL; 154 } 155 156 if (end < start) 157 { 158 PyErr_SetString (PyExc_ValueError, 159 _("Argument 'end_pc' should be greater than or " 160 "equal to the argument 'start_pc'.")); 161 162 return NULL; 163 } 164 } 165 if (count_obj) 166 { 167 count = PyInt_AsLong (count_obj); 168 if (PyErr_Occurred () || count < 0) 169 { 170 PyErr_SetString (PyExc_TypeError, 171 _("Argument 'count' should be an non-negative " 172 "integer.")); 173 174 return NULL; 175 } 176 } 177 178 gdbpy_ref<> result_list (PyList_New (0)); 179 if (result_list == NULL) 180 return NULL; 181 182 for (pc = start, i = 0; 183 /* All args are specified. */ 184 (end_obj && count_obj && pc <= end && i < count) 185 /* end_pc is specified, but no count. */ 186 || (end_obj && count_obj == NULL && pc <= end) 187 /* end_pc is not specified, but a count is. */ 188 || (end_obj == NULL && count_obj && i < count) 189 /* Both end_pc and count are not specified. */ 190 || (end_obj == NULL && count_obj == NULL && pc == start);) 191 { 192 int insn_len = 0; 193 gdbpy_ref<> insn_dict (PyDict_New ()); 194 195 if (insn_dict == NULL) 196 return NULL; 197 if (PyList_Append (result_list.get (), insn_dict.get ())) 198 return NULL; /* PyList_Append Sets the exception. */ 199 200 string_file stb; 201 202 try 203 { 204 insn_len = gdb_print_insn (gdbarch, pc, &stb, NULL); 205 } 206 catch (const gdb_exception &except) 207 { 208 gdbpy_convert_exception (except); 209 return NULL; 210 } 211 212 if (PyDict_SetItemString (insn_dict.get (), "addr", 213 gdb_py_long_from_ulongest (pc)) 214 || PyDict_SetItemString (insn_dict.get (), "asm", 215 PyString_FromString (!stb.empty () 216 ? stb.c_str () 217 : "<unknown>")) 218 || PyDict_SetItemString (insn_dict.get (), "length", 219 PyInt_FromLong (insn_len))) 220 return NULL; 221 222 pc += insn_len; 223 i++; 224 } 225 226 return result_list.release (); 227 } 228 229 /* Implementation of gdb.Architecture.registers (self, reggroup) -> Iterator. 230 Returns an iterator over register descriptors for registers in GROUP 231 within the architecture SELF. */ 232 233 static PyObject * 234 archpy_registers (PyObject *self, PyObject *args, PyObject *kw) 235 { 236 static const char *keywords[] = { "reggroup", NULL }; 237 struct gdbarch *gdbarch = NULL; 238 const char *group_name = NULL; 239 240 /* Parse method arguments. */ 241 if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "|s", keywords, 242 &group_name)) 243 return NULL; 244 245 /* Extract the gdbarch from the self object. */ 246 ARCHPY_REQUIRE_VALID (self, gdbarch); 247 248 return gdbpy_new_register_descriptor_iterator (gdbarch, group_name); 249 } 250 251 /* Implementation of gdb.Architecture.register_groups (self) -> Iterator. 252 Returns an iterator that will give up all valid register groups in the 253 architecture SELF. */ 254 255 static PyObject * 256 archpy_register_groups (PyObject *self, PyObject *args) 257 { 258 struct gdbarch *gdbarch = NULL; 259 260 /* Extract the gdbarch from the self object. */ 261 ARCHPY_REQUIRE_VALID (self, gdbarch); 262 return gdbpy_new_reggroup_iterator (gdbarch); 263 } 264 265 /* Initializes the Architecture class in the gdb module. */ 266 267 int 268 gdbpy_initialize_arch (void) 269 { 270 arch_object_data = gdbarch_data_register_post_init (arch_object_data_init); 271 arch_object_type.tp_new = PyType_GenericNew; 272 if (PyType_Ready (&arch_object_type) < 0) 273 return -1; 274 275 return gdb_pymodule_addobject (gdb_module, "Architecture", 276 (PyObject *) &arch_object_type); 277 } 278 279 static PyMethodDef arch_object_methods [] = { 280 { "name", archpy_name, METH_NOARGS, 281 "name () -> String.\n\ 282 Return the name of the architecture as a string value." }, 283 { "disassemble", (PyCFunction) archpy_disassemble, 284 METH_VARARGS | METH_KEYWORDS, 285 "disassemble (start_pc [, end_pc [, count]]) -> List.\n\ 286 Return a list of at most COUNT disassembled instructions from START_PC to\n\ 287 END_PC." }, 288 { "registers", (PyCFunction) archpy_registers, 289 METH_VARARGS | METH_KEYWORDS, 290 "registers ([ group-name ]) -> Iterator.\n\ 291 Return an iterator of register descriptors for the registers in register\n\ 292 group GROUP-NAME." }, 293 { "register_groups", archpy_register_groups, 294 METH_NOARGS, 295 "register_groups () -> Iterator.\n\ 296 Return an iterator over all of the register groups in this architecture." }, 297 {NULL} /* Sentinel */ 298 }; 299 300 PyTypeObject arch_object_type = { 301 PyVarObject_HEAD_INIT (NULL, 0) 302 "gdb.Architecture", /* tp_name */ 303 sizeof (arch_object), /* tp_basicsize */ 304 0, /* tp_itemsize */ 305 0, /* tp_dealloc */ 306 0, /* tp_print */ 307 0, /* tp_getattr */ 308 0, /* tp_setattr */ 309 0, /* tp_compare */ 310 0, /* tp_repr */ 311 0, /* tp_as_number */ 312 0, /* tp_as_sequence */ 313 0, /* tp_as_mapping */ 314 0, /* tp_hash */ 315 0, /* tp_call */ 316 0, /* tp_str */ 317 0, /* tp_getattro */ 318 0, /* tp_setattro */ 319 0, /* tp_as_buffer */ 320 Py_TPFLAGS_DEFAULT, /* tp_flags */ 321 "GDB architecture object", /* tp_doc */ 322 0, /* tp_traverse */ 323 0, /* tp_clear */ 324 0, /* tp_richcompare */ 325 0, /* tp_weaklistoffset */ 326 0, /* tp_iter */ 327 0, /* tp_iternext */ 328 arch_object_methods, /* tp_methods */ 329 0, /* tp_members */ 330 0, /* tp_getset */ 331 0, /* tp_base */ 332 0, /* tp_dict */ 333 0, /* tp_descr_get */ 334 0, /* tp_descr_set */ 335 0, /* tp_dictoffset */ 336 0, /* tp_init */ 337 0, /* tp_alloc */ 338 }; 339