[binutils.git] / gdb / solib-target.c

/* Definitions for targets which report shared library events.

   Copyright (C) 2007, 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 "objfiles.h"
#include "solist.h"
#include "symtab.h"
#include "symfile.h"
#include "target.h"
#include "vec.h"
#include "solib-target.h"

#include "gdb_string.h"

DEF_VEC_O(CORE_ADDR);

/* Private data for each loaded library.  */
struct lm_info
{
  /* The library's name.  The name is normally kept in the struct
     so_list; it is only here during XML parsing.  */
  char *name;

  /* The target can either specify segment bases or section bases, not
     both.  */

  /* The base addresses for each independently relocatable segment of
     this shared library.  */
  VEC(CORE_ADDR) *segment_bases;

  /* The base addresses for each independently allocatable,
     relocatable section of this shared library.  */
  VEC(CORE_ADDR) *section_bases;

  /* The cached offsets for each section of this shared library,
     determined from SEGMENT_BASES, or SECTION_BASES.  */
  struct section_offsets *offsets;
};

typedef struct lm_info *lm_info_p;
DEF_VEC_P(lm_info_p);

#if !defined(HAVE_LIBEXPAT)

static VEC(lm_info_p) *
solib_target_parse_libraries (const char *library)
{
  static int have_warned;

  if (!have_warned)
    {
      have_warned = 1;
      warning (_("Can not parse XML library list; XML support was disabled "
		 "at compile time"));
    }

  return NULL;
}

#else /* HAVE_LIBEXPAT */

#include "xml-support.h"

/* Handle the start of a <segment> element.  */

static void
library_list_start_segment (struct gdb_xml_parser *parser,
			    const struct gdb_xml_element *element,
			    void *user_data, VEC(gdb_xml_value_s) *attributes)
{
  VEC(lm_info_p) **list = user_data;
  struct lm_info *last = VEC_last (lm_info_p, *list);
  ULONGEST *address_p = VEC_index (gdb_xml_value_s, attributes, 0)->value;
  CORE_ADDR address = (CORE_ADDR) *address_p;

  if (last->section_bases != NULL)
    gdb_xml_error (parser,
		   _("Library list with both segments and sections"));

  VEC_safe_push (CORE_ADDR, last->segment_bases, &address);
}

static void
library_list_start_section (struct gdb_xml_parser *parser,
			    const struct gdb_xml_element *element,
			    void *user_data, VEC(gdb_xml_value_s) *attributes)
{
  VEC(lm_info_p) **list = user_data;
  struct lm_info *last = VEC_last (lm_info_p, *list);
  ULONGEST *address_p = VEC_index (gdb_xml_value_s, attributes, 0)->value;
  CORE_ADDR address = (CORE_ADDR) *address_p;

  if (last->segment_bases != NULL)
    gdb_xml_error (parser,
		   _("Library list with both segments and sections"));

  VEC_safe_push (CORE_ADDR, last->section_bases, &address);
}

/* Handle the start of a <library> element.  */

static void
library_list_start_library (struct gdb_xml_parser *parser,
			    const struct gdb_xml_element *element,
			    void *user_data, VEC(gdb_xml_value_s) *attributes)
{
  VEC(lm_info_p) **list = user_data;
  struct lm_info *item = XZALLOC (struct lm_info);
  const char *name = VEC_index (gdb_xml_value_s, attributes, 0)->value;

  item->name = xstrdup (name);
  VEC_safe_push (lm_info_p, *list, item);
}

static void
library_list_end_library (struct gdb_xml_parser *parser,
			  const struct gdb_xml_element *element,
			  void *user_data, const char *body_text)
{
  VEC(lm_info_p) **list = user_data;
  struct lm_info *lm_info = VEC_last (lm_info_p, *list);

  if (lm_info->segment_bases == NULL
      && lm_info->section_bases == NULL)
    gdb_xml_error (parser,
		   _("No segment or section bases defined"));
}


/* Handle the start of a <library-list> element.  */

static void
library_list_start_list (struct gdb_xml_parser *parser,
			 const struct gdb_xml_element *element,
			 void *user_data, VEC(gdb_xml_value_s) *attributes)
{
  char *version = VEC_index (gdb_xml_value_s, attributes, 0)->value;

  if (strcmp (version, "1.0") != 0)
    gdb_xml_error (parser,
		   _("Library list has unsupported version \"%s\""),
		   version);
}

