[deliverable/binutils-gdb.git] / gdb / osabi.c

/* OS ABI variant handling for GDB.
   Copyright 2001, 2002, 2003 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 2 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, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330,
   Boston, MA 02111-1307, USA.  */

#include "defs.h"

#include "gdb_assert.h"
#include "gdb_string.h"

#include "osabi.h"

#include "elf-bfd.h"


/* This table matches the indices assigned to enum gdb_osabi.  Keep
   them in sync.  */
static const char * const gdb_osabi_names[] =
{
  "<unknown>",

  "SVR4",
  "GNU/Hurd",
  "Solaris",
  "OSF/1",
  "GNU/Linux",
  "FreeBSD a.out",
  "FreeBSD ELF",
  "NetBSD a.out",
  "NetBSD ELF",
  "Windows CE",
  "DJGPP",
  "NetWare",
  "Irix",
  "LynxOS",
  "Interix",
  "HP/UX ELF",
  "HP/UX SOM",

  "ARM EABI v1",
  "ARM EABI v2",
  "ARM APCS",

  "<invalid>"
};

const char *
gdbarch_osabi_name (enum gdb_osabi osabi)
{
  if (osabi >= GDB_OSABI_UNKNOWN && osabi < GDB_OSABI_INVALID)
    return gdb_osabi_names[osabi];

  return gdb_osabi_names[GDB_OSABI_INVALID];
}

/* Handler for a given architecture/OS ABI pair.  There should be only
   one handler for a given OS ABI each architecture family.  */
struct gdb_osabi_handler  
{
  struct gdb_osabi_handler *next;
  const struct bfd_arch_info *arch_info;
  enum gdb_osabi osabi;
  void (*init_osabi)(struct gdbarch_info, struct gdbarch *);
};

static struct gdb_osabi_handler *gdb_osabi_handler_list;

void
gdbarch_register_osabi (enum bfd_architecture arch, unsigned long machine,
			enum gdb_osabi osabi,
                        void (*init_osabi)(struct gdbarch_info,
					   struct gdbarch *))
{
  struct gdb_osabi_handler **handler_p;
  const struct bfd_arch_info *arch_info = bfd_lookup_arch (arch, machine);

  /* Registering an OS ABI handler for "unknown" is not allowed.  */
  if (osabi == GDB_OSABI_UNKNOWN)
    {
      internal_error
	(__FILE__, __LINE__,
	 "gdbarch_register_osabi: An attempt to register a handler for "
         "OS ABI \"%s\" for architecture %s was made.  The handler will "
	 "not be registered",
	 gdbarch_osabi_name (osabi),
	 bfd_printable_arch_mach (arch, machine));
      return;
    }

  gdb_assert (arch_info);

  for (handler_p = &gdb_osabi_handler_list; *handler_p != NULL;
       handler_p = &(*handler_p)->next)
    {
      if ((*handler_p)->arch_info == arch_info
	  && (*handler_p)->osabi == osabi)
	{
	  internal_error
	    (__FILE__, __LINE__,
	     "gdbarch_register_osabi: A handler for OS ABI \"%s\" "
	     "has already been registered for architecture %s",
	     gdbarch_osabi_name (osabi),
	     arch_info->printable_name);
	  /* If user wants to continue, override previous definition.  */
	  (*handler_p)->init_osabi = init_osabi;
	  return;
	}
    }

  (*handler_p)
    = (struct gdb_osabi_handler *) xmalloc (sizeof (struct gdb_osabi_handler));
  (*handler_p)->next = NULL;
  (*handler_p)->arch_info = arch_info;
  (*handler_p)->osabi = osabi;
  (*handler_p)->init_osabi = init_osabi;
}
\f

/* Sniffer to find the OS ABI for a given file's architecture and flavour. 
   It is legal to have multiple sniffers for each arch/flavour pair, to
   disambiguate one OS's a.out from another, for example.  The first sniffer
   to return something other than GDB_OSABI_UNKNOWN wins, so a sniffer should
   be careful to claim a file only if it knows for sure what it is.  */
struct gdb_osabi_sniffer
{
  struct gdb_osabi_sniffer *next;
  enum bfd_architecture arch;   /* bfd_arch_unknown == wildcard */
  enum bfd_flavour flavour;
  enum gdb_osabi (*sniffer)(bfd *);
};

