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

/* Definitions for targets which report shared library events.

   Copyright (C) 2007-2015 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"

/* 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 = xml_find_attribute (attributes, "address")->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 = xml_find_attribute (attributes, "address")->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 = XCNEW (struct lm_info);
  const char *name = xml_find_attribute (attributes, "name")->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)
{
  struct gdb_xml_value *version = xml_find_attribute (attributes, "version");

  /* #FIXED attribute may be omitted, Expat returns NULL in such case.  */
  if (version != NULL)
    {
      const char *string = version->value;

      if (strcmp (string, "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>.  */

static 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 }
};

static 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 }
};

static 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 }
};

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

static 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 }
};

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

static 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)
{
  VEC(lm_info_p) *result = NULL;
  struct cleanup *back_to = make_cleanup (solib_target_free_library_list,
					  &result);

  if (gdb_xml_parse_quick (_("target library list"), "library-list.dtd",
			   library_list_elements, library, &result) == 0)
    {
      /* Parsed successfully, keep the result.  */
      discard_cleanups (back_to);
      return result;
    }

  do_cleanups (back_to);
  return NULL;
}
#endif

static struct so_list *
solib_target_current_sos (void)
{
  struct so_list *new_solib, *start = NULL, *last = NULL;
  char *library_document;
  struct cleanup *old_chain;
  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;

  /* solib_target_parse_libraries may throw, so we use a cleanup.  */
  old_chain = make_cleanup (xfree, library_document);

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

  /* library_document string is not needed behind this point.  */
  do_cleanups (old_chain);

  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 = XCNEW (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)
{
  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 = gdb_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[gdb_bfd_section_index
					 (sec->the_bfd_section->owner,
					  sec->the_bfd_section)];
  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);
}

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