[deliverable/binutils-gdb.git] / gdb / python / py-block.c

/* Python interface to blocks.

   Copyright (C) 2008, 2009, 2010, 2011 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 "block.h"
#include "dictionary.h"
#include "symtab.h"
#include "python-internal.h"
#include "objfiles.h"
#include "symtab.h"

typedef struct blpy_block_object {
  PyObject_HEAD
  /* The GDB block structure that represents a frame's code block.  */
  struct block *block;
  /* The backing object file.  There is no direct relationship in GDB
     between a block and an object file.  When a block is created also
     store a pointer to the object file for later use.  */
  struct objfile *objfile;
  /* Keep track of all blocks with a doubly-linked list.  Needed for
     block invalidation if the source object file has been freed.  */
  struct blpy_block_object *prev;
  struct blpy_block_object *next;
} block_object;

typedef struct {
  PyObject_HEAD
  /* The block dictionary of symbols.  */
  struct dictionary *dict;
  /* The iterator for that dictionary.  */
  struct dict_iterator iter;
  /* Has the iterator been initialized flag.  */
  int initialized_p;
  /* Pointer back to the original source block object.  Needed to
     check if the block is still valid, and has not been invalidated
     when an object file has been freed.  */
  struct blpy_block_object *source;
} block_syms_iterator_object;

/* Require a valid block.  All access to block_object->block should be
   gated by this call.  */
#define BLPY_REQUIRE_VALID(block_obj, block)		\
  do {							\
    block = block_object_to_block (block_obj);		\
    if (block == NULL)					\
      {							\
	PyErr_SetString (PyExc_RuntimeError,		\
			 _("Block is invalid."));	\
	return NULL;					\
      }							\
  } while (0)

/* Require a valid block.  This macro is called during block iterator
   creation, and at each next call.  */
#define BLPY_ITER_REQUIRE_VALID(block_obj)				\
  do {									\
    if (block_obj->block == NULL)					\
      {									\
	PyErr_SetString (PyExc_RuntimeError,				\
			 _("Source block for iterator is invalid."));	\
	return NULL;							\
      }									\
  } while (0)

static PyTypeObject block_syms_iterator_object_type;
static const struct objfile_data *blpy_objfile_data_key;

static PyObject *
blpy_iter (PyObject *self)
{
  block_syms_iterator_object *block_iter_obj;
  struct block *block = NULL;

  BLPY_REQUIRE_VALID (self, block);

  block_iter_obj = PyObject_New (block_syms_iterator_object,
				 &block_syms_iterator_object_type);
  if (block_iter_obj == NULL)
      return NULL;

  block_iter_obj->dict = BLOCK_DICT (block);
  block_iter_obj->initialized_p = 0;
  Py_INCREF (self);
  block_iter_obj->source = (block_object *) self;

  return (PyObject *) block_iter_obj;
}

static PyObject *
blpy_get_start (PyObject *self, void *closure)
{
  struct block *block = NULL;

  BLPY_REQUIRE_VALID (self, block);

  return gdb_py_object_from_ulongest (BLOCK_START (block));
}

static PyObject *
blpy_get_end (PyObject *self, void *closure)
{
  struct block *block = NULL;

  BLPY_REQUIRE_VALID (self, block);

  return gdb_py_object_from_ulongest (BLOCK_END (block));
}

static PyObject *
blpy_get_function (PyObject *self, void *closure)
{
  struct symbol *sym;
  struct block *block = NULL;

  BLPY_REQUIRE_VALID (self, block);

  sym = BLOCK_FUNCTION (block);
  if (sym)
    return symbol_to_symbol_object (sym);

  Py_RETURN_NONE;
}

static PyObject *
blpy_get_superblock (PyObject *self, void *closure)
{
  struct block *block = NULL;
  struct block *super_block = NULL;
  block_object *self_obj  = (block_object *) self;

  BLPY_REQUIRE_VALID (self, block);

  super_block = BLOCK_SUPERBLOCK (block);
  if (super_block)
    return block_to_block_object (super_block, self_obj->objfile);

  Py_RETURN_NONE;
}

static void
blpy_dealloc (PyObject *obj)
{
  block_object *block = (block_object *) obj;

  if (block->prev)
    block->prev->next = block->next;
  else if (block->objfile)
    {
      set_objfile_data (block->objfile, blpy_objfile_data_key,
			block->next);
    }
  if (block->next)
    block->next->prev = block->prev;
  block->block = NULL;
}