static struct gdb_osabi_sniffer *gdb_osabi_sniffer_list;

void
gdbarch_register_osabi_sniffer (enum bfd_architecture arch,
                                enum bfd_flavour flavour,
				enum gdb_osabi (*sniffer_fn)(bfd *))
{
  struct gdb_osabi_sniffer *sniffer;

  sniffer =
    (struct gdb_osabi_sniffer *) xmalloc (sizeof (struct gdb_osabi_sniffer));
  sniffer->arch = arch;
  sniffer->flavour = flavour;
  sniffer->sniffer = sniffer_fn;

  sniffer->next = gdb_osabi_sniffer_list;
  gdb_osabi_sniffer_list = sniffer;
}
\f

enum gdb_osabi
gdbarch_lookup_osabi (bfd *abfd)
{
  struct gdb_osabi_sniffer *sniffer;
  enum gdb_osabi osabi, match;
  int match_specific;

  if (abfd == NULL)
    return GDB_OSABI_UNINITIALIZED;

  match = GDB_OSABI_UNKNOWN;
  match_specific = 0;

  for (sniffer = gdb_osabi_sniffer_list; sniffer != NULL;
       sniffer = sniffer->next)
    {
      if ((sniffer->arch == bfd_arch_unknown /* wildcard */
	   || sniffer->arch == bfd_get_arch (abfd))
	  && sniffer->flavour == bfd_get_flavour (abfd))
	{
	  osabi = (*sniffer->sniffer) (abfd);
	  if (osabi < GDB_OSABI_UNKNOWN || osabi >= GDB_OSABI_INVALID)
	    {
	      internal_error
		(__FILE__, __LINE__,
		 "gdbarch_lookup_osabi: invalid OS ABI (%d) from sniffer "
		 "for architecture %s flavour %d",
		 (int) osabi,
		 bfd_printable_arch_mach (bfd_get_arch (abfd), 0),
		 (int) bfd_get_flavour (abfd));
	    }
	  else if (osabi != GDB_OSABI_UNKNOWN)
	    {
	      /* A specific sniffer always overrides a generic sniffer.
		 Croak on multiple match if the two matches are of the
		 same class.  If the user wishes to continue, we'll use
		 the first match.  */
	      if (match != GDB_OSABI_UNKNOWN)
		{
		  if ((match_specific && sniffer->arch != bfd_arch_unknown)
		   || (!match_specific && sniffer->arch == bfd_arch_unknown))
		    {
		      internal_error
		        (__FILE__, __LINE__,
		         "gdbarch_lookup_osabi: multiple %sspecific OS ABI "
			 "match for architecture %s flavour %d: first "
			 "match \"%s\", second match \"%s\"",
			 match_specific ? "" : "non-",
		         bfd_printable_arch_mach (bfd_get_arch (abfd), 0),
		         (int) bfd_get_flavour (abfd),
		         gdbarch_osabi_name (match),
		         gdbarch_osabi_name (osabi));
		    }
		  else if (sniffer->arch != bfd_arch_unknown)
		    {
		      match = osabi;
		      match_specific = 1;
		    }
		}
	      else
		{
		  match = osabi;
		  if (sniffer->arch != bfd_arch_unknown)
		    match_specific = 1;
		}
	    }
	}
    }

  return match;
}