/* Discard the constructed library list.  */

static void
solib_target_free_library_list (void *p)
{
  VEC(lm_info_p) **result = p;
  struct lm_info *info;
  int ix;

  for (ix = 0; VEC_iterate (lm_info_p, *result, ix, info); ix++)
    {
      xfree (info->name);
      VEC_free (CORE_ADDR, info->segment_bases);
      VEC_free (CORE_ADDR, info->section_bases);
      xfree (info);
    }
  VEC_free (lm_info_p, *result);
  *result = NULL;
}

/* The allowed elements and attributes for an XML library list.
   The root element is a <library-list>.  */

const struct gdb_xml_attribute segment_attributes[] = {
  { "address", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
  { NULL, GDB_XML_AF_NONE, NULL, NULL }
};

const struct gdb_xml_attribute section_attributes[] = {
  { "address", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
  { NULL, GDB_XML_AF_NONE, NULL, NULL }
};

const struct gdb_xml_element library_children[] = {
  { "segment", segment_attributes, NULL,
    GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
    library_list_start_segment, NULL },
  { "section", section_attributes, NULL,
    GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
    library_list_start_section, NULL },
  { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
};

const struct gdb_xml_attribute library_attributes[] = {
  { "name", GDB_XML_AF_NONE, NULL, NULL },
  { NULL, GDB_XML_AF_NONE, NULL, NULL }
};

const struct gdb_xml_element library_list_children[] = {
  { "library", library_attributes, library_children,
    GDB_XML_EF_REPEATABLE | GDB_XML_EF_OPTIONAL,
    library_list_start_library, library_list_end_library },
  { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
};

const struct gdb_xml_attribute library_list_attributes[] = {
  { "version", GDB_XML_AF_NONE, NULL, NULL },
  { NULL, GDB_XML_AF_NONE, NULL, NULL }
};

const struct gdb_xml_element library_list_elements[] = {
  { "library-list", library_list_attributes, library_list_children,
    GDB_XML_EF_NONE, library_list_start_list, NULL },
  { NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
};

static VEC(lm_info_p) *
solib_target_parse_libraries (const char *library)
{
  struct gdb_xml_parser *parser;
  VEC(lm_info_p) *result = NULL;
  struct cleanup *before_deleting_result, *back_to;

  back_to = make_cleanup (null_cleanup, NULL);
  parser = gdb_xml_create_parser_and_cleanup (_("target library list"),
					      library_list_elements, &result);
  gdb_xml_use_dtd (parser, "library-list.dtd");

  before_deleting_result = make_cleanup (solib_target_free_library_list,
					 &result);

  if (gdb_xml_parse (parser, library) == 0)
    /* Parsed successfully, don't need to delete the result.  */
    discard_cleanups (before_deleting_result);

  do_cleanups (back_to);
  return result;
}
#endif

static struct so_list *
solib_target_current_sos (void)
{
  struct so_list *new_solib, *start = NULL, *last = NULL;
  const char *library_document;
  VEC(lm_info_p) *library_list;
  struct lm_info *info;
  int ix;

  /* Fetch the list of shared libraries.  */
  library_document = target_read_stralloc (&current_target,
					   TARGET_OBJECT_LIBRARIES,
					   NULL);
  if (library_document == NULL)
    return NULL;

  /* Parse the list.  */
  library_list = solib_target_parse_libraries (library_document);
  if (library_list == NULL)
    return NULL;

  /* Build a struct so_list for each entry on the list.  */
  for (ix = 0; VEC_iterate (lm_info_p, library_list, ix, info); ix++)
    {
      new_solib = XZALLOC (struct so_list);
      strncpy (new_solib->so_name, info->name, SO_NAME_MAX_PATH_SIZE - 1);
      new_solib->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
      strncpy (new_solib->so_original_name, info->name,
	       SO_NAME_MAX_PATH_SIZE - 1);
      new_solib->so_original_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
      new_solib->lm_info = info;

      /* We no longer need this copy of the name.  */
      xfree (info->name);
      info->name = NULL;

      /* Add it to the list.  */
      if (!start)
	last = start = new_solib;
      else
	{
	  last->next = new_solib;
	  last = new_solib;
	}
    }

  /* Free the library list, but not its members.  */
  VEC_free (lm_info_p, library_list);

  return start;
}

static void
solib_target_special_symbol_handling (void)
{
  /* Nothing needed.  */
}

static void
solib_target_solib_create_inferior_hook (int from_tty)
{
  /* Nothing needed.  */
}

static void
solib_target_clear_solib (void)
{
  /* Nothing needed.  */
}

static void
solib_target_free_so (struct so_list *so)
{
  gdb_assert (so->lm_info->name == NULL);
  xfree (so->lm_info->offsets);
  VEC_free (CORE_ADDR, so->lm_info->segment_bases);
  xfree (so->lm_info);
}

static void
solib_target_relocate_section_addresses (struct so_list *so,
					 struct target_section *sec)
{
  int flags = bfd_get_section_flags (sec->bfd, sec->the_bfd_section);
  CORE_ADDR offset;

  /* Build the offset table only once per object file.  We can not do
     it any earlier, since we need to open the file first.  */
  if (so->lm_info->offsets == NULL)
    {
      int num_sections = bfd_count_sections (so->abfd);

      so->lm_info->offsets = xzalloc (SIZEOF_N_SECTION_OFFSETS (num_sections));

      if (so->lm_info->section_bases)
	{
	  int i;
	  asection *sect;
	  int num_section_bases
	    = VEC_length (CORE_ADDR, so->lm_info->section_bases);
	  int num_alloc_sections = 0;

	  for (i = 0, sect = so->abfd->sections;
	       sect != NULL;
	       i++, sect = sect->next)
	    if ((bfd_get_section_flags (so->abfd, sect) & SEC_ALLOC))
	      num_alloc_sections++;

	  if (num_alloc_sections != num_section_bases)
	    warning (_("\
Could not relocate shared library \"%s\": wrong number of ALLOC sections"),
		     so->so_name);
	  else
	    {
	      int bases_index = 0;
	      int found_range = 0;
	      CORE_ADDR *section_bases;

	      section_bases = VEC_address (CORE_ADDR,
					   so->lm_info->section_bases);

	      so->addr_low = ~(CORE_ADDR) 0;
	      so->addr_high = 0;
	      for (i = 0, sect = so->abfd->sections;
		   sect != NULL;
		   i++, sect = sect->next)
		{
		  if (!(bfd_get_section_flags (so->abfd, sect) & SEC_ALLOC))
		    continue;
		  if (bfd_section_size (so->abfd, sect) > 0)
		    {
		      CORE_ADDR low, high;

		      low = section_bases[i];
		      high = low + bfd_section_size (so->abfd, sect) - 1;

		      if (low < so->addr_low)
			so->addr_low = low;
		      if (high > so->addr_high)
			so->addr_high = high;
		      gdb_assert (so->addr_low <= so->addr_high);
		      found_range = 1;
		    }
		  so->lm_info->offsets->offsets[i]
		    = section_bases[bases_index];
		  bases_index++;
		}
	      if (!found_range)
		so->addr_low = so->addr_high = 0;
	      gdb_assert (so->addr_low <= so->addr_high);
	    }
	}
      else if (so->lm_info->segment_bases)
	{
	  struct symfile_segment_data *data;

	  data = get_symfile_segment_data (so->abfd);
	  if (data == NULL)
	    warning (_("\
Could not relocate shared library \"%s\": no segments"), so->so_name);
	  else
	    {
	      ULONGEST orig_delta;
	      int i;
	      int num_bases;
	      CORE_ADDR *segment_bases;

	      num_bases = VEC_length (CORE_ADDR, so->lm_info->segment_bases);
	      segment_bases = VEC_address (CORE_ADDR,
					   so->lm_info->segment_bases);

	      if (!symfile_map_offsets_to_segments (so->abfd, data,
						    so->lm_info->offsets,
						    num_bases, segment_bases))
		warning (_("\
Could not relocate shared library \"%s\": bad offsets"), so->so_name);

	      /* Find the range of addresses to report for this library in
		 "info sharedlibrary".  Report any consecutive segments
		 which were relocated as a single unit.  */
	      gdb_assert (num_bases > 0);
	      orig_delta = segment_bases[0] - data->segment_bases[0];

	      for (i = 1; i < data->num_segments; i++)
		{
		  /* If we have run out of offsets, assume all
		     remaining segments have the same offset.  */
		  if (i >= num_bases)
		    continue;

		  /* If this segment does not have the same offset, do
		     not include it in the library's range.  */
		  if (segment_bases[i] - data->segment_bases[i] != orig_delta)
		    break;
		}

	      so->addr_low = segment_bases[0];
	      so->addr_high = (data->segment_bases[i - 1]
			       + data->segment_sizes[i - 1]
			       + orig_delta);
	      gdb_assert (so->addr_low <= so->addr_high);

	      free_symfile_segment_data (data);
	    }
	}
    }

  offset = so->lm_info->offsets->offsets[sec->the_bfd_section->index];
  sec->addr += offset;
  sec->endaddr += offset;
}

static int
solib_target_open_symbol_file_object (void *from_ttyp)
{
  /* We can't locate the main symbol file based on the target's
     knowledge; the user has to specify it.  */
  return 0;
}

static int
solib_target_in_dynsym_resolve_code (CORE_ADDR pc)
{
  /* We don't have a range of addresses for the dynamic linker; there
     may not be one in the program's address space.  So only report
     PLT entries (which may be import stubs).  */
  return in_plt_section (pc, NULL);
}

struct target_so_ops solib_target_so_ops;

/* -Wmissing-prototypes */
extern initialize_file_ftype _initialize_solib_target;

void
_initialize_solib_target (void)
{
  solib_target_so_ops.relocate_section_addresses
    = solib_target_relocate_section_addresses;
  solib_target_so_ops.free_so = solib_target_free_so;
  solib_target_so_ops.clear_solib = solib_target_clear_solib;
  solib_target_so_ops.solib_create_inferior_hook
    = solib_target_solib_create_inferior_hook;
  solib_target_so_ops.special_symbol_handling
    = solib_target_special_symbol_handling;
  solib_target_so_ops.current_sos = solib_target_current_sos;
  solib_target_so_ops.open_symbol_file_object
    = solib_target_open_symbol_file_object;
  solib_target_so_ops.in_dynsym_resolve_code
    = solib_target_in_dynsym_resolve_code;
  solib_target_so_ops.bfd_open = solib_bfd_open;

  /* Set current_target_so_ops to solib_target_so_ops if not already
     set.  */
  if (current_target_so_ops == 0)
    current_target_so_ops = &solib_target_so_ops;
}
Commit	Line	Data
cfa9d6d9 DJ	1	/* Definitions for targets which report shared library events.
cfa9d6d9 DJ	2
7b6bb8da	3	Copyright (C) 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
cfa9d6d9 DJ	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
a9762ec7	9	the Free Software Foundation; either version 3 of the License, or
cfa9d6d9 DJ	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
a9762ec7	18	along with this program. If not, see <http://www.gnu.org/licenses/>. */
cfa9d6d9 DJ	19
	20	#include "defs.h"
	21	#include "objfiles.h"
	22	#include "solist.h"
	23	#include "symtab.h"
	24	#include "symfile.h"
	25	#include "target.h"
	26	#include "vec.h"
8d465389	27	#include "solib-target.h"
cfa9d6d9 DJ	28
	29	#include "gdb_string.h"
	30
	31	DEF_VEC_O(CORE_ADDR);
	32
	33	/* Private data for each loaded library. */
	34	struct lm_info
	35	{
	36	/* The library's name. The name is normally kept in the struct
	37	so_list; it is only here during XML parsing. */
	38	char *name;
	39
1fddbabb PA	40	/* The target can either specify segment bases or section bases, not
	41	both. */
	42
cfa9d6d9 DJ	43	/* The base addresses for each independently relocatable segment of
	44	this shared library. */
	45	VEC(CORE_ADDR) *segment_bases;
	46
1fddbabb PA	47	/* The base addresses for each independently allocatable,
	48	relocatable section of this shared library. */
	49	VEC(CORE_ADDR) *section_bases;
	50
cfa9d6d9	51	/* The cached offsets for each section of this shared library,
1fddbabb	52	determined from SEGMENT_BASES, or SECTION_BASES. */
cfa9d6d9 DJ	53	struct section_offsets *offsets;
	54	};
	55
	56	typedef struct lm_info *lm_info_p;
	57	DEF_VEC_P(lm_info_p);
	58
	59	#if !defined(HAVE_LIBEXPAT)
	60
899cff7a	61	static VEC(lm_info_p) *
cfa9d6d9 DJ	62	solib_target_parse_libraries (const char *library)
	63	{
	64	static int have_warned;
	65
	66	if (!have_warned)
	67	{
	68	have_warned = 1;
	69	warning (_("Can not parse XML library list; XML support was disabled "
	70	"at compile time"));
	71	}
	72
	73	return NULL;
	74	}
	75
	76	#else /* HAVE_LIBEXPAT */
	77
	78	#include "xml-support.h"
	79
	80	/* Handle the start of a <segment> element. */
	81
	82	static void
	83	library_list_start_segment (struct gdb_xml_parser *parser,
	84	const struct gdb_xml_element *element,
	85	void user_data, VEC(gdb_xml_value_s) attributes)
	86	{
	87	VEC(lm_info_p) **list = user_data;
	88	struct lm_info last = VEC_last (lm_info_p, list);
	89	ULONGEST *address_p = VEC_index (gdb_xml_value_s, attributes, 0)->value;
358eb95e	90	CORE_ADDR address = (CORE_ADDR) *address_p;
cfa9d6d9	91
1fddbabb PA	92	if (last->section_bases != NULL)
	93	gdb_xml_error (parser,
	94	_("Library list with both segments and sections"));
	95
358eb95e	96	VEC_safe_push (CORE_ADDR, last->segment_bases, &address);
cfa9d6d9 DJ	97	}
cfa9d6d9 DJ	98
1fddbabb PA	99	static void
	100	library_list_start_section (struct gdb_xml_parser *parser,
	101	const struct gdb_xml_element *element,
	102	void user_data, VEC(gdb_xml_value_s) attributes)
	103	{
	104	VEC(lm_info_p) **list = user_data;
	105	struct lm_info last = VEC_last (lm_info_p, list);
	106	ULONGEST *address_p = VEC_index (gdb_xml_value_s, attributes, 0)->value;
	107	CORE_ADDR address = (CORE_ADDR) *address_p;
	108
	109	if (last->segment_bases != NULL)
	110	gdb_xml_error (parser,
	111	_("Library list with both segments and sections"));
	112
	113	VEC_safe_push (CORE_ADDR, last->section_bases, &address);
	114	}
	115
cfa9d6d9 DJ	116	/* Handle the start of a <library> element. */
	117
	118	static void
	119	library_list_start_library (struct gdb_xml_parser *parser,
	120	const struct gdb_xml_element *element,
	121	void user_data, VEC(gdb_xml_value_s) attributes)
	122	{
	123	VEC(lm_info_p) **list = user_data;
	124	struct lm_info *item = XZALLOC (struct lm_info);
	125	const char *name = VEC_index (gdb_xml_value_s, attributes, 0)->value;
	126
	127	item->name = xstrdup (name);
	128	VEC_safe_push (lm_info_p, *list, item);
	129	}
	130
1fddbabb PA	131	static void
	132	library_list_end_library (struct gdb_xml_parser *parser,
	133	const struct gdb_xml_element *element,
	134	void user_data, const char body_text)
	135	{
	136	VEC(lm_info_p) **list = user_data;
	137	struct lm_info lm_info = VEC_last (lm_info_p, list);
433759f7	138
1fddbabb PA	139	if (lm_info->segment_bases == NULL
	140	&& lm_info->section_bases == NULL)
	141	gdb_xml_error (parser,
	142	_("No segment or section bases defined"));
	143	}
	144
	145
cfa9d6d9 DJ	146	/* Handle the start of a <library-list> element. */
	147
	148	static void
	149	library_list_start_list (struct gdb_xml_parser *parser,
	150	const struct gdb_xml_element *element,
	151	void user_data, VEC(gdb_xml_value_s) attributes)
	152	{
	153	char *version = VEC_index (gdb_xml_value_s, attributes, 0)->value;
	154
	155	if (strcmp (version, "1.0") != 0)
	156	gdb_xml_error (parser,
	157	_("Library list has unsupported version \"%s\""),
	158	version);
	159	}
	160
	161	/* Discard the constructed library list. */
	162
	163	static void
	164	solib_target_free_library_list (void *p)
	165	{
	166	VEC(lm_info_p) **result = p;
	167	struct lm_info *info;
	168	int ix;
	169
	170	for (ix = 0; VEC_iterate (lm_info_p, *result, ix, info); ix++)
	171	{
	172	xfree (info->name);
	173	VEC_free (CORE_ADDR, info->segment_bases);
1fddbabb	174	VEC_free (CORE_ADDR, info->section_bases);
cfa9d6d9 DJ	175	xfree (info);
	176	}
	177	VEC_free (lm_info_p, *result);
	178	*result = NULL;
	179	}
	180
	181	/* The allowed elements and attributes for an XML library list.
	182	The root element is a <library-list>. */
	183
	184	const struct gdb_xml_attribute segment_attributes[] = {
	185	{ "address", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
	186	{ NULL, GDB_XML_AF_NONE, NULL, NULL }
	187	};
	188
1fddbabb PA	189	const struct gdb_xml_attribute section_attributes[] = {
	190	{ "address", GDB_XML_AF_NONE, gdb_xml_parse_attr_ulongest, NULL },
	191	{ NULL, GDB_XML_AF_NONE, NULL, NULL }
	192	};
	193
cfa9d6d9	194	const struct gdb_xml_element library_children[] = {
1fddbabb PA	195	{ "segment", segment_attributes, NULL,
1fddbabb PA	196	GDB_XML_EF_REPEATABLE \| GDB_XML_EF_OPTIONAL,
cfa9d6d9	197	library_list_start_segment, NULL },
1fddbabb PA	198	{ "section", section_attributes, NULL,
	199	GDB_XML_EF_REPEATABLE \| GDB_XML_EF_OPTIONAL,
	200	library_list_start_section, NULL },
cfa9d6d9 DJ	201	{ NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
	202	};
	203
	204	const struct gdb_xml_attribute library_attributes[] = {
	205	{ "name", GDB_XML_AF_NONE, NULL, NULL },
	206	{ NULL, GDB_XML_AF_NONE, NULL, NULL }
	207	};
	208
	209	const struct gdb_xml_element library_list_children[] = {
	210	{ "library", library_attributes, library_children,
	211	GDB_XML_EF_REPEATABLE \| GDB_XML_EF_OPTIONAL,
1fddbabb	212	library_list_start_library, library_list_end_library },
cfa9d6d9 DJ	213	{ NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
	214	};
	215
	216	const struct gdb_xml_attribute library_list_attributes[] = {
	217	{ "version", GDB_XML_AF_NONE, NULL, NULL },
	218	{ NULL, GDB_XML_AF_NONE, NULL, NULL }
	219	};
	220
	221	const struct gdb_xml_element library_list_elements[] = {
	222	{ "library-list", library_list_attributes, library_list_children,
	223	GDB_XML_EF_NONE, library_list_start_list, NULL },
	224	{ NULL, NULL, NULL, GDB_XML_EF_NONE, NULL, NULL }
	225	};
	226
	227	static VEC(lm_info_p) *
	228	solib_target_parse_libraries (const char *library)
	229	{
	230	struct gdb_xml_parser *parser;
	231	VEC(lm_info_p) *result = NULL;
	232	struct cleanup before_deleting_result, back_to;
	233
	234	back_to = make_cleanup (null_cleanup, NULL);
	235	parser = gdb_xml_create_parser_and_cleanup (_("target library list"),
	236	library_list_elements, &result);
	237	gdb_xml_use_dtd (parser, "library-list.dtd");
	238
	239	before_deleting_result = make_cleanup (solib_target_free_library_list,
	240	&result);
	241
	242	if (gdb_xml_parse (parser, library) == 0)
	243	/* Parsed successfully, don't need to delete the result. */
	244	discard_cleanups (before_deleting_result);
	245
	246	do_cleanups (back_to);
	247	return result;
	248	}
	249	#endif
	250
	251	static struct so_list *
	252	solib_target_current_sos (void)
	253	{
	254	struct so_list new_solib, start = NULL, *last = NULL;
	255	const char *library_document;
	256	VEC(lm_info_p) *library_list;
	257	struct lm_info *info;
	258	int ix;
	259
	260	/* Fetch the list of shared libraries. */
	261	library_document = target_read_stralloc (&current_target,
	262	TARGET_OBJECT_LIBRARIES,
	263	NULL);
	264	if (library_document == NULL)
	265	return NULL;
	266
	267	/* Parse the list. */
	268	library_list = solib_target_parse_libraries (library_document);
	269	if (library_list == NULL)
	270	return NULL;
	271
	272	/* Build a struct so_list for each entry on the list. */
	273	for (ix = 0; VEC_iterate (lm_info_p, library_list, ix, info); ix++)
	274	{
	275	new_solib = XZALLOC (struct so_list);
	276	strncpy (new_solib->so_name, info->name, SO_NAME_MAX_PATH_SIZE - 1);
277	new_solib->so_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
278	strncpy (new_solib->so_original_name, info->name,
279	SO_NAME_MAX_PATH_SIZE - 1);
280	new_solib->so_original_name[SO_NAME_MAX_PATH_SIZE - 1] = '\0';
281	new_solib->lm_info = info;
282
283	/* We no longer need this copy of the name. */
284	xfree (info->name);
285	info->name = NULL;
286
287	/* Add it to the list. */
288	if (!start)
289	last = start = new_solib;
290	else
291	{
292	last->next = new_solib;
293	last = new_solib;
294	}
295	}
296
297	/* Free the library list, but not its members. */
298	VEC_free (lm_info_p, library_list);
299
300	return start;
301	}
302
303	static void
304	solib_target_special_symbol_handling (void)
305	{
306	/* Nothing needed. */
307	}
308
309	static void
268a4a75	310	solib_target_solib_create_inferior_hook (int from_tty)
cfa9d6d9 DJ	311	{
	312	/* Nothing needed. */
	313	}
	314
	315	static void
	316	solib_target_clear_solib (void)
	317	{
	318	/* Nothing needed. */
	319	}
	320
	321	static void
	322	solib_target_free_so (struct so_list *so)
	323	{
	324	gdb_assert (so->lm_info->name == NULL);
	325	xfree (so->lm_info->offsets);
	326	VEC_free (CORE_ADDR, so->lm_info->segment_bases);
	327	xfree (so->lm_info);
	328	}
	329
	330	static void
	331	solib_target_relocate_section_addresses (struct so_list *so,
0542c86d	332	struct target_section *sec)
cfa9d6d9 DJ	333	{
	334	int flags = bfd_get_section_flags (sec->bfd, sec->the_bfd_section);
	335	CORE_ADDR offset;
	336
	337	/* Build the offset table only once per object file. We can not do
	338	it any earlier, since we need to open the file first. */
	339	if (so->lm_info->offsets == NULL)
	340	{
cfa9d6d9 DJ	341	int num_sections = bfd_count_sections (so->abfd);
	342
	343	so->lm_info->offsets = xzalloc (SIZEOF_N_SECTION_OFFSETS (num_sections));
	344
1fddbabb	345	if (so->lm_info->section_bases)
cfa9d6d9	346	{
cfa9d6d9	347	int i;
1fddbabb PA	348	asection *sect;
	349	int num_section_bases
	350	= VEC_length (CORE_ADDR, so->lm_info->section_bases);
	351	int num_alloc_sections = 0;
	352
	353	for (i = 0, sect = so->abfd->sections;
	354	sect != NULL;
	355	i++, sect = sect->next)
	356	if ((bfd_get_section_flags (so->abfd, sect) & SEC_ALLOC))
	357	num_alloc_sections++;
	358
	359	if (num_alloc_sections != num_section_bases)
	360	warning (_("\
	361	Could not relocate shared library \"%s\": wrong number of ALLOC sections"),
cfa9d6d9	362	so->so_name);
1fddbabb	363	else
cfa9d6d9	364	{
1fddbabb PA	365	int bases_index = 0;
	366	int found_range = 0;
	367	CORE_ADDR *section_bases;
433759f7	368
1fddbabb PA	369	section_bases = VEC_address (CORE_ADDR,
	370	so->lm_info->section_bases);
	371
	372	so->addr_low = ~(CORE_ADDR) 0;
	373	so->addr_high = 0;
	374	for (i = 0, sect = so->abfd->sections;
	375	sect != NULL;
	376	i++, sect = sect->next)
	377	{
	378	if (!(bfd_get_section_flags (so->abfd, sect) & SEC_ALLOC))
	379	continue;
	380	if (bfd_section_size (so->abfd, sect) > 0)
	381	{
	382	CORE_ADDR low, high;
433759f7	383
1fddbabb PA	384	low = section_bases[i];
	385	high = low + bfd_section_size (so->abfd, sect) - 1;
	386
	387	if (low < so->addr_low)
	388	so->addr_low = low;
	389	if (high > so->addr_high)
	390	so->addr_high = high;
	391	gdb_assert (so->addr_low <= so->addr_high);
	392	found_range = 1;
	393	}
3e43a32a MS	394	so->lm_info->offsets->offsets[i]
3e43a32a MS	395	= section_bases[bases_index];
1fddbabb PA	396	bases_index++;
	397	}
	398	if (!found_range)
	399	so->addr_low = so->addr_high = 0;
	400	gdb_assert (so->addr_low <= so->addr_high);
	401	}
	402	}
	403	else if (so->lm_info->segment_bases)
	404	{
	405	struct symfile_segment_data *data;
433759f7	406
1fddbabb PA	407	data = get_symfile_segment_data (so->abfd);
	408	if (data == NULL)
	409	warning (_("\
	410	Could not relocate shared library \"%s\": no segments"), so->so_name);
	411	else
	412	{
	413	ULONGEST orig_delta;
	414	int i;
	415	int num_bases;
	416	CORE_ADDR *segment_bases;
	417
	418	num_bases = VEC_length (CORE_ADDR, so->lm_info->segment_bases);
	419	segment_bases = VEC_address (CORE_ADDR,
	420	so->lm_info->segment_bases);
	421
	422	if (!symfile_map_offsets_to_segments (so->abfd, data,
	423	so->lm_info->offsets,
	424	num_bases, segment_bases))
	425	warning (_("\
	426	Could not relocate shared library \"%s\": bad offsets"), so->so_name);
	427
	428	/* Find the range of addresses to report for this library in
	429	"info sharedlibrary". Report any consecutive segments
	430	which were relocated as a single unit. */
	431	gdb_assert (num_bases > 0);
	432	orig_delta = segment_bases[0] - data->segment_bases[0];
	433
	434	for (i = 1; i < data->num_segments; i++)
	435	{
	436	/* If we have run out of offsets, assume all
	437	remaining segments have the same offset. */
	438	if (i >= num_bases)
	439	continue;
	440
	441	/* If this segment does not have the same offset, do
	442	not include it in the library's range. */
	443	if (segment_bases[i] - data->segment_bases[i] != orig_delta)
	444	break;
	445	}
	446
	447	so->addr_low = segment_bases[0];
	448	so->addr_high = (data->segment_bases[i - 1]
	449	+ data->segment_sizes[i - 1]
	450	+ orig_delta);
	451	gdb_assert (so->addr_low <= so->addr_high);
	452
	453	free_symfile_segment_data (data);
cfa9d6d9	454	}
cfa9d6d9 DJ	455	}
	456	}
	457
	458	offset = so->lm_info->offsets->offsets[sec->the_bfd_section->index];
	459	sec->addr += offset;
	460	sec->endaddr += offset;
	461	}
	462
	463	static int
	464	solib_target_open_symbol_file_object (void *from_ttyp)
	465	{
	466	/* We can't locate the main symbol file based on the target's
	467	knowledge; the user has to specify it. */
	468	return 0;
	469	}
	470
	471	static int
	472	solib_target_in_dynsym_resolve_code (CORE_ADDR pc)
	473	{
	474	/* We don't have a range of addresses for the dynamic linker; there
	475	may not be one in the program's address space. So only report
	476	PLT entries (which may be import stubs). */
	477	return in_plt_section (pc, NULL);
	478	}
	479
8d465389	480	struct target_so_ops solib_target_so_ops;
cfa9d6d9	481
3e43a32a MS	482	/* -Wmissing-prototypes */
3e43a32a MS	483	extern initialize_file_ftype _initialize_solib_target;
cfa9d6d9 DJ	484
	485	void
	486	_initialize_solib_target (void)
	487	{
	488	solib_target_so_ops.relocate_section_addresses
	489	= solib_target_relocate_section_addresses;
	490	solib_target_so_ops.free_so = solib_target_free_so;
	491	solib_target_so_ops.clear_solib = solib_target_clear_solib;
	492	solib_target_so_ops.solib_create_inferior_hook
	493	= solib_target_solib_create_inferior_hook;
	494	solib_target_so_ops.special_symbol_handling
	495	= solib_target_special_symbol_handling;
	496	solib_target_so_ops.current_sos = solib_target_current_sos;
	497	solib_target_so_ops.open_symbol_file_object
	498	= solib_target_open_symbol_file_object;
	499	solib_target_so_ops.in_dynsym_resolve_code
	500	= solib_target_in_dynsym_resolve_code;
831a0c44	501	solib_target_so_ops.bfd_open = solib_bfd_open;
98d64339 PA	502
	503	/* Set current_target_so_ops to solib_target_so_ops if not already
	504	set. */
	505	if (current_target_so_ops == 0)
	506	current_target_so_ops = &solib_target_so_ops;
cfa9d6d9	507	}