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

/* OS ABI variant handling for GDB.
   Copyright 2001, 2002 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;

  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,
                    enum gdb_osabi osabi)
{
  const struct bfd_arch_info *arch_info = gdbarch_bfd_arch_info (gdbarch);
  const struct bfd_arch_info *compatible;
  struct gdb_osabi_handler *handler;

  if (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 != 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 (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 JT	1	/* OS ABI variant handling for GDB.
	2	Copyright 2001, 2002 Free Software Foundation, Inc.
	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
	174	match = GDB_OSABI_UNKNOWN;
	175	match_specific = 0;
	176
	177	for (sniffer = gdb_osabi_sniffer_list; sniffer != NULL;
	178	sniffer = sniffer->next)
	179	{
	180	if ((sniffer->arch == bfd_arch_unknown /* wildcard */
	181	\|\| sniffer->arch == bfd_get_arch (abfd))
	182	&& sniffer->flavour == bfd_get_flavour (abfd))
	183	{
	184	osabi = (*sniffer->sniffer) (abfd);
	185	if (osabi < GDB_OSABI_UNKNOWN \|\| osabi >= GDB_OSABI_INVALID)
	186	{
	187	internal_error
	188	(__FILE__, __LINE__,
	189	"gdbarch_lookup_osabi: invalid OS ABI (%d) from sniffer "
	190	"for architecture %s flavour %d",
	191	(int) osabi,
	192	bfd_printable_arch_mach (bfd_get_arch (abfd), 0),
193	(int) bfd_get_flavour (abfd));
194	}
195	else if (osabi != GDB_OSABI_UNKNOWN)
196	{
197	/* A specific sniffer always overrides a generic sniffer.
198	Croak on multiple match if the two matches are of the
199	same class. If the user wishes to continue, we'll use
200	the first match. */
201	if (match != GDB_OSABI_UNKNOWN)
202	{
203	if ((match_specific && sniffer->arch != bfd_arch_unknown)
204	\|\| (!match_specific && sniffer->arch == bfd_arch_unknown))
205	{
206	internal_error
207	(__FILE__, __LINE__,
208	"gdbarch_lookup_osabi: multiple %sspecific OS ABI "
209	"match for architecture %s flavour %d: first "
210	"match \"%s\", second match \"%s\"",
211	match_specific ? "" : "non-",
212	bfd_printable_arch_mach (bfd_get_arch (abfd), 0),
213	(int) bfd_get_flavour (abfd),
214	gdbarch_osabi_name (match),
215	gdbarch_osabi_name (osabi));
216	}
217	else if (sniffer->arch != bfd_arch_unknown)
218	{
219	match = osabi;
220	match_specific = 1;
221	}
222	}
223	else
224	{
225	match = osabi;
226	if (sniffer->arch != bfd_arch_unknown)
227	match_specific = 1;
228	}
229	}
230	}
231	}
232
233	return match;
234	}
235
236	void
237	gdbarch_init_osabi (struct gdbarch_info info, struct gdbarch *gdbarch,
238	enum gdb_osabi osabi)
239	{
70f80edf	240	const struct bfd_arch_info *arch_info = gdbarch_bfd_arch_info (gdbarch);
05816f70 MK	241	const struct bfd_arch_info *compatible;
05816f70 MK	242	struct gdb_osabi_handler *handler;
70f80edf JT	243
	244	if (osabi == GDB_OSABI_UNKNOWN)
	245	{
01fc4e33 AC	246	/* Don't complain about an unknown OSABI. Assume the user knows
01fc4e33 AC	247	what they are doing. */
70f80edf JT	248	return;
	249	}
	250
	251	for (handler = gdb_osabi_handler_list; handler != NULL;
	252	handler = handler->next)
	253	{
05816f70 MK	254	if (handler->osabi != osabi)
	255	continue;
	256
	257	/* Check whether the machine type and architecture of the
	258	handler are compatible with the desired machine type and
	259	architecture.
	260
	261	NOTE: kettenis/20021027: There may be more than one machine
	262	type that is compatible with the desired machine type. Right
	263	now we simply return the first match, which is fine for now.
	264	However, we might want to do something smarter in the future. */
	265	compatible = arch_info->compatible (arch_info, handler->arch_info);
	266	if (compatible == handler->arch_info)
70f80edf JT	267	{
	268	(*handler->init_osabi) (info, gdbarch);
	269	return;
	270	}
	271	}
	272
	273	/* We assume that if GDB_MULTI_ARCH is less than GDB_MULTI_ARCH_TM
	274	that an ABI variant can be supported by overriding definitions in
	275	the tm-file. */
	276	if (GDB_MULTI_ARCH > GDB_MULTI_ARCH_PARTIAL)
	277	fprintf_filtered
	278	(gdb_stderr,
	279	"A handler for the OS ABI \"%s\" is not built into this "
	280	"configuration of GDB. "
	281	"Attempting to continue with the default %s settings",
	282	gdbarch_osabi_name (osabi),
	283	bfd_printable_arch_mach (arch_info->arch, arch_info->mach));
	284	}
	285	\f
	286
	287	/* Generic sniffer for ELF flavoured files. */
	288
	289	void
	290	generic_elf_osabi_sniff_abi_tag_sections (bfd abfd, asection sect, void *obj)
	291	{
	292	enum gdb_osabi *os_ident_ptr = obj;
	293	const char *name;
	294	unsigned int sectsize;
	295
	296	name = bfd_get_section_name (abfd, sect);
	297	sectsize = bfd_section_size (abfd, sect);
	298
	299	/* .note.ABI-tag notes, used by GNU/Linux and FreeBSD. */
	300	if (strcmp (name, ".note.ABI-tag") == 0 && sectsize > 0)
	301	{
	302	unsigned int name_length, data_length, note_type;
	303	char *note;
	304
	305	/* If the section is larger than this, it's probably not what we are
	306	looking for. */
	307	if (sectsize > 128)
	308	sectsize = 128;
	309
	310	note = alloca (sectsize);
	311
	312	bfd_get_section_contents (abfd, sect, note,
	313	(file_ptr) 0, (bfd_size_type) sectsize);
	314
	315	name_length = bfd_h_get_32 (abfd, note);
	316	data_length = bfd_h_get_32 (abfd, note + 4);
	317	note_type = bfd_h_get_32 (abfd, note + 8);
	318
	319	if (name_length == 4 && data_length == 16 && note_type == NT_GNU_ABI_TAG
	320	&& strcmp (note + 12, "GNU") == 0)
	321	{
	322	int os_number = bfd_h_get_32 (abfd, note + 16);
	323
	324	switch (os_number)
	325	{
	326	case GNU_ABI_TAG_LINUX:
	327	*os_ident_ptr = GDB_OSABI_LINUX;
	328	break;
	329
	330	case GNU_ABI_TAG_HURD:
331	*os_ident_ptr = GDB_OSABI_HURD;
332	break;
333
334	case GNU_ABI_TAG_SOLARIS:
335	*os_ident_ptr = GDB_OSABI_SOLARIS;
336	break;
337
338	default:
339	internal_error
340	(__FILE__, __LINE__,
341	"generic_elf_osabi_sniff_abi_tag_sections: unknown OS number %d",
342	os_number);
343	}
344	return;
345	}
346	else if (name_length == 8 && data_length == 4
347	&& note_type == NT_FREEBSD_ABI_TAG
348	&& strcmp (note + 12, "FreeBSD") == 0)
349	{
350	/* XXX Should we check the version here? Probably not
351	necessary yet. */
352	*os_ident_ptr = GDB_OSABI_FREEBSD_ELF;
353	}
354	return;
355	}
356
357	/* .note.netbsd.ident notes, used by NetBSD. */
358	if (strcmp (name, ".note.netbsd.ident") == 0 && sectsize > 0)
359	{
360	unsigned int name_length, data_length, note_type;
361	char *note;
362
363	/* If the section is larger than this, it's probably not what we are
364	looking for. */
365	if (sectsize > 128)
366	sectsize = 128;
367
368	note = alloca (sectsize);
369
370	bfd_get_section_contents (abfd, sect, note,
371	(file_ptr) 0, (bfd_size_type) sectsize);
372
373	name_length = bfd_h_get_32 (abfd, note);
374	data_length = bfd_h_get_32 (abfd, note + 4);
375	note_type = bfd_h_get_32 (abfd, note + 8);
376
377	if (name_length == 7 && data_length == 4 && note_type == NT_NETBSD_IDENT
378	&& strcmp (note + 12, "NetBSD") == 0)
379	{
380	/* XXX Should we check the version here? Probably not
381	necessary yet. */
382	*os_ident_ptr = GDB_OSABI_NETBSD_ELF;
383	}
384	return;
385	}
386	}
387
388	static enum gdb_osabi
389	generic_elf_osabi_sniffer (bfd *abfd)
390	{
391	unsigned int elfosabi;
392	enum gdb_osabi osabi = GDB_OSABI_UNKNOWN;
393
394	elfosabi = elf_elfheader (abfd)->e_ident[EI_OSABI];
395
396	switch (elfosabi)
397	{
398	case ELFOSABI_NONE:
399	/* When elfosabi is ELFOSABI_NONE (0), then the ELF structures in the
400	file are conforming to the base specification for that machine
401	(there are no OS-specific extensions). In order to determine the
402	real OS in use we must look for OS notes that have been added. */
403	bfd_map_over_sections (abfd,
404	generic_elf_osabi_sniff_abi_tag_sections,
405	&osabi);
406	break;
407
408	case ELFOSABI_FREEBSD:
409	osabi = GDB_OSABI_FREEBSD_ELF;
410	break;
411
412	case ELFOSABI_NETBSD:
413	osabi = GDB_OSABI_NETBSD_ELF;
414	break;
415
416	case ELFOSABI_LINUX:
417	osabi = GDB_OSABI_LINUX;
418	break;
419
420	case ELFOSABI_HURD:
421	osabi = GDB_OSABI_HURD;
422	break;
423
424	case ELFOSABI_SOLARIS:
425	osabi = GDB_OSABI_SOLARIS;
426	break;
a09a320d JB	427
	428	case ELFOSABI_HPUX:
	429	osabi = GDB_OSABI_HPUX_ELF;
	430	break;
70f80edf JT	431	}
70f80edf JT	432
bb21884d MK	433	if (osabi == GDB_OSABI_UNKNOWN)
	434	{
	435	/* The FreeBSD folks have been naughty; they stored the string
	436	"FreeBSD" in the padding of the e_ident field of the ELF
	437	header to "brand" their ELF binaries in FreeBSD 3.x. */
	438	if (strcmp (&elf_elfheader (abfd)->e_ident[8], "FreeBSD") == 0)
	439	osabi = GDB_OSABI_FREEBSD_ELF;
	440	}
	441
70f80edf JT	442	return osabi;
	443	}
	444	\f
	445
	446	void
	447	_initialize_gdb_osabi (void)
	448	{
	449	if (strcmp (gdb_osabi_names[GDB_OSABI_INVALID], "<invalid>") != 0)
	450	internal_error
	451	(__FILE__, __LINE__,
	452	"_initialize_gdb_osabi: gdb_osabi_names[] is inconsistent");
	453
	454	/* Register a generic sniffer for ELF flavoured files. */
	455	gdbarch_register_osabi_sniffer (bfd_arch_unknown,
	456	bfd_target_elf_flavour,
	457	generic_elf_osabi_sniffer);
	458	}