libebl/eblopenbackend.c

/* Generate ELF backend handle.
   Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005 Red Hat, Inc.

   This program is Open Source software; you can redistribute it and/or
   modify it under the terms of the Open Software License version 1.0 as
   published by the Open Source Initiative.

   You should have received a copy of the Open Software License along
   with this program; if not, you may obtain a copy of the Open Software
   License version 1.0 from http://www.opensource.org/licenses/osl.php or
   by writing the Open Source Initiative c/o Lawrence Rosen, Esq.,
   3001 King Ranch Road, Ukiah, CA 95482.   */

#ifdef HAVE_CONFIG_H
# include <config.h>
#endif

#include <assert.h>
#include <dlfcn.h>
#include <error.h>
#include <gelf.h>
#include <stdlib.h>
#include <string.h>

#include <libeblP.h>


/* This table should contain the complete list of architectures as far
   as the ELF specification is concerned.  */
/* XXX When things are stable replace the string pointers with char
   arrays to avoid relocations.  */
static const struct
{
  const char *dsoname;
  const char *emulation;
  const char *prefix;
  int prefix_len;
  int em;
} machines[] =
{
  { "i386", "elf_i386", "i386", 4, EM_386 },
  { "ia64", "elf_ia64", "ia64", 4, EM_IA_64 },
  { "alpha", "elf_alpha", "alpha", 5, EM_ALPHA },
  { "x86_64", "elf_x86_64", "x86_64", 6, EM_X86_64 },
  { "sh", "elf_sh", "sh", 2, EM_SH },
  { "arm", "ebl_arm", "arm", 3, EM_ARM },
  { "sparc", "elf_sparcv9", "sparc", 5, EM_SPARCV9 },
  { "sparc", "elf_sparc", "sparc", 5, EM_SPARC },
  { "sparc", "elf_sparcv8plus", "sparc", 5, EM_SPARC32PLUS },

  { "m32", "elf_m32", "m32", 3, EM_M32 },
  { "m68k", "elf_m68k", "m68k", 4, EM_68K },
  { "m88k", "elf_m88k", "m88k", 4, EM_88K },
  { "i860", "elf_i860", "i860", 4, EM_860 },
  { "mips", "elf_mips", "mips", 4, EM_MIPS },
  { "s370", "ebl_s370", "s370", 4, EM_S370 },
  { "mips", "elf_mipsel", "mips", 4, EM_MIPS_RS3_LE },
  { "parisc", "elf_parisc", "parisc", 6, EM_PARISC },
  { "vpp500", "elf_vpp500", "vpp500", 5, EM_VPP500 },
  { "sparc", "elf_v8plus", "v8plus", 6, EM_SPARC32PLUS },
  { "i960", "elf_i960", "i960", 4, EM_960 },
  { "ppc", "elf_ppc", "ppc", 3, EM_PPC },
  { "ppc64", "elf_ppc64", "ppc64", 5, EM_PPC64 },
  { "s390", "ebl_s390", "s390", 4, EM_S390 },
  { "v800", "ebl_v800", "v800", 4, EM_V800 },
  { "fr20", "ebl_fr20", "fr20", 4, EM_FR20 },
  { "rh32", "ebl_rh32", "rh32", 4, EM_RH32 },
  { "rce", "ebl_rce", "rce", 3, EM_RCE },
  { "tricore", "elf_tricore", "tricore", 7, EM_TRICORE },
  { "arc", "elf_arc", "arc", 3, EM_ARC },
  { "h8", "elf_h8_300", "h8_300", 6, EM_H8_300 },
  { "h8", "elf_h8_300h", "h8_300h", 6, EM_H8_300H },
  { "h8", "elf_h8s", "h8s", 6, EM_H8S },
  { "h8", "elf_h8_500", "h8_500", 6, EM_H8_500 },
  { "mips_x", "elf_mips_x", "mips_x", 6, EM_MIPS_X },
  { "coldfire", "elf_coldfire", "coldfire", 8, EM_COLDFIRE },
  { "m68k", "elf_68hc12", "68hc12", 6, EM_68HC12 },
  { "mma", "elf_mma", "mma", 3, EM_MMA },
  { "pcp", "elf_pcp", "pcp", 3, EM_PCP },
  { "ncpu", "elf_ncpu", "ncpu", 4, EM_NCPU },
  { "ndr1", "elf_ndr1", "ndr1", 4, EM_NDR1 },
  { "starcore", "elf_starcore", "starcore", 8, EM_STARCORE },
  { "me16", "elf_me16", "em16", 4, EM_ME16 },
  { "st100", "elf_st100", "st100", 5, EM_ST100 },
  { "tinyj", "elf_tinyj", "tinyj", 5, EM_TINYJ },
  { "pdsp", "elf_pdsp", "pdsp", 4, EM_PDSP },
  { "fx66", "elf_fx66", "fx66", 4, EM_FX66 },
  { "st9plus", "elf_st9plus", "st9plus", 7, EM_ST9PLUS },
  { "st7", "elf_st7", "st7", 3, EM_ST7 },
  { "m68k", "elf_68hc16", "68hc16", 6, EM_68HC16 },
  { "m68k", "elf_68hc11", "68hc11", 6, EM_68HC11 },
  { "m68k", "elf_68hc08", "68hc08", 6, EM_68HC08 },
  { "m68k", "elf_68hc05", "68hc05", 6, EM_68HC05 },
  { "svx", "elf_svx", "svx", 3, EM_SVX },
  { "st19", "elf_st19", "st19", 4, EM_ST19 },
  { "vax", "elf_vax", "vax", 3, EM_VAX },
  { "cris", "elf_cris", "cris", 4, EM_CRIS },
  { "javelin", "elf_javelin", "javelin", 7, EM_JAVELIN },
  { "firepath", "elf_firepath", "firepath", 8, EM_FIREPATH },
  { "zsp", "elf_zsp", "zsp", 3, EM_ZSP},
  { "mmix", "elf_mmix", "mmix", 4, EM_MMIX },
  { "hunay", "elf_huany", "huany", 5, EM_HUANY },
  { "prism", "elf_prism", "prism", 5, EM_PRISM },
  { "avr", "elf_avr", "avr", 3, EM_AVR },
  { "fr30", "elf_fr30", "fr30", 4, EM_FR30 },
  { "dv10", "elf_dv10", "dv10", 4, EM_D10V },
  { "dv30", "elf_dv30", "dv30", 4, EM_D30V },
  { "v850", "elf_v850", "v850", 4, EM_V850 },
  { "m32r", "elf_m32r", "m32r", 4, EM_M32R },
  { "mn10300", "elf_mn10300", "mn10300", 7, EM_MN10300 },
  { "mn10200", "elf_mn10200", "mn10200", 7, EM_MN10200 },
  { "pj", "elf_pj", "pj", 2, EM_PJ },
  { "openrisc", "elf_openrisc", "openrisc", 8, EM_OPENRISC },
  { "arc", "elf_arc_a5", "arc_a5", 6, EM_ARC_A5 },
  { "xtensa", "elf_xtensa", "xtensa", 6, EM_XTENSA },
};
#define nmachines (sizeof (machines) / sizeof (machines[0]))


