1/* Python interface to register, and register group information.
2
3   Copyright (C) 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 "reggroups.h"
25#include "python-internal.h"
26#include "user-regs.h"
27#include <unordered_map>
28
29/* Token to access per-gdbarch data related to register descriptors.  */
30static struct gdbarch_data *gdbpy_register_object_data = NULL;
31
32/* Structure for iterator over register descriptors.  */
33typedef struct {
34  PyObject_HEAD
35
36  /* The register group that the user is iterating over.  This will never
37     be NULL.  */
38  struct reggroup *reggroup;
39
40  /* The next register number to lookup.  Starts at 0 and counts up.  */
41  int regnum;
42
43  /* Pointer back to the architecture we're finding registers for.  */
44  struct gdbarch *gdbarch;
45} register_descriptor_iterator_object;
46
47extern PyTypeObject register_descriptor_iterator_object_type
48    CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("register_descriptor_iterator_object");
49
50/* A register descriptor.  */
51typedef struct {
52  PyObject_HEAD
53
54  /* The register this is a descriptor for.  */
55  int regnum;
56
57  /* The architecture this is a register for.  */
58  struct gdbarch *gdbarch;
59} register_descriptor_object;
60
61extern PyTypeObject register_descriptor_object_type
62    CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("register_descriptor_object");
63
64/* Structure for iterator over register groups.  */
65typedef struct {
66  PyObject_HEAD
67
68  /* The last register group returned.  Initially this will be NULL.  */
69  struct reggroup *reggroup;
70
71  /* Pointer back to the architecture we're finding registers for.  */
72  struct gdbarch *gdbarch;
73} reggroup_iterator_object;
74
75extern PyTypeObject reggroup_iterator_object_type
76    CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("reggroup_iterator_object");
77
78/* A register group object.  */
79typedef struct {
80  PyObject_HEAD
81
82  /* The register group being described.  */
83  struct reggroup *reggroup;
84} reggroup_object;
85
86extern PyTypeObject reggroup_object_type
87    CPYCHECKER_TYPE_OBJECT_FOR_TYPEDEF ("reggroup_object");
88
89/* Associates a vector of gdb.RegisterDescriptor objects with GDBARCH as
90   gdbarch_data via the gdbarch post init registration mechanism
91   (gdbarch_data_register_post_init).  */
92
93static void *
94gdbpy_register_object_data_init (struct gdbarch *gdbarch)
95{
96  return new std::vector<gdbpy_ref<>>;
97}
98
99/* Return a gdb.RegisterGroup object wrapping REGGROUP.  The register
100   group objects are cached, and the same Python object will always be
101   returned for the same REGGROUP pointer.  */
102
103static gdbpy_ref<>
104gdbpy_get_reggroup (struct reggroup *reggroup)
105{
106  /* Map from GDB's internal reggroup objects to the Python representation.
107     GDB's reggroups are global, and are never deleted, so using a map like
108     this is safe.  */
109  static std::unordered_map<struct reggroup *,gdbpy_ref<>>
110    gdbpy_reggroup_object_map;
111
112  /* If there is not already a suitable Python object in the map then
113     create a new one, and add it to the map.  */
114  if (gdbpy_reggroup_object_map[reggroup] == nullptr)
115    {
116      /* Create a new object and fill in its details.  */
117      gdbpy_ref<reggroup_object> group
118	(PyObject_New (reggroup_object, &reggroup_object_type));
119      if (group == NULL)
120	return NULL;
121      group->reggroup = reggroup;
122      gdbpy_reggroup_object_map[reggroup]
123	= gdbpy_ref<> ((PyObject *) group.release ());
124    }
125
126  /* Fetch the Python object wrapping REGGROUP from the map, increasing
127     the reference count is handled by the gdbpy_ref class.  */
128  return gdbpy_reggroup_object_map[reggroup];
129}
130
131/* Convert a gdb.RegisterGroup to a string, it just returns the name of
132   the register group.  */
133
134static PyObject *
135gdbpy_reggroup_to_string (PyObject *self)
136{
137  reggroup_object *group = (reggroup_object *) self;
138  struct reggroup *reggroup = group->reggroup;
139
140  const char *name = reggroup_name (reggroup);
141  return PyString_FromString (name);
142}
143
144/* Implement gdb.RegisterGroup.name (self) -> String.
145   Return a string that is the name of this register group.  */
146
147static PyObject *
148gdbpy_reggroup_name (PyObject *self, void *closure)
149{
150  return gdbpy_reggroup_to_string (self);
151}
152
153/* Return a gdb.RegisterDescriptor object for REGNUM from GDBARCH.  For
154   each REGNUM (in GDBARCH) only one descriptor is ever created, which is
155   then cached on the GDBARCH.  */
156
157static gdbpy_ref<>
158gdbpy_get_register_descriptor (struct gdbarch *gdbarch,
159			       int regnum)
160{
161  auto &vec
162    = *(std::vector<gdbpy_ref<>> *) gdbarch_data (gdbarch,
163						  gdbpy_register_object_data);
164
165  /* Ensure that we have enough entries in the vector.  */
166  if (vec.size () <= regnum)
167    vec.resize ((regnum + 1), nullptr);
168
169  /* If we don't already have a descriptor for REGNUM in GDBARCH then
170     create one now.  */
171  if (vec[regnum] == nullptr)
172    {
173      gdbpy_ref <register_descriptor_object> reg
174	(PyObject_New (register_descriptor_object,
175		       &register_descriptor_object_type));
176      if (reg == NULL)
177	return NULL;
178      reg->regnum = regnum;
179      reg->gdbarch = gdbarch;
180      vec[regnum] = gdbpy_ref<> ((PyObject *) reg.release ());
181    }
182
183  /* Grab the register descriptor from the vector, the reference count is
184     automatically incremented thanks to gdbpy_ref.  */
185  return vec[regnum];
186}
187
188/* Convert the register descriptor to a string.  */
189
190static PyObject *
191gdbpy_register_descriptor_to_string (PyObject *self)
192{
193  register_descriptor_object *reg
194    = (register_descriptor_object *) self;
195  struct gdbarch *gdbarch = reg->gdbarch;
196  int regnum = reg->regnum;
197
198  const char *name = gdbarch_register_name (gdbarch, regnum);
199  return PyString_FromString (name);
200}
201
202/* Implement gdb.RegisterDescriptor.name attribute get function.  Return a
203   string that is the name of this register.  Due to checking when register
204   descriptors are created the name will never by the empty string.  */
205
206static PyObject *
207gdbpy_register_descriptor_name (PyObject *self, void *closure)
208{
209  return gdbpy_register_descriptor_to_string (self);
210}
211
212/* Return a reference to the gdb.RegisterGroupsIterator object.  */
213
214static PyObject *
215gdbpy_reggroup_iter (PyObject *self)
216{
217  Py_INCREF (self);
218  return self;
219}
220
221/* Return the next gdb.RegisterGroup object from the iterator.  */
222
223static PyObject *
224gdbpy_reggroup_iter_next (PyObject *self)
225{
226  reggroup_iterator_object *iter_obj
227    = (reggroup_iterator_object *) self;
228  struct gdbarch *gdbarch = iter_obj->gdbarch;
229
230  struct reggroup *next_group = reggroup_next (gdbarch, iter_obj->reggroup);
231  if (next_group == NULL)
232    {
233      PyErr_SetString (PyExc_StopIteration, _("No more groups"));
234      return NULL;
235    }
236
237  iter_obj->reggroup = next_group;
238  return gdbpy_get_reggroup (iter_obj->reggroup).release ();
239}
240
241/* Return a new gdb.RegisterGroupsIterator over all the register groups in
242   GDBARCH.  */
243
244PyObject *
245gdbpy_new_reggroup_iterator (struct gdbarch *gdbarch)
246{
247  gdb_assert (gdbarch != nullptr);
248
249  /* Create a new object and fill in its internal state.  */
250  reggroup_iterator_object *iter
251    = PyObject_New (reggroup_iterator_object,
252		    &reggroup_iterator_object_type);
253  if (iter == NULL)
254    return NULL;
255  iter->reggroup = NULL;
256  iter->gdbarch = gdbarch;
257  return (PyObject *) iter;
258}
259
260/* Create and return a new gdb.RegisterDescriptorIterator object which
261   will iterate over all registers in GROUP_NAME for GDBARCH.  If
262   GROUP_NAME is either NULL or the empty string then the ALL_REGGROUP is
263   used, otherwise lookup the register group matching GROUP_NAME and use
264   that.
265
266   This function can return NULL if GROUP_NAME isn't found.  */
267
268PyObject *
269gdbpy_new_register_descriptor_iterator (struct gdbarch *gdbarch,
270					const char *group_name)
271{
272  struct reggroup *grp = NULL;
273
274  /* Lookup the requested register group, or find the default.  */
275  if (group_name == NULL || *group_name == '\0')
276    grp = all_reggroup;
277  else
278    {
279      grp = reggroup_find (gdbarch, group_name);
280      if (grp == NULL)
281	{
282	  PyErr_SetString (PyExc_ValueError,
283			   _("Unknown register group name."));
284	  return NULL;
285	}
286    }
287  /* Create a new iterator object initialised for this architecture and
288     fill in all of the details.  */
289  register_descriptor_iterator_object *iter
290    = PyObject_New (register_descriptor_iterator_object,
291		    &register_descriptor_iterator_object_type);
292  if (iter == NULL)
293    return NULL;
294  iter->regnum = 0;
295  iter->gdbarch = gdbarch;
296  gdb_assert (grp != NULL);
297  iter->reggroup = grp;
298
299  return (PyObject *) iter;
300}
301
302/* Return a reference to the gdb.RegisterDescriptorIterator object.  */
303
304static PyObject *
305gdbpy_register_descriptor_iter (PyObject *self)
306{
307  Py_INCREF (self);
308  return self;
309}
310
311/* Return the next register name.  */
312
313static PyObject *
314gdbpy_register_descriptor_iter_next (PyObject *self)
315{
316  register_descriptor_iterator_object *iter_obj
317    = (register_descriptor_iterator_object *) self;
318  struct gdbarch *gdbarch = iter_obj->gdbarch;
319
320  do
321    {
322      if (iter_obj->regnum >= gdbarch_num_cooked_regs (gdbarch))
323	{
324	  PyErr_SetString (PyExc_StopIteration, _("No more registers"));
325	  return NULL;
326	}
327
328      const char *name = nullptr;
329      int regnum = iter_obj->regnum;
330      if (gdbarch_register_reggroup_p (gdbarch, regnum,
331				       iter_obj->reggroup))
332	name = gdbarch_register_name (gdbarch, regnum);
333      iter_obj->regnum++;
334
335      if (name != nullptr && *name != '\0')
336	return gdbpy_get_register_descriptor (gdbarch, regnum).release ();
337    }
338  while (true);
339}
340
341/* Implement:
342
343   gdb.RegisterDescriptorIterator.find (self, name) -> gdb.RegisterDescriptor
344
345   Look up a descriptor for register with NAME.  If no matching register is
346   found then return None.  */
347
348static PyObject *
349register_descriptor_iter_find (PyObject *self, PyObject *args, PyObject *kw)
350{
351  static const char *keywords[] = { "name", NULL };
352  const char *register_name = NULL;
353
354  register_descriptor_iterator_object *iter_obj
355    = (register_descriptor_iterator_object *) self;
356  struct gdbarch *gdbarch = iter_obj->gdbarch;
357
358  if (!gdb_PyArg_ParseTupleAndKeywords (args, kw, "s", keywords,
359					&register_name))
360    return NULL;
361
362  if (register_name != NULL && *register_name != '\0')
363    {
364      int regnum = user_reg_map_name_to_regnum (gdbarch, register_name,
365						strlen (register_name));
366      if (regnum >= 0)
367	return gdbpy_get_register_descriptor (gdbarch, regnum).release ();
368    }
369
370  Py_RETURN_NONE;
371}
372
373/* See python-internal.h.  */
374
375bool
376gdbpy_parse_register_id (struct gdbarch *gdbarch, PyObject *pyo_reg_id,
377			 int *reg_num)
378{
379  gdb_assert (pyo_reg_id != NULL);
380
381  /* The register could be a string, its name.  */
382  if (gdbpy_is_string (pyo_reg_id))
383    {
384      gdb::unique_xmalloc_ptr<char> reg_name (gdbpy_obj_to_string (pyo_reg_id));
385
386      if (reg_name != NULL)
387	{
388	  *reg_num = user_reg_map_name_to_regnum (gdbarch, reg_name.get (),
389						  strlen (reg_name.get ()));
390	  return *reg_num >= 0;
391	}
392    }
393  /* The register could be its internal GDB register number.  */
394  else if (PyInt_Check (pyo_reg_id))
395    {
396      long value;
397      if (gdb_py_int_as_long (pyo_reg_id, &value) && (int) value == value)
398        {
399	  if (user_reg_map_regnum_to_name (gdbarch, value) != NULL)
400	    {
401	      *reg_num = (int) value;
402	      return true;
403	    }
404        }
405    }
406  /* The register could be a gdb.RegisterDescriptor object.  */
407  else if (PyObject_IsInstance (pyo_reg_id,
408			   (PyObject *) &register_descriptor_object_type))
409    {
410      register_descriptor_object *reg
411	= (register_descriptor_object *) pyo_reg_id;
412      if (reg->gdbarch == gdbarch)
413	{
414	  *reg_num = reg->regnum;
415	  return true;
416	}
417      else
418	PyErr_SetString (PyExc_ValueError,
419			 _("Invalid Architecture in RegisterDescriptor"));
420    }
421
422  gdb_assert (PyErr_Occurred ());
423  return false;
424}
425
426/* Initializes the new Python classes from this file in the gdb module.  */
427
428int
429gdbpy_initialize_registers ()
430{
431  gdbpy_register_object_data
432    = gdbarch_data_register_post_init (gdbpy_register_object_data_init);
433
434  register_descriptor_object_type.tp_new = PyType_GenericNew;
435  if (PyType_Ready (&register_descriptor_object_type) < 0)
436    return -1;
437  if (gdb_pymodule_addobject
438      (gdb_module, "RegisterDescriptor",
439       (PyObject *) &register_descriptor_object_type) < 0)
440    return -1;
441
442  reggroup_iterator_object_type.tp_new = PyType_GenericNew;
443  if (PyType_Ready (&reggroup_iterator_object_type) < 0)
444    return -1;
445  if (gdb_pymodule_addobject
446      (gdb_module, "RegisterGroupsIterator",
447       (PyObject *) &reggroup_iterator_object_type) < 0)
448    return -1;
449
450  reggroup_object_type.tp_new = PyType_GenericNew;
451  if (PyType_Ready (&reggroup_object_type) < 0)
452    return -1;
453  if (gdb_pymodule_addobject
454      (gdb_module, "RegisterGroup",
455       (PyObject *) &reggroup_object_type) < 0)
456    return -1;
457
458  register_descriptor_iterator_object_type.tp_new = PyType_GenericNew;
459  if (PyType_Ready (&register_descriptor_iterator_object_type) < 0)
460    return -1;
461  return (gdb_pymodule_addobject
462	  (gdb_module, "RegisterDescriptorIterator",
463	   (PyObject *) &register_descriptor_iterator_object_type));
464}
465
466static PyMethodDef register_descriptor_iterator_object_methods [] = {
467  { "find", (PyCFunction) register_descriptor_iter_find,
468    METH_VARARGS | METH_KEYWORDS,
469    "registers (name) -> gdb.RegisterDescriptor.\n\
470Return a register descriptor for the register NAME, or None if no register\n\
471with that name exists in this iterator." },
472  {NULL}  /* Sentinel */
473};
474
475PyTypeObject register_descriptor_iterator_object_type = {
476  PyVarObject_HEAD_INIT (NULL, 0)
477  "gdb.RegisterDescriptorIterator",	  	/*tp_name*/
478  sizeof (register_descriptor_iterator_object),	/*tp_basicsize*/
479  0,				  /*tp_itemsize*/
480  0,				  /*tp_dealloc*/
481  0,				  /*tp_print*/
482  0,				  /*tp_getattr*/
483  0,				  /*tp_setattr*/
484  0,				  /*tp_compare*/
485  0,				  /*tp_repr*/
486  0,				  /*tp_as_number*/
487  0,				  /*tp_as_sequence*/
488  0,				  /*tp_as_mapping*/
489  0,				  /*tp_hash */
490  0,				  /*tp_call*/
491  0,				  /*tp_str*/
492  0,				  /*tp_getattro*/
493  0,				  /*tp_setattro*/
494  0,				  /*tp_as_buffer*/
495  Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER,			/*tp_flags*/
496  "GDB architecture register descriptor iterator object",	/*tp_doc */
497  0,				  /*tp_traverse */
498  0,				  /*tp_clear */
499  0,				  /*tp_richcompare */
500  0,				  /*tp_weaklistoffset */
501  gdbpy_register_descriptor_iter,	  /*tp_iter */
502  gdbpy_register_descriptor_iter_next,  /*tp_iternext */
503  register_descriptor_iterator_object_methods		/*tp_methods */
504};
505
506static gdb_PyGetSetDef gdbpy_register_descriptor_getset[] = {
507  { "name", gdbpy_register_descriptor_name, NULL,
508    "The name of this register.", NULL },
509  { NULL }  /* Sentinel */
510};
511
512PyTypeObject register_descriptor_object_type = {
513  PyVarObject_HEAD_INIT (NULL, 0)
514  "gdb.RegisterDescriptor",	  /*tp_name*/
515  sizeof (register_descriptor_object),	/*tp_basicsize*/
516  0,				  /*tp_itemsize*/
517  0,				  /*tp_dealloc*/
518  0,				  /*tp_print*/
519  0,				  /*tp_getattr*/
520  0,				  /*tp_setattr*/
521  0,				  /*tp_compare*/
522  0,				  /*tp_repr*/
523  0,				  /*tp_as_number*/
524  0,				  /*tp_as_sequence*/
525  0,				  /*tp_as_mapping*/
526  0,				  /*tp_hash */
527  0,				  /*tp_call*/
528  gdbpy_register_descriptor_to_string,			/*tp_str*/
529  0,				  /*tp_getattro*/
530  0,				  /*tp_setattro*/
531  0,				  /*tp_as_buffer*/
532  Py_TPFLAGS_DEFAULT,		  /*tp_flags*/
533  "GDB architecture register descriptor object",	/*tp_doc */
534  0,				  /*tp_traverse */
535  0,				  /*tp_clear */
536  0,				  /*tp_richcompare */
537  0,				  /*tp_weaklistoffset */
538  0,				  /*tp_iter */
539  0,				  /*tp_iternext */
540  0,				  /*tp_methods */
541  0,				  /*tp_members */
542  gdbpy_register_descriptor_getset			/*tp_getset */
543};
544
545PyTypeObject reggroup_iterator_object_type = {
546  PyVarObject_HEAD_INIT (NULL, 0)
547  "gdb.RegisterGroupsIterator",	  /*tp_name*/
548  sizeof (reggroup_iterator_object),		/*tp_basicsize*/
549  0,				  /*tp_itemsize*/
550  0,				  /*tp_dealloc*/
551  0,				  /*tp_print*/
552  0,				  /*tp_getattr*/
553  0,				  /*tp_setattr*/
554  0,				  /*tp_compare*/
555  0,				  /*tp_repr*/
556  0,				  /*tp_as_number*/
557  0,				  /*tp_as_sequence*/
558  0,				  /*tp_as_mapping*/
559  0,				  /*tp_hash */
560  0,				  /*tp_call*/
561  0,				  /*tp_str*/
562  0,				  /*tp_getattro*/
563  0,				  /*tp_setattro*/
564  0,				  /*tp_as_buffer*/
565  Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER,	/*tp_flags*/
566  "GDB register groups iterator object",	/*tp_doc */
567  0,				  /*tp_traverse */
568  0,				  /*tp_clear */
569  0,				  /*tp_richcompare */
570  0,				  /*tp_weaklistoffset */
571  gdbpy_reggroup_iter,		  /*tp_iter */
572  gdbpy_reggroup_iter_next,	  /*tp_iternext */
573  0				  /*tp_methods */
574};
575
576static gdb_PyGetSetDef gdbpy_reggroup_getset[] = {
577  { "name", gdbpy_reggroup_name, NULL,
578    "The name of this register group.", NULL },
579  { NULL }  /* Sentinel */
580};
581
582PyTypeObject reggroup_object_type = {
583  PyVarObject_HEAD_INIT (NULL, 0)
584  "gdb.RegisterGroup",		  /*tp_name*/
585  sizeof (reggroup_object),	  /*tp_basicsize*/
586  0,				  /*tp_itemsize*/
587  0,				  /*tp_dealloc*/
588  0,				  /*tp_print*/
589  0,				  /*tp_getattr*/
590  0,				  /*tp_setattr*/
591  0,				  /*tp_compare*/
592  0,				  /*tp_repr*/
593  0,				  /*tp_as_number*/
594  0,				  /*tp_as_sequence*/
595  0,				  /*tp_as_mapping*/
596  0,				  /*tp_hash */
597  0,				  /*tp_call*/
598  gdbpy_reggroup_to_string,	  /*tp_str*/
599  0,				  /*tp_getattro*/
600  0,				  /*tp_setattro*/
601  0,				  /*tp_as_buffer*/
602  Py_TPFLAGS_DEFAULT,		  /*tp_flags*/
603  "GDB register group object",	  /*tp_doc */
604  0,				  /*tp_traverse */
605  0,				  /*tp_clear */
606  0,				  /*tp_richcompare */
607  0,				  /*tp_weaklistoffset */
608  0,				  /*tp_iter */
609  0,				  /*tp_iternext */
610  0,				  /*tp_methods */
611  0,				  /*tp_members */
612  gdbpy_reggroup_getset		  /*tp_getset */
613};
614