vaseboot/VasEBoot-core/kern/ia64/dl.c

/* dl.c - arch-dependent part of loadable module support */
/*
 *  VAS_EBOOT  --  GRand Unified Bootloader
 *  Copyright (C) 2002,2004,2005,2007,2009  Free Software Foundation, Inc.
 *
 *  VAS_EBOOT 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.
 *
 *  VAS_EBOOT 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 VAS_EBOOT.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <VasEBoot/dl.h>
#include <VasEBoot/elf.h>
#include <VasEBoot/misc.h>
#include <VasEBoot/err.h>
#include <VasEBoot/mm.h>
#include <VasEBoot/i18n.h>
#include <VasEBoot/ia64/reloc.h>

#define MASK19 ((1 << 19) - 1)
#define MASK20 ((1 << 20) - 1)

/* Check if EHDR is a valid ELF header.  */
VasEBoot_err_t
VasEBoot_arch_dl_check_header (void *ehdr)
{
  Elf_Ehdr *e = ehdr;

  /* Check the magic numbers.  */
  if (e->e_ident[EI_CLASS] != ELFCLASS64
      || e->e_ident[EI_DATA] != ELFDATA2LSB
      || e->e_machine != EM_IA_64)
    return VasEBoot_error (VAS_EBOOT_ERR_BAD_OS, N_("invalid arch-dependent ELF magic"));

  return VAS_EBOOT_ERR_NONE;
}

#pragma GCC diagnostic ignored "-Wcast-align"

/* Relocate symbols.  */
VasEBoot_err_t
VasEBoot_arch_dl_relocate_symbols (VasEBoot_dl_t mod, void *ehdr,
			       Elf_Shdr *s, VasEBoot_dl_segment_t seg)
{
  Elf_Rela *rel, *max;

  for (rel = (Elf_Rela *) ((char *) ehdr + s->sh_offset),
	 max = (Elf_Rela *) ((char *) rel + s->sh_size);
       rel < max;
       rel = (Elf_Rela *) ((char *) rel + s->sh_entsize))
    {
      VasEBoot_addr_t addr;
      Elf_Sym *sym;
      VasEBoot_uint64_t value;

      if (seg->size < (rel->r_offset & ~3))
	return VasEBoot_error (VAS_EBOOT_ERR_BAD_MODULE,
			   "reloc offset is out of the segment");

      addr = (VasEBoot_addr_t) seg->addr + rel->r_offset;
      sym = (Elf_Sym *) ((char *) mod->symtab
			 + mod->symsize * ELF_R_SYM (rel->r_info));

      /* On the PPC the value does not have an explicit
	 addend, add it.  */
      value = sym->st_value + rel->r_addend;

      switch (ELF_R_TYPE (rel->r_info))
	{
	case R_IA64_PCREL21B:
	  {
	    VasEBoot_int64_t noff;
	    if (ELF_ST_TYPE (sym->st_info) == STT_FUNC)
	      {
		struct VasEBoot_ia64_trampoline *tr = mod->trampptr;
		VasEBoot_ia64_make_trampoline (tr, value);
		noff = ((char *) tr - (char *) (addr & ~3)) >> 4;
		mod->trampptr = tr + 1;
	      }
	    else
	      noff = ((char *) value - (char *) (addr & ~3)) >> 4;

	    if ((noff & ~MASK19) && ((-noff) & ~MASK19))
	      return VasEBoot_error (VAS_EBOOT_ERR_BAD_MODULE,
				 "jump offset too big (%lx)", noff);
	    VasEBoot_ia64_add_value_to_slot_20b (addr, noff);
	  }
	  break;
	case R_IA64_SEGREL64LSB:
	  *(VasEBoot_uint64_t *) addr += value - (VasEBoot_addr_t) seg->addr;
	  break;
	case R_IA64_FPTR64LSB:
	case R_IA64_DIR64LSB:
	  *(VasEBoot_uint64_t *) addr += value;
	  break;
	case R_IA64_PCREL64LSB:
	  *(VasEBoot_uint64_t *) addr += value - addr;
	  break;
	case R_IA64_GPREL64I:
	  VasEBoot_ia64_set_immu64 (addr, value - (VasEBoot_addr_t) mod->base);
	  break;
	case R_IA64_GPREL22:
	  if ((value - (VasEBoot_addr_t) mod->base) & ~MASK20)
	    return VasEBoot_error (VAS_EBOOT_ERR_BAD_MODULE,
			       "gprel offset too big (%lx)",
			       value - (VasEBoot_addr_t) mod->base);
	  VasEBoot_ia64_add_value_to_slot_21 (addr, value - (VasEBoot_addr_t) mod->base);
	  break;

	case R_IA64_LTOFF22X:
	case R_IA64_LTOFF22:
	  if (ELF_ST_TYPE (sym->st_info) == STT_FUNC)
	    value = *(VasEBoot_uint64_t *) sym->st_value + rel->r_addend;
	  /* Fallthrough.  */
	case R_IA64_LTOFF_FPTR22:
	  {
	    VasEBoot_uint64_t *gpptr = mod->gotptr;
	    *gpptr = value;
	    if (((VasEBoot_addr_t) gpptr - (VasEBoot_addr_t) mod->base) & ~MASK20)
	      return VasEBoot_error (VAS_EBOOT_ERR_BAD_MODULE,
				 "gprel offset too big (%lx)",
				 (VasEBoot_addr_t) gpptr - (VasEBoot_addr_t) mod->base);
	    VasEBoot_ia64_add_value_to_slot_21 (addr, (VasEBoot_addr_t) gpptr - (VasEBoot_addr_t) mod->base);
	    mod->gotptr = gpptr + 1;
	    break;
	  }
	  /* We treat LTOFF22X as LTOFF22, so we can ignore LDXMOV.  */
	case R_IA64_LDXMOV:
	  break;
	default:
	  {
	    char rel_info[17]; /* log16(2^64) = 16, plus NUL. */

	    VasEBoot_snprintf (rel_info, sizeof (rel_info) - 1, "%" PRIxVAS_EBOOT_UINT64_T,
			   ELF_R_TYPE (rel->r_info));
	    return VasEBoot_error (VAS_EBOOT_ERR_NOT_IMPLEMENTED_YET,
			       N_("relocation 0x%s is not implemented yet"), rel_info);
	  }
	}
    }
  return VAS_EBOOT_ERR_NONE;
}