/* Default callbacks.  Mostly they just return the error value.  */
static const char *default_object_type_name (int ignore, char *buf,
					     size_t len);
static const char *default_reloc_type_name (int ignore, char *buf, size_t len);
static bool default_reloc_type_check (int ignore);
static bool default_reloc_valid_use (Elf *elf, int ignore);
static Elf_Type default_reloc_simple_type (Elf *elf, int ignore);
static bool default_gotpc_reloc_check (Elf *elf, int ignore);
static const char *default_segment_type_name (int ignore, char *buf,
					      size_t len);
static const char *default_section_type_name (int ignore, char *buf,
					      size_t len);
static const char *default_section_name (int ignore, int ignore2, char *buf,
					 size_t len);
static const char *default_machine_flag_name (Elf64_Word *ignore);
static bool default_machine_flag_check (Elf64_Word flags);
static const char *default_symbol_type_name (int ignore, char *buf,
					     size_t len);
static const char *default_symbol_binding_name (int ignore, char *buf,
						size_t len);
static const char *default_dynamic_tag_name (int64_t ignore, char *buf,
					     size_t len);
static bool default_dynamic_tag_check (int64_t ignore);
static GElf_Word default_sh_flags_combine (GElf_Word flags1, GElf_Word flags2);
static const char *default_osabi_name (int ignore, char *buf, size_t len);
static void default_destr (struct ebl *ignore);
static const char *default_core_note_type_name (uint32_t, char *buf,
						size_t len);