/* Given a block, and a block_object that has previously been
   allocated and initialized, populate the block_object with the
   struct block data.  Also, register the block_object life-cycle
   with the life-cycle of the object file associated with this
   block, if needed.  */
static void
set_block (block_object *obj, struct block *block,
	   struct objfile *objfile)
{
  obj->block = block;
  obj->prev = NULL;
  if (objfile)
    {
      obj->objfile = objfile;
      obj->next = objfile_data (objfile, blpy_objfile_data_key);
      if (obj->next)
	obj->next->prev = obj;
      set_objfile_data (objfile, blpy_objfile_data_key, obj);
    }
  else
    obj->next = NULL;
}

/* Create a new block object (gdb.Block) that encapsulates the struct
   block object from GDB.  */
PyObject *
block_to_block_object (struct block *block, struct objfile *objfile)
{
  block_object *block_obj;

  block_obj = PyObject_New (block_object, &block_object_type);
  if (block_obj)
    set_block (block_obj, block, objfile);

  return (PyObject *) block_obj;
}

/* Return struct block reference that is wrapped by this object.  */
struct block *
block_object_to_block (PyObject *obj)
{
  if (! PyObject_TypeCheck (obj, &block_object_type))
    return NULL;
  return ((block_object *) obj)->block;
}

/* Return a reference to the block iterator.  */
static PyObject *
blpy_block_syms_iter (PyObject *self)
{
  block_syms_iterator_object *iter_obj = (block_syms_iterator_object *) self;

  BLPY_ITER_REQUIRE_VALID (iter_obj->source);

  Py_INCREF (self);
  return self;
}

/* Return the next symbol in the iteration through the block's
   dictionary.  */
static PyObject *
blpy_block_syms_iternext (PyObject *self)
{
  block_syms_iterator_object *iter_obj = (block_syms_iterator_object *) self;
  struct symbol *sym;

  BLPY_ITER_REQUIRE_VALID (iter_obj->source);

  if (!iter_obj->initialized_p)
    {
      sym = dict_iterator_first (iter_obj->dict,  &(iter_obj->iter));
      iter_obj->initialized_p = 1;
    }
  else
    sym = dict_iterator_next (&(iter_obj->iter));

  if (sym == NULL)
    {
      PyErr_SetString (PyExc_StopIteration, _("Symbol is null."));
      return NULL;
    }

  return symbol_to_symbol_object (sym);
}

static void
blpy_block_syms_dealloc (PyObject *obj)
{
  block_syms_iterator_object *iter_obj = (block_syms_iterator_object *) obj;

  Py_XDECREF (iter_obj->source);
}

/* Implementation of gdb.Block.is_valid (self) -> Boolean.
   Returns True if this block object still exists in GDB.  */

static PyObject *
blpy_is_valid (PyObject *self, PyObject *args)
{
  struct block *block;

  block = block_object_to_block (self);
  if (block == NULL)
    Py_RETURN_FALSE;

  Py_RETURN_TRUE;
}

/* Implementation of gdb.BlockIterator.is_valid (self) -> Boolean.
   Returns True if this block iterator object still exists in GDB  */

static PyObject *
blpy_iter_is_valid (PyObject *self, PyObject *args)
{
  block_syms_iterator_object *iter_obj =
    (block_syms_iterator_object *) self;

  if (iter_obj->source->block == NULL)
    Py_RETURN_FALSE;

  Py_RETURN_TRUE;
}

/* Return the innermost lexical block containing the specified pc value,
   or 0 if there is none.  */
PyObject *
gdbpy_block_for_pc (PyObject *self, PyObject *args)
{
  gdb_py_ulongest pc;
  struct block *block;
  struct obj_section *section;
  struct symtab *symtab;

  if (!PyArg_ParseTuple (args, GDB_PY_LLU_ARG, &pc))
    return NULL;

  section = find_pc_mapped_section (pc);
  symtab = find_pc_sect_symtab (pc, section);
  if (!symtab || symtab->objfile == NULL)
    {
      PyErr_SetString (PyExc_RuntimeError,
		       _("Cannot locate object file for block."));
      return NULL;
    }

  block = block_for_pc (pc);
  if (block)
    return block_to_block_object (block, symtab->objfile);

  Py_RETURN_NONE;
}