void
gdbarch_init_osabi (struct gdbarch_info info, struct gdbarch *gdbarch)
{
  const struct bfd_arch_info *arch_info = gdbarch_bfd_arch_info (gdbarch);
  const struct bfd_arch_info *compatible;
  struct gdb_osabi_handler *handler;

  if (info.osabi == GDB_OSABI_UNKNOWN)
    {
      /* Don't complain about an unknown OSABI.  Assume the user knows
         what they are doing.  */
      return;
    }

  for (handler = gdb_osabi_handler_list; handler != NULL;
       handler = handler->next)
    {
      if (handler->osabi != info.osabi)
	continue;

      /* Check whether the machine type and architecture of the
         handler are compatible with the desired machine type and
         architecture.

	 NOTE: kettenis/20021027: There may be more than one machine
	 type that is compatible with the desired machine type.  Right
	 now we simply return the first match, which is fine for now.
	 However, we might want to do something smarter in the future.  */
      compatible = arch_info->compatible (arch_info, handler->arch_info);
      if (compatible == handler->arch_info)
	{
	  (*handler->init_osabi) (info, gdbarch);
	  return;
	}
    }

  /* We assume that if GDB_MULTI_ARCH is less than GDB_MULTI_ARCH_TM
     that an ABI variant can be supported by overriding definitions in
     the tm-file.  */
  if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
    fprintf_filtered
      (gdb_stderr,
       "A handler for the OS ABI \"%s\" is not built into this "
       "configuration of GDB.  "
       "Attempting to continue with the default %s settings",
       gdbarch_osabi_name (info.osabi),
       bfd_printable_arch_mach (arch_info->arch, arch_info->mach));
}
\f

/* Generic sniffer for ELF flavoured files.  */

void
generic_elf_osabi_sniff_abi_tag_sections (bfd *abfd, asection *sect, void *obj)
{
  enum gdb_osabi *os_ident_ptr = obj;
  const char *name;
  unsigned int sectsize;

  name = bfd_get_section_name (abfd, sect);
  sectsize = bfd_section_size (abfd, sect);

  /* .note.ABI-tag notes, used by GNU/Linux and FreeBSD.  */
  if (strcmp (name, ".note.ABI-tag") == 0 && sectsize > 0)
    {
      unsigned int name_length, data_length, note_type;
      char *note;

      /* If the section is larger than this, it's probably not what we are
	 looking for.  */
      if (sectsize > 128)
	sectsize = 128;

      note = alloca (sectsize);

      bfd_get_section_contents (abfd, sect, note,
				(file_ptr) 0, (bfd_size_type) sectsize);

      name_length = bfd_h_get_32 (abfd, note);
      data_length = bfd_h_get_32 (abfd, note + 4);
      note_type   = bfd_h_get_32 (abfd, note + 8);

      if (name_length == 4 && data_length == 16 && note_type == NT_GNU_ABI_TAG
	  && strcmp (note + 12, "GNU") == 0)
	{
	  int os_number = bfd_h_get_32 (abfd, note + 16);

	  switch (os_number)
	    {
	    case GNU_ABI_TAG_LINUX:
	      *os_ident_ptr = GDB_OSABI_LINUX;
	      break;

	    case GNU_ABI_TAG_HURD:
	      *os_ident_ptr = GDB_OSABI_HURD;
	      break;

	    case GNU_ABI_TAG_SOLARIS:
	      *os_ident_ptr = GDB_OSABI_SOLARIS;
	      break;

	    default:
	      internal_error
		(__FILE__, __LINE__,
		 "generic_elf_osabi_sniff_abi_tag_sections: unknown OS number %d",
		 os_number);
	    }
	  return;
	}
      else if (name_length == 8 && data_length == 4
	       && note_type == NT_FREEBSD_ABI_TAG
	       && strcmp (note + 12, "FreeBSD") == 0)
	{
	  /* XXX Should we check the version here?  Probably not
	     necessary yet.  */
	  *os_ident_ptr = GDB_OSABI_FREEBSD_ELF;
	}
      return;
    }

  /* .note.netbsd.ident notes, used by NetBSD.  */
  if (strcmp (name, ".note.netbsd.ident") == 0 && sectsize > 0)
    {
      unsigned int name_length, data_length, note_type;
      char *note;

      /* If the section is larger than this, it's probably not what we are
	 looking for.  */
      if (sectsize > 128) 
	sectsize = 128;

      note = alloca (sectsize);

      bfd_get_section_contents (abfd, sect, note,
				(file_ptr) 0, (bfd_size_type) sectsize);
      
      name_length = bfd_h_get_32 (abfd, note);
      data_length = bfd_h_get_32 (abfd, note + 4);
      note_type   = bfd_h_get_32 (abfd, note + 8);

      if (name_length == 7 && data_length == 4 && note_type == NT_NETBSD_IDENT
	  && strcmp (note + 12, "NetBSD") == 0)
	{
	  /* XXX Should we check the version here?  Probably not
	     necessary yet.  */
	  *os_ident_ptr = GDB_OSABI_NETBSD_ELF;
	}
      return;
    }
}