static const char *default_object_note_type_name (uint32_t, char *buf,
						  size_t len);
static bool default_core_note (const char *name, uint32_t type,
			       uint32_t descsz, const char *desc);
static bool default_object_note (const char *name, uint32_t type,
				 uint32_t descsz, const char *desc);
static bool default_debugscn_p (const char *name);
static bool default_copy_reloc_p (int reloc);


static void
fill_defaults (Ebl *result)
{
  result->object_type_name = default_object_type_name;
  result->reloc_type_name = default_reloc_type_name;
  result->reloc_type_check = default_reloc_type_check;
  result->reloc_valid_use = default_reloc_valid_use;
  result->reloc_simple_type = default_reloc_simple_type;
  result->gotpc_reloc_check = default_gotpc_reloc_check;
  result->segment_type_name = default_segment_type_name;
  result->section_type_name = default_section_type_name;
  result->section_name = default_section_name;
  result->machine_flag_name = default_machine_flag_name;
  result->machine_flag_check = default_machine_flag_check;
  result->symbol_type_name = default_symbol_type_name;
  result->symbol_binding_name = default_symbol_binding_name;
  result->dynamic_tag_name = default_dynamic_tag_name;
  result->dynamic_tag_check = default_dynamic_tag_check;
  result->sh_flags_combine = default_sh_flags_combine;
  result->osabi_name = default_osabi_name;
  result->core_note_type_name = default_core_note_type_name;
  result->object_note_type_name = default_object_note_type_name;
  result->core_note = default_core_note;
  result->object_note = default_object_note;
  result->debugscn_p = default_debugscn_p;
  result->copy_reloc_p = default_copy_reloc_p;
  result->destr = default_destr;
}


/* Find an appropriate backend for the file associated with ELF.  */
static Ebl *
openbackend (elf, emulation, machine)
     Elf *elf;
     const char *emulation;
     GElf_Half machine;
{
  Ebl *result;
  size_t cnt;

  /* First allocate the data structure for the result.  We do this
     here since this assures that the structure is always large
     enough.  */
  result = (Ebl *) calloc (1, sizeof (Ebl));
  if (result == NULL)
    {
      // XXX uncomment
      // __libebl_seterror (ELF_E_NOMEM);
      return NULL;
    }

  /* Fill in the default callbacks.  The initializer for the machine
     specific module can overwrite the values.  */
  fill_defaults (result);

  /* XXX Currently all we do is to look at 'e_machine' value in the
     ELF header.  With an internal mapping table from EM_* value to
     DSO name we try to load the appropriate module to handle this
     binary type.

     Multiple modules for the same machine type are possible and they
     will be tried in sequence.  The lookup process will only stop
     when a module which can handle the machine type is found or all
     available matching modules are tried.  */
  for (cnt = 0; cnt < nmachines; ++cnt)
    if ((emulation != NULL && strcmp (emulation, machines[cnt].emulation) == 0)
	|| (emulation == NULL && machines[cnt].em == machine))
      {
	/* Well, we know the emulation name now.  */
	result->emulation = machines[cnt].emulation;

#ifndef LIBEBL_SUBDIR
# define LIBEBL_SUBDIR PACKAGE
#endif
#define ORIGINDIR "$ORIGIN/../$LIB/" LIBEBL_SUBDIR "/"

	/* Give it a try.  At least the machine type matches.  First
           try to load the module.  */
	char dsoname[100];
	strcpy (stpcpy (stpcpy (dsoname, ORIGINDIR "libebl_"),
			machines[cnt].dsoname),
		".so");

	void *h = dlopen (dsoname, RTLD_LAZY);
	if (h == NULL)
	  {
	    strcpy (stpcpy (stpcpy (dsoname, "libebl_"),
			    machines[cnt].dsoname),
		    ".so");
	    h = dlopen (dsoname, RTLD_LAZY);
	  }

	  /* Try without an explicit path.  */
	if (h != NULL)
	  {
	    /* We managed to load the object.  Now see whether the
	       initialization function likes our file.  */
	    static const char version[] = MODVERSION;
	    const char *modversion;
	    ebl_bhinit_t initp;
	    char symname[machines[cnt].prefix_len + sizeof "_init"];

	    strcpy (mempcpy (symname, machines[cnt].prefix,
			     machines[cnt].prefix_len), "_init");

	    initp = (ebl_bhinit_t) dlsym (h, symname);
	    if (initp != NULL
		&& (modversion = initp (elf, machine, result, sizeof (Ebl)))
		&& strcmp (version, modversion) == 0)
	      {
		/* We found a module to handle our file.  */
		result->dlhandle = h;
		result->elf = elf;

		/* A few entries are mandatory.  */
		assert (result->name != NULL);
		assert (result->destr != NULL);

		return result;
	      }

	    /* Not the module we need.  */
	    (void) dlclose (h);
	  }

	/* We cannot find a DSO but the emulation/machine ID matches.
	   Return that information.  */
	result->dlhandle = NULL;
	result->elf = elf;
	result->name = machines[cnt].prefix;
	fill_defaults (result);

	return result;
      }

  /* Nothing matched.  We use only the default callbacks.   */
  result->dlhandle = NULL;
  result->elf = elf;
  result->emulation = "<unknown>";
  result->name = "<unknown>";
  fill_defaults (result);

  return result;
}