/* This function is called when an objfile is about to be freed.
   Invalidate the block as further actions on the block would result
   in bad data.  All access to obj->symbol should be gated by
   BLPY_REQUIRE_VALID which will raise an exception on invalid
   blocks.  */
static void
del_objfile_blocks (struct objfile *objfile, void *datum)
{
  block_object *obj = datum;

  while (obj)
    {
      block_object *next = obj->next;

      obj->block = NULL;
      obj->objfile = NULL;
      obj->next = NULL;
      obj->prev = NULL;

      obj = next;
    }
}

void
gdbpy_initialize_blocks (void)
{
  block_object_type.tp_new = PyType_GenericNew;
  if (PyType_Ready (&block_object_type) < 0)
    return;

  block_syms_iterator_object_type.tp_new = PyType_GenericNew;
  if (PyType_Ready (&block_syms_iterator_object_type) < 0)
    return;

  /* Register an objfile "free" callback so we can properly
     invalidate blocks when an object file is about to be
     deleted.  */
  blpy_objfile_data_key
    = register_objfile_data_with_cleanup (NULL, del_objfile_blocks);

  Py_INCREF (&block_object_type);
  PyModule_AddObject (gdb_module, "Block", (PyObject *) &block_object_type);

  Py_INCREF (&block_syms_iterator_object_type);
  PyModule_AddObject (gdb_module, "BlockIterator",
		      (PyObject *) &block_syms_iterator_object_type);
}

\f

static PyMethodDef block_object_methods[] = {
  { "is_valid", blpy_is_valid, METH_NOARGS,
    "is_valid () -> Boolean.\n\
Return true if this block is valid, false if not." },
  {NULL}  /* Sentinel */
};

static PyGetSetDef block_object_getset[] = {
  { "start", blpy_get_start, NULL, "Start address of the block.", NULL },
  { "end", blpy_get_end, NULL, "End address of the block.", NULL },
  { "function", blpy_get_function, NULL,
    "Symbol that names the block, or None.", NULL },
  { "superblock", blpy_get_superblock, NULL,
    "Block containing the block, or None.", NULL },
  { NULL }  /* Sentinel */
};

PyTypeObject block_object_type = {
  PyObject_HEAD_INIT (NULL)
  0,				  /*ob_size*/
  "gdb.Block",			  /*tp_name*/
  sizeof (block_object),	  /*tp_basicsize*/
  0,				  /*tp_itemsize*/
  blpy_dealloc,                   /*tp_dealloc*/
  0,				  /*tp_print*/
  0,				  /*tp_getattr*/
  0,				  /*tp_setattr*/
  0,				  /*tp_compare*/
  0,				  /*tp_repr*/
  0,				  /*tp_as_number*/
  0,				  /*tp_as_sequence*/
  0,				  /*tp_as_mapping*/
  0,				  /*tp_hash */
  0,				  /*tp_call*/
  0,				  /*tp_str*/
  0,				  /*tp_getattro*/
  0,				  /*tp_setattro*/
  0,				  /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER,  /*tp_flags*/
  "GDB block object",		  /* tp_doc */
  0,				  /* tp_traverse */
  0,				  /* tp_clear */
  0,				  /* tp_richcompare */
  0,				  /* tp_weaklistoffset */
  blpy_iter,			  /* tp_iter */
  0,				  /* tp_iternext */
  block_object_methods,		  /* tp_methods */
  0,				  /* tp_members */
  block_object_getset		  /* tp_getset */
};

static PyMethodDef block_iterator_object_methods[] = {
  { "is_valid", blpy_iter_is_valid, METH_NOARGS,
    "is_valid () -> Boolean.\n\
Return true if this block iterator is valid, false if not." },
  {NULL}  /* Sentinel */
};