static enum gdb_osabi
generic_elf_osabi_sniffer (bfd *abfd)
{
  unsigned int elfosabi;
  enum gdb_osabi osabi = GDB_OSABI_UNKNOWN;

  elfosabi = elf_elfheader (abfd)->e_ident[EI_OSABI];

  switch (elfosabi)
    {
    case ELFOSABI_NONE:
      /* When elfosabi is ELFOSABI_NONE (0), then the ELF structures in the
         file are conforming to the base specification for that machine
	 (there are no OS-specific extensions).  In order to determine the
	 real OS in use we must look for OS notes that have been added.  */
      bfd_map_over_sections (abfd,
			     generic_elf_osabi_sniff_abi_tag_sections,
			     &osabi);
      break;

    case ELFOSABI_FREEBSD:
      osabi = GDB_OSABI_FREEBSD_ELF;
      break;

    case ELFOSABI_NETBSD:
      osabi = GDB_OSABI_NETBSD_ELF;
      break;

    case ELFOSABI_LINUX:
      osabi = GDB_OSABI_LINUX;
      break;

    case ELFOSABI_HURD:
      osabi = GDB_OSABI_HURD;
      break;

    case ELFOSABI_SOLARIS:
      osabi = GDB_OSABI_SOLARIS;
      break;

    case ELFOSABI_HPUX:
      osabi = GDB_OSABI_HPUX_ELF;
      break;
    }

  if (osabi == GDB_OSABI_UNKNOWN)
    {
      /* The FreeBSD folks have been naughty; they stored the string
         "FreeBSD" in the padding of the e_ident field of the ELF
         header to "brand" their ELF binaries in FreeBSD 3.x.  */
      if (strcmp (&elf_elfheader (abfd)->e_ident[8], "FreeBSD") == 0)
	osabi = GDB_OSABI_FREEBSD_ELF;
    }

  return osabi;
}
\f

void
_initialize_gdb_osabi (void)
{
  if (strcmp (gdb_osabi_names[GDB_OSABI_INVALID], "<invalid>") != 0)
    internal_error
      (__FILE__, __LINE__,
       "_initialize_gdb_osabi: gdb_osabi_names[] is inconsistent");

  /* Register a generic sniffer for ELF flavoured files.  */
  gdbarch_register_osabi_sniffer (bfd_arch_unknown,
				  bfd_target_elf_flavour,
				  generic_elf_osabi_sniffer);
}
Commit	Line	Data
70f80edf	1	/* OS ABI variant handling for GDB.
4be87837	2	Copyright 2001, 2002, 2003 Free Software Foundation, Inc.
70f80edf JT	3
	4	This file is part of GDB.
	5
	6	This program is free software; you can redistribute it and/or modify
	7	it under the terms of the GNU General Public License as published by
	8	the Free Software Foundation; either version 2 of the License, or
	9	(at your option) any later version.
	10
	11	This program is distributed in the hope that it will be useful,
	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	GNU General Public License for more details.
	15
	16	You should have received a copy of the GNU General Public License
	17	along with this program; if not, write to the Free Software
	18	Foundation, Inc., 59 Temple Place - Suite 330,
	19	Boston, MA 02111-1307, USA. */
	20
	21	#include "defs.h"