/* Find an appropriate backend for the file associated with ELF.  */
Ebl *
ebl_openbackend (elf)
     Elf *elf;
{
  GElf_Ehdr ehdr_mem;
  GElf_Ehdr *ehdr;

  /* Get the ELF header of the object.  */
  ehdr = gelf_getehdr (elf, &ehdr_mem);
  if (ehdr == NULL)
    {
      // XXX uncomment
      // __libebl_seterror (elf_errno ());
      return NULL;
    }

  return openbackend (elf, NULL, ehdr->e_machine);
}


/* Find backend without underlying ELF file.  */
Ebl *
ebl_openbackend_machine (machine)
     GElf_Half machine;
{
  return openbackend (NULL, NULL, machine);
}


/* Find backend with given emulation name.  */
Ebl *
ebl_openbackend_emulation (const char *emulation)
{
  return openbackend (NULL, emulation, EM_NONE);
}


/* Default callbacks.  Mostly they just return the error value.  */
static const char *
default_object_type_name (int ignore __attribute__ ((unused)),
			  char *buf __attribute__ ((unused)),
			  size_t len __attribute__ ((unused)))
{
  return NULL;
}

static const char *
default_reloc_type_name (int ignore __attribute__ ((unused)),
			 char *buf __attribute__ ((unused)),
			 size_t len __attribute__ ((unused)))
{
  return NULL;
}

static bool
default_reloc_type_check (int ignore __attribute__ ((unused)))
{
  return false;
}

static bool
default_reloc_valid_use (Elf *elf __attribute__ ((unused)),
			 int ignore __attribute__ ((unused)))
{
  return false;
}

static Elf_Type
default_reloc_simple_type (Elf *elf __attribute__ ((unused)),
			   int ignore __attribute__ ((unused)))
{
  return ELF_T_NUM;
}

static bool
default_gotpc_reloc_check (Elf *elf __attribute__ ((unused)),
			   int ignore __attribute__ ((unused)))
{
  return false;
}

static const char *
default_segment_type_name (int ignore __attribute__ ((unused)),
			   char *buf __attribute__ ((unused)),
			   size_t len __attribute__ ((unused)))
{
  return NULL;
}

static const char *
default_section_type_name (int ignore __attribute__ ((unused)),
			   char *buf __attribute__ ((unused)),
			   size_t len __attribute__ ((unused)))
{
  return NULL;
}