static PyTypeObject block_syms_iterator_object_type = {
  PyObject_HEAD_INIT (NULL)
  0,				  /*ob_size*/
  "gdb.BlockIterator",		  /*tp_name*/
  sizeof (block_syms_iterator_object),	      /*tp_basicsize*/
  0,				  /*tp_itemsize*/
  blpy_block_syms_dealloc,	  /*tp_dealloc*/
  0,				  /*tp_print*/
  0,				  /*tp_getattr*/
  0,				  /*tp_setattr*/
  0,				  /*tp_compare*/
  0,				  /*tp_repr*/
  0,				  /*tp_as_number*/
  0,				  /*tp_as_sequence*/
  0,				  /*tp_as_mapping*/
  0,				  /*tp_hash */
  0,				  /*tp_call*/
  0,				  /*tp_str*/
  0,				  /*tp_getattro*/
  0,				  /*tp_setattro*/
  0,				  /*tp_as_buffer*/
  Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_ITER,  /*tp_flags*/
  "GDB block syms iterator object",	      /*tp_doc */
  0,				  /*tp_traverse */
  0,				  /*tp_clear */
  0,				  /*tp_richcompare */
  0,				  /*tp_weaklistoffset */
  blpy_block_syms_iter,           /*tp_iter */
  blpy_block_syms_iternext,	  /*tp_iternext */
  block_iterator_object_methods   /*tp_methods */
};
Commit	Line	Data
f3e9a817 PM	1	/* Python interface to blocks.
f3e9a817 PM	2
7b6bb8da	3	Copyright (C) 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
f3e9a817 PM	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 "block.h"
	22	#include "dictionary.h"
	23	#include "symtab.h"
	24	#include "python-internal.h"
	25	#include "objfiles.h"
	26	#include "symtab.h"
	27
	28	typedef struct blpy_block_object {
	29	PyObject_HEAD
	30	/* The GDB block structure that represents a frame's code block. */
	31	struct block *block;
	32	/* The backing object file. There is no direct relationship in GDB
	33	between a block and an object file. When a block is created also
	34	store a pointer to the object file for later use. */
	35	struct objfile *objfile;
	36	/* Keep track of all blocks with a doubly-linked list. Needed for
	37	block invalidation if the source object file has been freed. */
	38	struct blpy_block_object *prev;
	39	struct blpy_block_object *next;
	40	} block_object;
	41
	42	typedef struct {
	43	PyObject_HEAD
	44	/* The block dictionary of symbols. */
	45	struct dictionary *dict;
	46	/* The iterator for that dictionary. */
	47	struct dict_iterator iter;
	48	/* Has the iterator been initialized flag. */
	49	int initialized_p;
	50	/* Pointer back to the original source block object. Needed to
	51	check if the block is still valid, and has not been invalidated
	52	when an object file has been freed. */
	53	struct blpy_block_object *source;
	54	} block_syms_iterator_object;
	55
	56	/* Require a valid block. All access to block_object->block should be
	57	gated by this call. */
	58	#define BLPY_REQUIRE_VALID(block_obj, block) \
	59	do { \
	60	block = block_object_to_block (block_obj); \
	61	if (block == NULL) \
	62	{ \
	63	PyErr_SetString (PyExc_RuntimeError, \
	64	_("Block is invalid.")); \
	65	return NULL; \
	66	} \
	67	} while (0)