05816f70 MK	22
05816f70 MK	23	#include "gdb_assert.h"
309367d4	24	#include "gdb_string.h"
05816f70	25
70f80edf JT	26	#include "osabi.h"
	27
	28	#include "elf-bfd.h"
	29
	30
	31	/* This table matches the indices assigned to enum gdb_osabi. Keep
	32	them in sync. */
	33	static const char * const gdb_osabi_names[] =
	34	{
	35	"<unknown>",
	36
	37	"SVR4",
	38	"GNU/Hurd",
	39	"Solaris",
	40	"OSF/1",
	41	"GNU/Linux",
	42	"FreeBSD a.out",
	43	"FreeBSD ELF",
	44	"NetBSD a.out",
	45	"NetBSD ELF",
	46	"Windows CE",
1029b7fa MK	47	"DJGPP",
1029b7fa MK	48	"NetWare",
b96d0a4e	49	"Irix",
daa66587	50	"LynxOS",
e64f66d1	51	"Interix",
a09a320d JB	52	"HP/UX ELF",
a09a320d JB	53	"HP/UX SOM",
70f80edf JT	54
	55	"ARM EABI v1",
	56	"ARM EABI v2",
	57	"ARM APCS",
	58
	59	"<invalid>"
	60	};
	61
	62	const char *
	63	gdbarch_osabi_name (enum gdb_osabi osabi)
	64	{
	65	if (osabi >= GDB_OSABI_UNKNOWN && osabi < GDB_OSABI_INVALID)
	66	return gdb_osabi_names[osabi];
	67
	68	return gdb_osabi_names[GDB_OSABI_INVALID];
	69	}
	70
	71	/* Handler for a given architecture/OS ABI pair. There should be only
	72	one handler for a given OS ABI each architecture family. */
	73	struct gdb_osabi_handler
	74	{
	75	struct gdb_osabi_handler *next;
05816f70	76	const struct bfd_arch_info *arch_info;
70f80edf JT	77	enum gdb_osabi osabi;
	78	void (init_osabi)(struct gdbarch_info, struct gdbarch );
	79	};
	80
	81	static struct gdb_osabi_handler *gdb_osabi_handler_list;
	82
	83	void