static const char *
default_section_name (int ignore __attribute__ ((unused)),
		      int ignore2 __attribute__ ((unused)),
		      char *buf __attribute__ ((unused)),
		      size_t len __attribute__ ((unused)))
{
  return NULL;
}

static const char *
default_machine_flag_name (Elf64_Word *ignore __attribute__ ((unused)))
{
  return NULL;
}

static bool
default_machine_flag_check (Elf64_Word flags __attribute__ ((unused)))
{
  return flags == 0;
}

static const char *
default_symbol_type_name (int ignore __attribute__ ((unused)),
			  char *buf __attribute__ ((unused)),
			  size_t len __attribute__ ((unused)))
{
  return NULL;
}

static const char *
default_symbol_binding_name (int ignore __attribute__ ((unused)),
			     char *buf __attribute__ ((unused)),
			     size_t len __attribute__ ((unused)))
{
  return NULL;
}

static const char *
default_dynamic_tag_name (int64_t ignore __attribute__ ((unused)),
			  char *buf __attribute__ ((unused)),
			  size_t len __attribute__ ((unused)))
{
  return NULL;
}

static bool
default_dynamic_tag_check (int64_t ignore __attribute__ ((unused)))
{
  return false;
}

static GElf_Word
default_sh_flags_combine (GElf_Word flags1, GElf_Word flags2)
{
  return SH_FLAGS_COMBINE (flags1, flags2);
}

static void
default_destr (struct ebl *ignore __attribute__ ((unused)))
{
}

static const char *
default_osabi_name (int ignore __attribute__ ((unused)),
		    char *buf __attribute__ ((unused)),
		    size_t len __attribute__ ((unused)))
{
  return NULL;
}

static const char *
default_core_note_type_name (uint32_t ignore __attribute__ ((unused)),
			     char *buf __attribute__ ((unused)),
			     size_t len __attribute__ ((unused)))
{
  return NULL;
}

static const char *
default_object_note_type_name (uint32_t ignore __attribute__ ((unused)),
			       char *buf __attribute__ ((unused)),
			       size_t len __attribute__ ((unused)))
{
  return NULL;
}

static bool
default_core_note (const char *name __attribute__ ((unused)),
		   uint32_t type __attribute__ ((unused)),
		   uint32_t descsz __attribute__ ((unused)),
		   const char *desc __attribute__ ((unused)))
{
  return NULL;
}

static bool
default_object_note (const char *name __attribute__ ((unused)),
		     uint32_t type __attribute__ ((unused)),
		     uint32_t descsz __attribute__ ((unused)),
		     const char *desc __attribute__ ((unused)))
{
  return NULL;
}

static bool
default_debugscn_p (const char *name)
{
  /* We know by default only about the DWARF debug sections which have
     fixed names.  */
  static const char *dwarf_scn_names[] =
    {
      /* DWARF 1 */
      ".debug",
      ".line",
      /* GNU DWARF 1 extensions */
      ".debug_srcinfo",
      ".debug_sfnames",
      /* DWARF 1.1 and DWARF 2 */
      ".debug_aranges",
      ".debug_pubnames",
      /* DWARF 2 */
      ".debug_info",
      ".debug_abbrev",
      ".debug_line",
      ".debug_frame",
      ".debug_str",
      ".debug_loc",
      ".debug_macinfo",
      /* DWARF 3 */
      ".debug_ranges",
      /* SGI/MIPS DWARF 2 extensions */
      ".debug_weaknames",
      ".debug_funcnames",
      ".debug_typenames",
      ".debug_varnames"
    };
  const size_t ndwarf_scn_names = (sizeof (dwarf_scn_names)
				   / sizeof (dwarf_scn_names[0]));
  for (size_t cnt = 0; cnt < ndwarf_scn_names; ++cnt)
    if (strcmp (name, dwarf_scn_names[cnt]) == 0)
      return true;

  return false;
}

static bool
default_copy_reloc_p (int reloc __attribute__ ((unused)))
{
  return false;
}