68
69	/* Require a valid block. This macro is called during block iterator
70	creation, and at each next call. */
71	#define BLPY_ITER_REQUIRE_VALID(block_obj) \
72	do { \
73	if (block_obj->block == NULL) \
74	{ \
75	PyErr_SetString (PyExc_RuntimeError, \
76	_("Source block for iterator is invalid.")); \
77	return NULL; \
78	} \
79	} while (0)
80
81	static PyTypeObject block_syms_iterator_object_type;
82	static const struct objfile_data *blpy_objfile_data_key;
83
84	static PyObject *
85	blpy_iter (PyObject *self)
86	{
87	block_syms_iterator_object *block_iter_obj;
88	struct block *block = NULL;
89
90	BLPY_REQUIRE_VALID (self, block);
91
92	block_iter_obj = PyObject_New (block_syms_iterator_object,
93	&block_syms_iterator_object_type);
94	if (block_iter_obj == NULL)
95	return NULL;
96
97	block_iter_obj->dict = BLOCK_DICT (block);
98	block_iter_obj->initialized_p = 0;
99	Py_INCREF (self);
100	block_iter_obj->source = (block_object *) self;
101
102	return (PyObject *) block_iter_obj;
103	}
104
105	static PyObject *
106	blpy_get_start (PyObject self, void closure)
107	{
108	struct block *block = NULL;
109
110	BLPY_REQUIRE_VALID (self, block);
111
74aedc46	112	return gdb_py_object_from_ulongest (BLOCK_START (block));
f3e9a817 PM	113	}
	114
	115	static PyObject *
	116	blpy_get_end (PyObject self, void closure)
	117	{
	118	struct block *block = NULL;
	119
	120	BLPY_REQUIRE_VALID (self, block);
	121
74aedc46	122	return gdb_py_object_from_ulongest (BLOCK_END (block));
f3e9a817 PM	123	}
	124
	125	static PyObject *
	126	blpy_get_function (PyObject self, void closure)
	127	{
	128	struct symbol *sym;
	129	struct block *block = NULL;
	130
	131	BLPY_REQUIRE_VALID (self, block);
	132
	133	sym = BLOCK_FUNCTION (block);
	134	if (sym)
	135	return symbol_to_symbol_object (sym);
	136
	137	Py_RETURN_NONE;
	138	}
	139
	140	static PyObject *
	141	blpy_get_superblock (PyObject self, void closure)
	142	{
	143	struct block *block = NULL;
	144	struct block *super_block = NULL;
	145	block_object self_obj = (block_object ) self;
	146
	147	BLPY_REQUIRE_VALID (self, block);
	148
	149	super_block = BLOCK_SUPERBLOCK (block);
	150	if (super_block)
	151	return block_to_block_object (super_block, self_obj->objfile);
	152
	153	Py_RETURN_NONE;
	154	}
	155
	156	static void
	157	blpy_dealloc (PyObject *obj)
	158	{
	159	block_object block = (block_object ) obj;
	160
	161	if (block->prev)
	162	block->prev->next = block->next;
	163	else if (block->objfile)
	164	{
	165	set_objfile_data (block->objfile, blpy_objfile_data_key,
	166	block->next);
	167	}
	168	if (block->next)
	169	block->next->prev = block->prev;
	170	block->block = NULL;
	171	}
	172
	173	/* Given a block, and a block_object that has previously been
	174	allocated and initialized, populate the block_object with the
	175	struct block data. Also, register the block_object life-cycle
b021a221	176	with the life-cycle of the object file associated with this
f3e9a817 PM	177	block, if needed. */
	178	static void
	179	set_block (block_object obj, struct block block,
	180	struct objfile *objfile)
	181	{
	182	obj->block = block;
	183	obj->prev = NULL;
	184	if (objfile)
	185	{
	186	obj->objfile = objfile;
	187	obj->next = objfile_data (objfile, blpy_objfile_data_key);
	188	if (obj->next)
	189	obj->next->prev = obj;
	190	set_objfile_data (objfile, blpy_objfile_data_key, obj);
	191	}
	192	else
	193	obj->next = NULL;
	194	}
	195
	196	/* Create a new block object (gdb.Block) that encapsulates the struct
	197	block object from GDB. */
	198	PyObject *
	199	block_to_block_object (struct block block, struct objfile objfile)
	200	{
	201	block_object *block_obj;
	202
	203	block_obj = PyObject_New (block_object, &block_object_type);
	204	if (block_obj)
	205	set_block (block_obj, block, objfile);
	206
	207	return (PyObject *) block_obj;
	208	}
	209
	210	/* Return struct block reference that is wrapped by this object. */
	211	struct block *
	212	block_object_to_block (PyObject *obj)
	213	{
	214	if (! PyObject_TypeCheck (obj, &block_object_type))
	215	return NULL;
	216	return ((block_object *) obj)->block;
	217	}
	218
	219	/* Return a reference to the block iterator. */
	220	static PyObject *
	221	blpy_block_syms_iter (PyObject *self)
	222	{
	223	block_syms_iterator_object iter_obj = (block_syms_iterator_object ) self;
	224
	225	BLPY_ITER_REQUIRE_VALID (iter_obj->source);
	226
	227	Py_INCREF (self);
	228	return self;
	229	}
	230
	231	/* Return the next symbol in the iteration through the block's
	232	dictionary. */
	233	static PyObject *
	234	blpy_block_syms_iternext (PyObject *self)
	235	{
	236	block_syms_iterator_object iter_obj = (block_syms_iterator_object ) self;
	237	struct symbol *sym;
	238
	239	BLPY_ITER_REQUIRE_VALID (iter_obj->source);
	240
241	if (!iter_obj->initialized_p)
242	{
243	sym = dict_iterator_first (iter_obj->dict, &(iter_obj->iter));
244	iter_obj->initialized_p = 1;
245	}
246	else
247	sym = dict_iterator_next (&(iter_obj->iter));
248
249	if (sym == NULL)
250	{
044c0f87	251	PyErr_SetString (PyExc_StopIteration, _("Symbol is null."));
f3e9a817 PM	252	return NULL;
	253	}
	254
	255	return symbol_to_symbol_object (sym);
	256	}
	257
	258	static void
	259	blpy_block_syms_dealloc (PyObject *obj)
	260	{
	261	block_syms_iterator_object iter_obj = (block_syms_iterator_object ) obj;
d59b6f6c	262
f3e9a817 PM	263	Py_XDECREF (iter_obj->source);
	264	}
	265