05816f70 MK	84	gdbarch_register_osabi (enum bfd_architecture arch, unsigned long machine,
05816f70 MK	85	enum gdb_osabi osabi,
70f80edf JT	86	void (*init_osabi)(struct gdbarch_info,
	87	struct gdbarch *))
	88	{
	89	struct gdb_osabi_handler **handler_p;
05816f70	90	const struct bfd_arch_info *arch_info = bfd_lookup_arch (arch, machine);
70f80edf JT	91
	92	/* Registering an OS ABI handler for "unknown" is not allowed. */
	93	if (osabi == GDB_OSABI_UNKNOWN)
	94	{
	95	internal_error
	96	(__FILE__, __LINE__,
	97	"gdbarch_register_osabi: An attempt to register a handler for "
	98	"OS ABI \"%s\" for architecture %s was made. The handler will "
	99	"not be registered",
	100	gdbarch_osabi_name (osabi),
05816f70	101	bfd_printable_arch_mach (arch, machine));
70f80edf JT	102	return;
	103	}
	104
05816f70 MK	105	gdb_assert (arch_info);
05816f70 MK	106
70f80edf JT	107	for (handler_p = &gdb_osabi_handler_list; *handler_p != NULL;
	108	handler_p = &(*handler_p)->next)
	109	{
05816f70	110	if ((*handler_p)->arch_info == arch_info
70f80edf JT	111	&& (*handler_p)->osabi == osabi)
	112	{
	113	internal_error
	114	(__FILE__, __LINE__,
	115	"gdbarch_register_osabi: A handler for OS ABI \"%s\" "
	116	"has already been registered for architecture %s",
	117	gdbarch_osabi_name (osabi),
05816f70	118	arch_info->printable_name);
70f80edf JT	119	/* If user wants to continue, override previous definition. */
	120	(*handler_p)->init_osabi = init_osabi;
	121	return;
	122	}
	123	}
	124
	125	(*handler_p)
	126	= (struct gdb_osabi_handler *) xmalloc (sizeof (struct gdb_osabi_handler));
	127	(*handler_p)->next = NULL;
05816f70	128	(*handler_p)->arch_info = arch_info;
70f80edf JT	129	(*handler_p)->osabi = osabi;
	130	(*handler_p)->init_osabi = init_osabi;
	131	}
	132	\f
	133
	134	/* Sniffer to find the OS ABI for a given file's architecture and flavour.
	135	It is legal to have multiple sniffers for each arch/flavour pair, to
	136	disambiguate one OS's a.out from another, for example. The first sniffer
	137	to return something other than GDB_OSABI_UNKNOWN wins, so a sniffer should
	138	be careful to claim a file only if it knows for sure what it is. */
	139	struct gdb_osabi_sniffer
	140	{
	141	struct gdb_osabi_sniffer *next;
	142	enum bfd_architecture arch; /* bfd_arch_unknown == wildcard */
	143	enum bfd_flavour flavour;
	144	enum gdb_osabi (sniffer)(bfd );
	145	};
	146
	147	static struct gdb_osabi_sniffer *gdb_osabi_sniffer_list;
	148
	149	void
	150	gdbarch_register_osabi_sniffer (enum bfd_architecture arch,
	151	enum bfd_flavour flavour,
	152	enum gdb_osabi (sniffer_fn)(bfd ))
	153	{
	154	struct gdb_osabi_sniffer *sniffer;
	155
	156	sniffer =
	157	(struct gdb_osabi_sniffer *) xmalloc (sizeof (struct gdb_osabi_sniffer));
	158	sniffer->arch = arch;
	159	sniffer->flavour = flavour;
	160	sniffer->sniffer = sniffer_fn;
	161
	162	sniffer->next = gdb_osabi_sniffer_list;
	163	gdb_osabi_sniffer_list = sniffer;
	164	}
	165	\f
	166
	167	enum gdb_osabi
	168	gdbarch_lookup_osabi (bfd *abfd)
	169	{
	170	struct gdb_osabi_sniffer *sniffer;
	171	enum gdb_osabi osabi, match;
	172	int match_specific;
	173
4be87837 DJ	174	if (abfd == NULL)
	175	return GDB_OSABI_UNINITIALIZED;
	176
70f80edf JT	177	match = GDB_OSABI_UNKNOWN;
	178	match_specific = 0;
	179
	180	for (sniffer = gdb_osabi_sniffer_list; sniffer != NULL;
	181	sniffer = sniffer->next)
	182	{
	183	if ((sniffer->arch == bfd_arch_unknown /* wildcard */
	184	\|\| sniffer->arch == bfd_get_arch (abfd))
	185	&& sniffer->flavour == bfd_get_flavour (abfd))
	186	{
	187	osabi = (*sniffer->sniffer) (abfd);
	188	if (osabi < GDB_OSABI_UNKNOWN \|\| osabi >= GDB_OSABI_INVALID)
	189	{
	190	internal_error
	191	(__FILE__, __LINE__,
	192	"gdbarch_lookup_osabi: invalid OS ABI (%d) from sniffer "
	193	"for architecture %s flavour %d",
	194	(int) osabi,
	195	bfd_printable_arch_mach (bfd_get_arch (abfd), 0),
	196	(int) bfd_get_flavour (abfd));
	197	}
	198	else if (osabi != GDB_OSABI_UNKNOWN)
	199	{
	200	/* A specific sniffer always overrides a generic sniffer.
	201	Croak on multiple match if the two matches are of the
	202	same class. If the user wishes to continue, we'll use
	203	the first match. */
	204	if (match != GDB_OSABI_UNKNOWN)
	205	{
	206	if ((match_specific && sniffer->arch != bfd_arch_unknown)
	207	\|\| (!match_specific && sniffer->arch == bfd_arch_unknown))
	208	{
	209	internal_error
	210	(__FILE__, __LINE__,
	211	"gdbarch_lookup_osabi: multiple %sspecific OS ABI "
	212	"match for architecture %s flavour %d: first "
	213	"match \"%s\", second match \"%s\"",
	214	match_specific ? "" : "non-",
	215	bfd_printable_arch_mach (bfd_get_arch (abfd), 0),
	216	(int) bfd_get_flavour (abfd),
	217	gdbarch_osabi_name (match),
	218	gdbarch_osabi_name (osabi));
	219	}
	220	else if (sniffer->arch != bfd_arch_unknown)
	221	{
	222	match = osabi;
	223	match_specific = 1;
	224	}
	225	}
	226	else
	227	{
	228	match = osabi;
	229	if (sniffer->arch != bfd_arch_unknown)
	230	match_specific = 1;
	231	}
	232	}
	233	}
	234	}
	235
	236	return match;
	237	}
	238
	239	void