29703da4 PM	266	/* Implementation of gdb.Block.is_valid (self) -> Boolean.
	267	Returns True if this block object still exists in GDB. */
	268
	269	static PyObject *
	270	blpy_is_valid (PyObject self, PyObject args)
	271	{
	272	struct block *block;
	273
	274	block = block_object_to_block (self);
	275	if (block == NULL)
	276	Py_RETURN_FALSE;
	277
	278	Py_RETURN_TRUE;
	279	}
	280
	281	/* Implementation of gdb.BlockIterator.is_valid (self) -> Boolean.
	282	Returns True if this block iterator object still exists in GDB */
	283
	284	static PyObject *
	285	blpy_iter_is_valid (PyObject self, PyObject args)
	286	{
	287	block_syms_iterator_object *iter_obj =
	288	(block_syms_iterator_object *) self;
	289
	290	if (iter_obj->source->block == NULL)
	291	Py_RETURN_FALSE;
	292
	293	Py_RETURN_TRUE;
	294	}
	295
f3e9a817 PM	296	/* Return the innermost lexical block containing the specified pc value,
	297	or 0 if there is none. */
	298	PyObject *
	299	gdbpy_block_for_pc (PyObject self, PyObject args)
	300	{
74aedc46	301	gdb_py_ulongest pc;
f3e9a817 PM	302	struct block *block;
	303	struct obj_section *section;
	304	struct symtab *symtab;
f3e9a817	305
74aedc46	306	if (!PyArg_ParseTuple (args, GDB_PY_LLU_ARG, &pc))
f3e9a817 PM	307	return NULL;
	308
	309	section = find_pc_mapped_section (pc);
	310	symtab = find_pc_sect_symtab (pc, section);
	311	if (!symtab \|\| symtab->objfile == NULL)
	312	{
	313	PyErr_SetString (PyExc_RuntimeError,
044c0f87	314	_("Cannot locate object file for block."));
f3e9a817 PM	315	return NULL;
	316	}
	317
	318	block = block_for_pc (pc);
	319	if (block)
	320	return block_to_block_object (block, symtab->objfile);
	321
	322	Py_RETURN_NONE;
	323	}
	324
	325	/* This function is called when an objfile is about to be freed.
	326	Invalidate the block as further actions on the block would result
	327	in bad data. All access to obj->symbol should be gated by
	328	BLPY_REQUIRE_VALID which will raise an exception on invalid
	329	blocks. */
	330	static void
	331	del_objfile_blocks (struct objfile objfile, void datum)
	332	{
	333	block_object *obj = datum;
d59b6f6c	334
f3e9a817 PM	335	while (obj)
	336	{
	337	block_object *next = obj->next;
	338
	339	obj->block = NULL;
	340	obj->objfile = NULL;
	341	obj->next = NULL;
	342	obj->prev = NULL;
	343
	344	obj = next;
	345	}
	346	}
	347
	348	void
	349	gdbpy_initialize_blocks (void)
	350	{
	351	block_object_type.tp_new = PyType_GenericNew;
	352	if (PyType_Ready (&block_object_type) < 0)
	353	return;
	354
	355	block_syms_iterator_object_type.tp_new = PyType_GenericNew;
	356	if (PyType_Ready (&block_syms_iterator_object_type) < 0)
	357	return;
	358
	359	/* Register an objfile "free" callback so we can properly
	360	invalidate blocks when an object file is about to be
	361	deleted. */
	362	blpy_objfile_data_key
	363	= register_objfile_data_with_cleanup (NULL, del_objfile_blocks);
	364
	365	Py_INCREF (&block_object_type);
	366	PyModule_AddObject (gdb_module, "Block", (PyObject *) &block_object_type);
	367
	368	Py_INCREF (&block_syms_iterator_object_type);
	369	PyModule_AddObject (gdb_module, "BlockIterator",
	370	(PyObject *) &block_syms_iterator_object_type);
	371	}
	372
	373	\f
	374
29703da4 PM	375	static PyMethodDef block_object_methods[] = {
	376	{ "is_valid", blpy_is_valid, METH_NOARGS,
	377	"is_valid () -> Boolean.\n\
	378	Return true if this block is valid, false if not." },
	379	{NULL} /* Sentinel */
	380	};
	381
f3e9a817 PM	382	static PyGetSetDef block_object_getset[] = {
	383	{ "start", blpy_get_start, NULL, "Start address of the block.", NULL },
	384	{ "end", blpy_get_end, NULL, "End address of the block.", NULL },
	385	{ "function", blpy_get_function, NULL,
	386	"Symbol that names the block, or None.", NULL },
	387	{ "superblock", blpy_get_superblock, NULL,
	388	"Block containing the block, or None.", NULL },
	389	{ NULL } /* Sentinel */
	390	};
	391
	392	PyTypeObject block_object_type = {
	393	PyObject_HEAD_INIT (NULL)
	394	0, /ob_size/
	395	"gdb.Block", /tp_name/
	396	sizeof (block_object), /tp_basicsize/
	397	0, /tp_itemsize/
	398	blpy_dealloc, /tp_dealloc/
	399	0, /tp_print/
	400	0, /tp_getattr/
	401	0, /tp_setattr/
	402	0, /tp_compare/
	403	0, /tp_repr/
	404	0, /tp_as_number/
	405	0, /tp_as_sequence/
	406	0, /tp_as_mapping/
	407	0, /tp_hash /
	408	0, /tp_call/
	409	0, /tp_str/
	410	0, /tp_getattro/
	411	0, /tp_setattro/
	412	0, /tp_as_buffer/
	413	Py_TPFLAGS_DEFAULT \| Py_TPFLAGS_HAVE_ITER, /tp_flags/
	414	"GDB block object", /* tp_doc */
	415	0, /* tp_traverse */
	416	0, /* tp_clear */
	417	0, /* tp_richcompare */
	418	0, /* tp_weaklistoffset */
	419	blpy_iter, /* tp_iter */
	420	0, /* tp_iternext */
29703da4	421	block_object_methods, /* tp_methods */
f3e9a817 PM	422	0, /* tp_members */
	423	block_object_getset /* tp_getset */
	424	};
	425
29703da4 PM	426	static PyMethodDef block_iterator_object_methods[] = {
	427	{ "is_valid", blpy_iter_is_valid, METH_NOARGS,
	428	"is_valid () -> Boolean.\n\
	429	Return true if this block iterator is valid, false if not." },
	430	{NULL} /* Sentinel */
	431	};
	432
f3e9a817 PM	433	static PyTypeObject block_syms_iterator_object_type = {
	434	PyObject_HEAD_INIT (NULL)
	435	0, /ob_size/
	436	"gdb.BlockIterator", /tp_name/
	437	sizeof (block_syms_iterator_object), /tp_basicsize/
	438	0, /tp_itemsize/
	439	blpy_block_syms_dealloc, /tp_dealloc/
	440	0, /tp_print/
	441	0, /tp_getattr/
	442	0, /tp_setattr/
	443	0, /tp_compare/
	444	0, /tp_repr/
	445	0, /tp_as_number/
	446	0, /tp_as_sequence/
	447	0, /tp_as_mapping/
	448	0, /tp_hash /
	449	0, /tp_call/
	450	0, /tp_str/
	451	0, /tp_getattro/
	452	0, /tp_setattro/
	453	0, /tp_as_buffer/
	454	Py_TPFLAGS_DEFAULT \| Py_TPFLAGS_HAVE_ITER, /tp_flags/
	455	"GDB block syms iterator object", /tp_doc /
	456	0, /tp_traverse /
	457	0, /tp_clear /
	458	0, /tp_richcompare /
	459	0, /tp_weaklistoffset /
	460	blpy_block_syms_iter, /tp_iter /
	461	blpy_block_syms_iternext, /tp_iternext /
29703da4	462	block_iterator_object_methods /tp_methods /
f3e9a817	463	};