4be87837	240	gdbarch_init_osabi (struct gdbarch_info info, struct gdbarch *gdbarch)
70f80edf	241	{
70f80edf	242	const struct bfd_arch_info *arch_info = gdbarch_bfd_arch_info (gdbarch);
05816f70 MK	243	const struct bfd_arch_info *compatible;
05816f70 MK	244	struct gdb_osabi_handler *handler;
70f80edf	245
4be87837	246	if (info.osabi == GDB_OSABI_UNKNOWN)
70f80edf	247	{
01fc4e33 AC	248	/* Don't complain about an unknown OSABI. Assume the user knows
01fc4e33 AC	249	what they are doing. */
70f80edf JT	250	return;
	251	}
	252
	253	for (handler = gdb_osabi_handler_list; handler != NULL;
	254	handler = handler->next)
	255	{
4be87837	256	if (handler->osabi != info.osabi)
05816f70 MK	257	continue;
	258
	259	/* Check whether the machine type and architecture of the
	260	handler are compatible with the desired machine type and
	261	architecture.
	262
	263	NOTE: kettenis/20021027: There may be more than one machine
	264	type that is compatible with the desired machine type. Right
	265	now we simply return the first match, which is fine for now.
	266	However, we might want to do something smarter in the future. */
	267	compatible = arch_info->compatible (arch_info, handler->arch_info);
	268	if (compatible == handler->arch_info)
70f80edf JT	269	{
	270	(*handler->init_osabi) (info, gdbarch);
	271	return;
	272	}
	273	}
	274
	275	/* We assume that if GDB_MULTI_ARCH is less than GDB_MULTI_ARCH_TM
	276	that an ABI variant can be supported by overriding definitions in
	277	the tm-file. */
	278	if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
	279	fprintf_filtered
	280	(gdb_stderr,
	281	"A handler for the OS ABI \"%s\" is not built into this "
	282	"configuration of GDB. "
	283	"Attempting to continue with the default %s settings",
4be87837	284	gdbarch_osabi_name (info.osabi),
70f80edf JT	285	bfd_printable_arch_mach (arch_info->arch, arch_info->mach));
	286	}
	287	\f
	288
	289	/* Generic sniffer for ELF flavoured files. */
	290
	291	void
	292	generic_elf_osabi_sniff_abi_tag_sections (bfd abfd, asection sect, void *obj)
	293	{
	294	enum gdb_osabi *os_ident_ptr = obj;
	295	const char *name;
	296	unsigned int sectsize;
	297
	298	name = bfd_get_section_name (abfd, sect);
	299	sectsize = bfd_section_size (abfd, sect);
	300
	301	/* .note.ABI-tag notes, used by GNU/Linux and FreeBSD. */
	302	if (strcmp (name, ".note.ABI-tag") == 0 && sectsize > 0)
	303	{
	304	unsigned int name_length, data_length, note_type;
	305	char *note;
	306
	307	/* If the section is larger than this, it's probably not what we are
	308	looking for. */
	309	if (sectsize > 128)
	310	sectsize = 128;
	311
	312	note = alloca (sectsize);
	313
	314	bfd_get_section_contents (abfd, sect, note,
	315	(file_ptr) 0, (bfd_size_type) sectsize);
	316
	317	name_length = bfd_h_get_32 (abfd, note);
	318	data_length = bfd_h_get_32 (abfd, note + 4);
	319	note_type = bfd_h_get_32 (abfd, note + 8);
	320
	321	if (name_length == 4 && data_length == 16 && note_type == NT_GNU_ABI_TAG
	322	&& strcmp (note + 12, "GNU") == 0)
	323	{
	324	int os_number = bfd_h_get_32 (abfd, note + 16);
	325
	326	switch (os_number)
	327	{
	328	case GNU_ABI_TAG_LINUX:
	329	*os_ident_ptr = GDB_OSABI_LINUX;
	330	break;
	331
	332	case GNU_ABI_TAG_HURD:
	333	*os_ident_ptr = GDB_OSABI_HURD;
	334	break;
	335
	336	case GNU_ABI_TAG_SOLARIS:
	337	*os_ident_ptr = GDB_OSABI_SOLARIS;
	338	break;
	339
	340	default:
	341	internal_error
	342	(__FILE__, __LINE__,
	343	"generic_elf_osabi_sniff_abi_tag_sections: unknown OS number %d",
	344	os_number);
	345	}
	346	return;
	347	}
	348	else if (name_length == 8 && data_length == 4
349	&& note_type == NT_FREEBSD_ABI_TAG
350	&& strcmp (note + 12, "FreeBSD") == 0)
351	{
352	/* XXX Should we check the version here? Probably not
353	necessary yet. */
354	*os_ident_ptr = GDB_OSABI_FREEBSD_ELF;
355	}
356	return;
357	}
358
359	/* .note.netbsd.ident notes, used by NetBSD. */
360	if (strcmp (name, ".note.netbsd.ident") == 0 && sectsize > 0)
361	{
362	unsigned int name_length, data_length, note_type;
363	char *note;
364
365	/* If the section is larger than this, it's probably not what we are
366	looking for. */
367	if (sectsize > 128)
368	sectsize = 128;
369
370	note = alloca (sectsize);
371
372	bfd_get_section_contents (abfd, sect, note,
373	(file_ptr) 0, (bfd_size_type) sectsize);
374
375	name_length = bfd_h_get_32 (abfd, note);
376	data_length = bfd_h_get_32 (abfd, note + 4);
377	note_type = bfd_h_get_32 (abfd, note + 8);
378
379	if (name_length == 7 && data_length == 4 && note_type == NT_NETBSD_IDENT
380	&& strcmp (note + 12, "NetBSD") == 0)
381	{
382	/* XXX Should we check the version here? Probably not
383	necessary yet. */
384	*os_ident_ptr = GDB_OSABI_NETBSD_ELF;
385	}
386	return;
387	}
388	}
389
390	static enum gdb_osabi
391	generic_elf_osabi_sniffer (bfd *abfd)
392	{
393	unsigned int elfosabi;
394	enum gdb_osabi osabi = GDB_OSABI_UNKNOWN;
395
396	elfosabi = elf_elfheader (abfd)->e_ident[EI_OSABI];
397
398	switch (elfosabi)
399	{
400	case ELFOSABI_NONE:
401	/* When elfosabi is ELFOSABI_NONE (0), then the ELF structures in the
402	file are conforming to the base specification for that machine
403	(there are no OS-specific extensions). In order to determine the
404	real OS in use we must look for OS notes that have been added. */
405	bfd_map_over_sections (abfd,
406	generic_elf_osabi_sniff_abi_tag_sections,
407	&osabi);
408	break;
409
410	case ELFOSABI_FREEBSD:
411	osabi = GDB_OSABI_FREEBSD_ELF;
412	break;
413
414	case ELFOSABI_NETBSD:
415	osabi = GDB_OSABI_NETBSD_ELF;
416	break;
417
418	case ELFOSABI_LINUX:
419	osabi = GDB_OSABI_LINUX;
420	break;
421
422	case ELFOSABI_HURD:
423	osabi = GDB_OSABI_HURD;
424	break;
425
426	case ELFOSABI_SOLARIS:
427	osabi = GDB_OSABI_SOLARIS;
428	break;
a09a320d JB	429
	430	case ELFOSABI_HPUX:
	431	osabi = GDB_OSABI_HPUX_ELF;
	432	break;
70f80edf JT	433	}
70f80edf JT	434
bb21884d MK	435	if (osabi == GDB_OSABI_UNKNOWN)
	436	{
	437	/* The FreeBSD folks have been naughty; they stored the string
	438	"FreeBSD" in the padding of the e_ident field of the ELF
	439	header to "brand" their ELF binaries in FreeBSD 3.x. */
	440	if (strcmp (&elf_elfheader (abfd)->e_ident[8], "FreeBSD") == 0)
	441	osabi = GDB_OSABI_FREEBSD_ELF;
	442	}
	443
70f80edf JT	444	return osabi;
	445	}
	446	\f
	447
	448	void
	449	_initialize_gdb_osabi (void)
	450	{
	451	if (strcmp (gdb_osabi_names[GDB_OSABI_INVALID], "<invalid>") != 0)
	452	internal_error
	453	(__FILE__, __LINE__,
	454	"_initialize_gdb_osabi: gdb_osabi_names[] is inconsistent");
	455
	456	/* Register a generic sniffer for ELF flavoured files. */
	457	gdbarch_register_osabi_sniffer (bfd_arch_unknown,
	458	bfd_target_elf_flavour,
	459	generic_elf_osabi_sniffer);
	460	}