[thirdparty/glibc.git] / sysdeps / sh / dl-machine.h

/* Machine-dependent ELF dynamic relocation inline functions.  SH version.
   Copyright (C) 1999-2017 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library 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
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, see
   <http://www.gnu.org/licenses/>.  */

#ifndef dl_machine_h
#define dl_machine_h

#define ELF_MACHINE_NAME "SH"

#include <sys/param.h>
#include <sysdep.h>
#include <assert.h>

/* Return nonzero iff ELF header is compatible with the running host.  */
static inline int __attribute__ ((unused))
elf_machine_matches_host (const Elf32_Ehdr *ehdr)
{
  return ehdr->e_machine == EM_SH;
}


/* Return the link-time address of _DYNAMIC.  Conveniently, this is the
   first element of the GOT.  This must be inlined in a function which
   uses global data.  */
static inline Elf32_Addr __attribute__ ((unused))
elf_machine_dynamic (void)
{
  register Elf32_Addr *got;
  asm ("mov r12,%0" :"=r" (got));
  return *got;
}


/* Return the run-time load address of the shared object.  */
static inline Elf32_Addr __attribute__ ((unused))
elf_machine_load_address (void)
{
  Elf32_Addr addr;
  asm ("mov.l 1f,r0\n\
	mov.l 3f,r2\n\
	add r12,r2\n\
	mov.l @(r0,r12),r0\n\
	bra 2f\n\
	 sub r0,r2\n\
	.align 2\n\
	1: .long _dl_start@GOT\n\
	3: .long _dl_start@GOTOFF\n\
	2: mov r2,%0"
       : "=r" (addr) : : "r0", "r1", "r2");
  return addr;
}


/* Set up the loaded object described by L so its unrelocated PLT
   entries will jump to the on-demand fixup code in dl-runtime.c.  */

static inline int __attribute__ ((unused, always_inline))
elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
{
  Elf32_Addr *got;
  extern void _dl_runtime_resolve (Elf32_Word);
  extern void _dl_runtime_profile (Elf32_Word);

  if (l->l_info[DT_JMPREL] && lazy)
    {
      /* The GOT entries for functions in the PLT have not yet been filled
	 in.  Their initial contents will arrange when called to load an
	 offset into the .rela.plt section and _GLOBAL_OFFSET_TABLE_[1],
	 and then jump to _GLOBAL_OFFSET_TABLE[2].  */
      got = (Elf32_Addr *) D_PTR (l, l_info[DT_PLTGOT]);
      /* If a library is prelinked but we have to relocate anyway,
	 we have to be able to undo the prelinking of .got.plt.
	 The prelinker saved us here address of .plt + 36.  */
      if (got[1])
	{
	  l->l_mach.plt = got[1] + l->l_addr;
	  l->l_mach.gotplt = (Elf32_Addr) &got[3];
	}
      got[1] = (Elf32_Addr) l;	/* Identify this shared object.	 */

      /* The got[2] entry contains the address of a function which gets
	 called to get the address of a so far unresolved function and
	 jump to it.  The profiling extension of the dynamic linker allows
	 to intercept the calls to collect information.	 In this case we
	 don't store the address in the GOT so that all future calls also
	 end in this function.	*/
      if (profile)
	{
	  got[2] = (Elf32_Addr) &_dl_runtime_profile;
	  /* Say that we really want profiling and the timers are started.  */
	  if (GLRO(dl_profile) != NULL
	      && _dl_name_match_p (GLRO(dl_profile), l))
	    GL(dl_profile_map) = l;
	}
      else
	/* This function will get called to fix up the GOT entry indicated by
	   the offset on the stack, and then jump to the resolved address.  */
	got[2] = (Elf32_Addr) &_dl_runtime_resolve;
    }
  return lazy;
}

#define ELF_MACHINE_RUNTIME_FIXUP_ARGS int plt_type
#define ELF_MACHINE_RUNTIME_FIXUP_PARAMS plt_type

/* Mask identifying addresses reserved for the user program,
   where the dynamic linker should not map anything.  */
#define ELF_MACHINE_USER_ADDRESS_MASK	0x80000000UL

/* Initial entry point code for the dynamic linker.
   The C function `_dl_start' is the real entry point;
   its return value is the user program's entry point.	*/

#define RTLD_START asm ("\
.text\n\
.globl _start\n\
.globl _dl_start_user\n\
_start:\n\
	mov r15,r4\n\
	mov.l .L_dl_start,r1\n\
	mova .L_dl_start,r0\n\
	add r1,r0\n\
	jsr @r0\n\
	 nop\n\
_dl_start_user:\n\
	! Save the user entry point address in r8.\n\
	mov r0,r8\n\
	! Point r12 at the GOT.\n\
	mov.l 1f,r12\n\
	mova 1f,r0\n\
	bra 2f\n\
	 add r0,r12\n\
	.align 2\n\
1:	.long _GLOBAL_OFFSET_TABLE_\n\
2:	! See if we were run as a command with the executable file\n\
	! name as an extra leading argument.\n\
	mov.l .L_dl_skip_args,r0\n\
	mov.l @(r0,r12),r0\n\
	mov.l @r0,r0\n\
	! Get the original argument count.\n\
	mov.l @r15,r5\n\
	! Subtract _dl_skip_args from it.\n\
	sub r0,r5\n\
	! Adjust the stack pointer to skip _dl_skip_args words.\n\
	shll2 r0\n\
	add r0,r15\n\
	! Store back the modified argument count.\n\
	mov.l r5,@r15\n\
	! Compute argv address and envp.\n\
	mov r15,r6\n\
	add #4,r6\n\
	mov r5,r7\n\
	shll2 r7\n\
	add r15,r7\n\
	add #8,r7\n\
	mov.l .L_dl_loaded,r0\n\
	mov.l @(r0,r12),r0\n\
	mov.l @r0,r4\n\
	! Call _dl_init.\n\
	mov.l .L_dl_init,r1\n\
	mova .L_dl_init,r0\n\
	add r1,r0\n\
	jsr @r0\n\
	 nop\n\
1:	! Pass our finalizer function to the user in r4, as per ELF ABI.\n\
	mov.l .L_dl_fini,r0\n\
	mov.l @(r0,r12),r4\n\
	! Jump to the user's entry point.\n\
	jmp @r8\n\
	 nop\n\
	.align 2\n\
.L_dl_start:\n\
	.long _dl_start@PLT\n\
.L_dl_skip_args:\n\
	.long _dl_skip_args@GOT\n\
.L_dl_init:\n\
	.long _dl_init@PLT\n\
.L_dl_loaded:\n\
	.long _rtld_local@GOT\n\
.L_dl_fini:\n\
	.long _dl_fini@GOT\n\
	.type __fpscr_values,@object\n\
	.global __fpscr_values\n\
__fpscr_values:\n\
	.long   0\n\
	.long   0x80000\n\
	.weak __fpscr_values\n\
.previous\n\
");

/* ELF_RTYPE_CLASS_PLT iff TYPE describes relocation of a PLT entry or
   TLS variable, so undefined references should not be allowed to
   define the value.
   ELF_RTYPE_CLASS_COPY iff TYPE should not be allowed to resolve to one
   of the main executable's symbols, as for a COPY reloc.  */
#define elf_machine_type_class(type) \
  ((((type) == R_SH_JMP_SLOT || (type) == R_SH_TLS_DTPMOD32		      \
     || (type) == R_SH_TLS_DTPOFF32 || (type) == R_SH_TLS_TPOFF32)	      \
    * ELF_RTYPE_CLASS_PLT)						      \
   | (((type) == R_SH_COPY) * ELF_RTYPE_CLASS_COPY))

/* A reloc type used for ld.so cmdline arg lookups to reject PLT entries.  */
#define ELF_MACHINE_JMP_SLOT	R_SH_JMP_SLOT

/* We define an initialization functions.  This is called very early in
   _dl_sysdep_start.  */
#define DL_PLATFORM_INIT dl_platform_init ()

static inline void __attribute__ ((unused))
dl_platform_init (void)
{
  if (GLRO(dl_platform) != NULL && *GLRO(dl_platform) == '\0')
    /* Avoid an empty string which would disturb us.  */
    GLRO(dl_platform) = NULL;
}

static inline Elf32_Addr
elf_machine_fixup_plt (struct link_map *map, lookup_t t,
		       const Elf32_Rela *reloc,
		       Elf32_Addr *reloc_addr, Elf32_Addr value)
{
  return *reloc_addr = value;
}

/* Return the final value of a plt relocation.	*/
static inline Elf32_Addr
elf_machine_plt_value (struct link_map *map, const Elf32_Rela *reloc,
		       Elf32_Addr value)
{
  return value + reloc->r_addend;
}

#define ARCH_LA_PLTENTER sh_gnu_pltenter
#define ARCH_LA_PLTEXIT sh_gnu_pltexit

#endif /* !dl_machine_h */

/* SH never uses Elf32_Rel relocations.	 */
#define ELF_MACHINE_NO_REL 1
#define ELF_MACHINE_NO_RELA 0

#ifdef RESOLVE_MAP

/* Perform the relocation specified by RELOC and SYM (which is fully resolved).
   MAP is the object containing the reloc.  */

auto inline void
__attribute ((always_inline))
elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
		  const Elf32_Sym *sym, const struct r_found_version *version,
		  void *const reloc_addr_arg, int skip_ifunc)
{
  Elf32_Addr *const reloc_addr = reloc_addr_arg;
  const unsigned int r_type = ELF32_R_TYPE (reloc->r_info);
  Elf32_Addr value;

#define COPY_UNALIGNED_WORD(swp, twp, align) \
  { \
    void *__s = (swp), *__t = (twp); \
    unsigned char *__s1 = __s, *__t1 = __t; \
    unsigned short *__s2 = __s, *__t2 = __t; \
    unsigned long *__s4 = __s, *__t4 = __t; \
    switch ((align)) \
    { \
    case 0: \
      *__t4 = *__s4; \
      break; \
    case 2: \
      *__t2++ = *__s2++; \
      *__t2 = *__s2; \
      break; \
    default: \
      *__t1++ = *__s1++; \
      *__t1++ = *__s1++; \
      *__t1++ = *__s1++; \
      *__t1 = *__s1; \
      break; \
    } \
  }

  if (__glibc_unlikely (r_type == R_SH_RELATIVE))
    {
#ifndef RTLD_BOOTSTRAP
      if (map != &GL(dl_rtld_map)) /* Already done in rtld itself.	 */
#endif
	{
	  if (reloc->r_addend)
	    value = map->l_addr + reloc->r_addend;
	  else
	    {
	      COPY_UNALIGNED_WORD (reloc_addr_arg, &value,
				   (int) reloc_addr_arg & 3);
	      value += map->l_addr;
	    }
	  COPY_UNALIGNED_WORD (&value, reloc_addr_arg,
			       (int) reloc_addr_arg & 3);
	}
    }
#ifndef RTLD_BOOTSTRAP
  else if (__glibc_unlikely (r_type == R_SH_NONE))
    return;
#endif
  else
    {
      const Elf32_Sym *const refsym = sym;
      struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);

      value = sym_map == NULL ? 0 : sym_map->l_addr + sym->st_value;
      value += reloc->r_addend;

      switch (r_type)
	{
	case R_SH_COPY:
	  if (sym == NULL)
	    /* This can happen in trace mode if an object could not be
	       found.  */
	    break;
	  if (sym->st_size > refsym->st_size
	      || (sym->st_size < refsym->st_size && GLRO(dl_verbose)))
	    {
	      const char *strtab;

	      strtab = (const char *) D_PTR (map, l_info[DT_STRTAB]);
	      _dl_error_printf ("\
%s: Symbol `%s' has different size in shared object, consider re-linking\n",
				RTLD_PROGNAME, strtab + refsym->st_name);
	    }
	  memcpy (reloc_addr_arg, (void *) value,
		  MIN (sym->st_size, refsym->st_size));
	  break;
	case R_SH_GLOB_DAT:
	case R_SH_JMP_SLOT:
	  /* These addresses are always aligned.  */
	  *reloc_addr = value;
	  break;
	  /* XXX Remove TLS relocations which are not needed.  */
	case R_SH_TLS_DTPMOD32:
#ifdef RTLD_BOOTSTRAP
	  /* During startup the dynamic linker is always the module
	     with index 1.
	     XXX If this relocation is necessary move before RESOLVE
	     call.  */
	  *reloc_addr = 1;
#else
	  /* Get the information from the link map returned by the
	     resolv function.  */
	  if (sym_map != NULL)
	    *reloc_addr = sym_map->l_tls_modid;
#endif
	  break;
	case R_SH_TLS_DTPOFF32:
#ifndef RTLD_BOOTSTRAP
	  /* During relocation all TLS symbols are defined and used.
	     Therefore the offset is already correct.  */
	  if (sym != NULL)
	    *reloc_addr = sym->st_value;
#endif
	  break;
	case R_SH_TLS_TPOFF32:
	  /* The offset is positive, afterward from the thread pointer.  */
#ifdef RTLD_BOOTSTRAP
	  *reloc_addr = map->l_tls_offset + sym->st_value + reloc->r_addend;
#else
	  /* We know the offset of object the symbol is contained in.
	     It is a positive value which will be added to the thread
	     pointer.  To get the variable position in the TLS block
	     we add the offset from that of the TLS block.  */
	  if (sym != NULL)
	    {
	      CHECK_STATIC_TLS (map, sym_map);
	      *reloc_addr = sym_map->l_tls_offset + sym->st_value
			    + reloc->r_addend;
	    }
#endif
	  break;
	case R_SH_DIR32:
	  {
#ifndef RTLD_BOOTSTRAP
	   /* This is defined in rtld.c, but nowhere in the static
	      libc.a; make the reference weak so static programs can
	      still link.  This declaration cannot be done when
	      compiling rtld.c (i.e. #ifdef RTLD_BOOTSTRAP) because
	      rtld.c contains the common defn for _dl_rtld_map, which
	      is incompatible with a weak decl in the same file.  */
# ifndef SHARED
	    weak_extern (_dl_rtld_map);
# endif
	    if (map == &GL(dl_rtld_map))
	      /* Undo the relocation done here during bootstrapping.
		 Now we will relocate it anew, possibly using a
		 binding found in the user program or a loaded library
		 rather than the dynamic linker's built-in definitions
		 used while loading those libraries.  */
	      value -= map->l_addr + refsym->st_value + reloc->r_addend;
#endif
	    COPY_UNALIGNED_WORD (&value, reloc_addr_arg,
				 (int) reloc_addr_arg & 3);
	    break;
	  }
	case R_SH_REL32:
	  value = (value - (Elf32_Addr) reloc_addr);
	  COPY_UNALIGNED_WORD (&value, reloc_addr_arg,
			       (int) reloc_addr_arg & 3);
	  break;
	default:
	  _dl_reloc_bad_type (map, r_type, 0);
	  break;
	}
    }
}

auto inline void
__attribute__ ((always_inline))
elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
			   void *const reloc_addr_arg)
{
  Elf32_Addr value;

  if (reloc->r_addend)
    value = l_addr + reloc->r_addend;
  else
    {
      COPY_UNALIGNED_WORD (reloc_addr_arg, &value, (int) reloc_addr_arg & 3);
      value += l_addr;
    }
  COPY_UNALIGNED_WORD (&value, reloc_addr_arg, (int) reloc_addr_arg & 3);

#undef COPY_UNALIGNED_WORD
}

auto inline void
__attribute__ ((always_inline))
elf_machine_lazy_rel (struct link_map *map,
		      Elf32_Addr l_addr, const Elf32_Rela *reloc,
		      int skip_ifunc)
{
  Elf32_Addr *const reloc_addr = (void *) (l_addr + reloc->r_offset);
  /* Check for unexpected PLT reloc type.  */
  if (ELF32_R_TYPE (reloc->r_info) == R_SH_JMP_SLOT)
    {
      if (__builtin_expect (map->l_mach.plt, 0) == 0)
	*reloc_addr += l_addr;
      else
	*reloc_addr =
	  map->l_mach.plt
	  + (((Elf32_Addr) reloc_addr) - map->l_mach.gotplt) * 7;
    }
  else
    _dl_reloc_bad_type (map, ELF32_R_TYPE (reloc->r_info), 1);
}

#endif /* RESOLVE_MAP */
Commit	Line	Data
65074d23	1	/* Machine-dependent ELF dynamic relocation inline functions. SH version.
bfff8b1b	2	Copyright (C) 1999-2017 Free Software Foundation, Inc.
65074d23 UD	3	This file is part of the GNU C Library.
	4
	5	The GNU C Library is free software; you can redistribute it and/or
41bdb6e2 AJ	6	modify it under the terms of the GNU Lesser General Public
	7	License as published by the Free Software Foundation; either
	8	version 2.1 of the License, or (at your option) any later version.
65074d23 UD	9
	10	The GNU C Library is distributed in the hope that it will be useful,
	11	but WITHOUT ANY WARRANTY; without even the implied warranty of
41bdb6e2 AJ	12	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
41bdb6e2 AJ	13	Lesser General Public License for more details.
65074d23	14
41bdb6e2	15	You should have received a copy of the GNU Lesser General Public
59ba27a6 PE	16	License along with the GNU C Library; if not, see
59ba27a6 PE	17	<http://www.gnu.org/licenses/>. */
65074d23 UD	18
	19	#ifndef dl_machine_h
	20	#define dl_machine_h
	21
65074d23 UD	22	#define ELF_MACHINE_NAME "SH"
	23
	24	#include <sys/param.h>
c2a4357a	25	#include <sysdep.h>
65074d23 UD	26	#include <assert.h>
65074d23 UD	27
ceb579a3	28	/* Return nonzero iff ELF header is compatible with the running host. */
65074d23	29	static inline int __attribute__ ((unused))
ceb579a3	30	elf_machine_matches_host (const Elf32_Ehdr *ehdr)
65074d23	31	{
ceb579a3	32	return ehdr->e_machine == EM_SH;
65074d23 UD	33	}
	34
	35
	36	/* Return the link-time address of _DYNAMIC. Conveniently, this is the
	37	first element of the GOT. This must be inlined in a function which
	38	uses global data. */
	39	static inline Elf32_Addr __attribute__ ((unused))
	40	elf_machine_dynamic (void)
	41	{
	42	register Elf32_Addr *got;
	43	asm ("mov r12,%0" :"=r" (got));
	44	return *got;
	45	}
	46
	47
	48	/* Return the run-time load address of the shared object. */
	49	static inline Elf32_Addr __attribute__ ((unused))
	50	elf_machine_load_address (void)
	51	{
	52	Elf32_Addr addr;
e438a468 UD	53	asm ("mov.l 1f,r0\n\
e438a468 UD	54	mov.l 3f,r2\n\
045fcd26 UD	55	add r12,r2\n\
045fcd26 UD	56	mov.l @(r0,r12),r0\n\
e438a468	57	bra 2f\n\
045fcd26 UD	58	sub r0,r2\n\
045fcd26 UD	59	.align 2\n\
e438a468 UD	60	1: .long _dl_start@GOT\n\
	61	3: .long _dl_start@GOTOFF\n\
	62	2: mov r2,%0"
65074d23 UD	63	: "=r" (addr) : : "r0", "r1", "r2");
	64	return addr;
	65	}
	66
	67
	68	/* Set up the loaded object described by L so its unrelocated PLT
	69	entries will jump to the on-demand fixup code in dl-runtime.c. */
	70
c2a4357a	71	static inline int __attribute__ ((unused, always_inline))
65074d23 UD	72	elf_machine_runtime_setup (struct link_map *l, int lazy, int profile)
	73	{
	74	Elf32_Addr *got;
	75	extern void _dl_runtime_resolve (Elf32_Word);
	76	extern void _dl_runtime_profile (Elf32_Word);
	77
	78	if (l->l_info[DT_JMPREL] && lazy)
	79	{
	80	/* The GOT entries for functions in the PLT have not yet been filled
	81	in. Their initial contents will arrange when called to load an
	82	offset into the .rela.plt section and _GLOBAL_OFFSET_TABLE_[1],
	83	and then jump to _GLOBAL_OFFSET_TABLE[2]. */
	84	got = (Elf32_Addr *) D_PTR (l, l_info[DT_PLTGOT]);
32e6df36 UD	85	/* If a library is prelinked but we have to relocate anyway,
	86	we have to be able to undo the prelinking of .got.plt.
	87	The prelinker saved us here address of .plt + 36. */
	88	if (got[1])
	89	{
	90	l->l_mach.plt = got[1] + l->l_addr;
	91	l->l_mach.gotplt = (Elf32_Addr) &got[3];
	92	}
65074d23 UD	93	got[1] = (Elf32_Addr) l; /* Identify this shared object. */
	94
	95	/* The got[2] entry contains the address of a function which gets
	96	called to get the address of a so far unresolved function and
	97	jump to it. The profiling extension of the dynamic linker allows
	98	to intercept the calls to collect information. In this case we
	99	don't store the address in the GOT so that all future calls also
	100	end in this function. */
	101	if (profile)
	102	{
	103	got[2] = (Elf32_Addr) &_dl_runtime_profile;
	104	/* Say that we really want profiling and the timers are started. */
537e7234 UD	105	if (GLRO(dl_profile) != NULL
	106	&& _dl_name_match_p (GLRO(dl_profile), l))
	107	GL(dl_profile_map) = l;
65074d23 UD	108	}
	109	else
	110	/* This function will get called to fix up the GOT entry indicated by
	111	the offset on the stack, and then jump to the resolved address. */
	112	got[2] = (Elf32_Addr) &_dl_runtime_resolve;
	113	}
	114	return lazy;
	115	}
	116
65074d23	117	#define ELF_MACHINE_RUNTIME_FIXUP_ARGS int plt_type
d072f3f7	118	#define ELF_MACHINE_RUNTIME_FIXUP_PARAMS plt_type
65074d23	119
65074d23 UD	120	/* Mask identifying addresses reserved for the user program,
	121	where the dynamic linker should not map anything. */
	122	#define ELF_MACHINE_USER_ADDRESS_MASK 0x80000000UL
	123
	124	/* Initial entry point code for the dynamic linker.
	125	The C function `_dl_start' is the real entry point;
	126	its return value is the user program's entry point. */
	127
	128	#define RTLD_START asm ("\
	129	.text\n\
	130	.globl _start\n\
	131	.globl _dl_start_user\n\
	132	_start:\n\
	133	mov r15,r4\n\
	134	mov.l .L_dl_start,r1\n\
	135	mova .L_dl_start,r0\n\
	136	add r1,r0\n\
	137	jsr @r0\n\
	138	nop\n\
	139	_dl_start_user:\n\
	140	! Save the user entry point address in r8.\n\
	141	mov r0,r8\n\
	142	! Point r12 at the GOT.\n\
	143	mov.l 1f,r12\n\
	144	mova 1f,r0\n\
	145	bra 2f\n\
	146	add r0,r12\n\
	147	.align 2\n\
	148	1: .long _GLOBAL_OFFSET_TABLE_\n\
97716954	149	2: ! See if we were run as a command with the executable file\n\
65074d23 UD	150	! name as an extra leading argument.\n\
	151	mov.l .L_dl_skip_args,r0\n\
	152	mov.l @(r0,r12),r0\n\
	153	mov.l @r0,r0\n\
	154	! Get the original argument count.\n\
	155	mov.l @r15,r5\n\
	156	! Subtract _dl_skip_args from it.\n\
	157	sub r0,r5\n\
	158	! Adjust the stack pointer to skip _dl_skip_args words.\n\
	159	shll2 r0\n\
	160	add r0,r15\n\
	161	! Store back the modified argument count.\n\
	162	mov.l r5,@r15\n\
	163	! Compute argv address and envp.\n\
	164	mov r15,r6\n\
	165	add #4,r6\n\
	166	mov r5,r7\n\
	167	shll2 r7\n\
	168	add r15,r7\n\
c2a4357a	169	add #8,r7\n\
65074d23 UD	170	mov.l .L_dl_loaded,r0\n\
	171	mov.l @(r0,r12),r0\n\
	172	mov.l @r0,r4\n\
	173	! Call _dl_init.\n\
	174	mov.l .L_dl_init,r1\n\
	175	mova .L_dl_init,r0\n\
	176	add r1,r0\n\
	177	jsr @r0\n\
	178	nop\n\
6c1232e2	179	1: ! Pass our finalizer function to the user in r4, as per ELF ABI.\n\
65074d23 UD	180	mov.l .L_dl_fini,r0\n\
	181	mov.l @(r0,r12),r4\n\
	182	! Jump to the user's entry point.\n\
	183	jmp @r8\n\
	184	nop\n\
	185	.align 2\n\
	186	.L_dl_start:\n\
	187	.long _dl_start@PLT\n\
65074d23 UD	188	.L_dl_skip_args:\n\
	189	.long _dl_skip_args@GOT\n\
	190	.L_dl_init:\n\
c5684fdb	191	.long _dl_init@PLT\n\
65074d23	192	.L_dl_loaded:\n\
0d01dace	193	.long _rtld_local@GOT\n\
65074d23 UD	194	.L_dl_fini:\n\
65074d23 UD	195	.long _dl_fini@GOT\n\
537e7234 UD	196	.type __fpscr_values,@object\n\
	197	.global __fpscr_values\n\
	198	__fpscr_values:\n\
	199	.long 0\n\
	200	.long 0x80000\n\
	201	.weak __fpscr_values\n\
65074d23 UD	202	.previous\n\
	203	");
	204
3632a260 UD	205	/* ELF_RTYPE_CLASS_PLT iff TYPE describes relocation of a PLT entry or
	206	TLS variable, so undefined references should not be allowed to
	207	define the value.
209826bc	208	ELF_RTYPE_CLASS_COPY iff TYPE should not be allowed to resolve to one
cf5a372e	209	of the main executable's symbols, as for a COPY reloc. */
d063d164	210	#define elf_machine_type_class(type) \
3632a260 UD	211	((((type) == R_SH_JMP_SLOT \|\| (type) == R_SH_TLS_DTPMOD32 \
	212	\|\| (type) == R_SH_TLS_DTPOFF32 \|\| (type) == R_SH_TLS_TPOFF32) \
	213	* ELF_RTYPE_CLASS_PLT) \
	214	\| (((type) == R_SH_COPY) * ELF_RTYPE_CLASS_COPY))
65074d23 UD	215
	216	/* A reloc type used for ld.so cmdline arg lookups to reject PLT entries. */
	217	#define ELF_MACHINE_JMP_SLOT R_SH_JMP_SLOT
	218
	219	/* We define an initialization functions. This is called very early in
	220	_dl_sysdep_start. */
	221	#define DL_PLATFORM_INIT dl_platform_init ()
	222
65074d23 UD	223	static inline void __attribute__ ((unused))
	224	dl_platform_init (void)
	225	{
d3a4a571	226	if (GLRO(dl_platform) != NULL && *GLRO(dl_platform) == '\0')
65074d23	227	/* Avoid an empty string which would disturb us. */
d3a4a571	228	GLRO(dl_platform) = NULL;
65074d23 UD	229	}
	230
	231	static inline Elf32_Addr
	232	elf_machine_fixup_plt (struct link_map *map, lookup_t t,
	233	const Elf32_Rela *reloc,
	234	Elf32_Addr *reloc_addr, Elf32_Addr value)
	235	{
	236	return *reloc_addr = value;
	237	}
	238
	239	/* Return the final value of a plt relocation. */
	240	static inline Elf32_Addr
	241	elf_machine_plt_value (struct link_map map, const Elf32_Rela reloc,
	242	Elf32_Addr value)
	243	{
	244	return value + reloc->r_addend;
	245	}
	246
537e7234 UD	247	#define ARCH_LA_PLTENTER sh_gnu_pltenter
	248	#define ARCH_LA_PLTEXIT sh_gnu_pltexit
	249
0ecb606c	250	#endif /* !dl_machine_h */
65074d23 UD	251
	252	/* SH never uses Elf32_Rel relocations. */
	253	#define ELF_MACHINE_NO_REL 1
4cf5b6d0	254	#define ELF_MACHINE_NO_RELA 0
65074d23	255
9cfe5381 RM	256	#ifdef RESOLVE_MAP
9cfe5381 RM	257
65074d23 UD	258	/* Perform the relocation specified by RELOC and SYM (which is fully resolved).
	259	MAP is the object containing the reloc. */
	260
c2a4357a UD	261	auto inline void
c2a4357a UD	262	__attribute ((always_inline))
65074d23	263	elf_machine_rela (struct link_map map, const Elf32_Rela reloc,
87d254a7	264	const Elf32_Sym sym, const struct r_found_version version,
3a62d00d	265	void *const reloc_addr_arg, int skip_ifunc)
65074d23	266	{
87d254a7	267	Elf32_Addr *const reloc_addr = reloc_addr_arg;
1721af3f	268	const unsigned int r_type = ELF32_R_TYPE (reloc->r_info);
045fcd26 UD	269	Elf32_Addr value;
045fcd26 UD	270
87d254a7	271	#define COPY_UNALIGNED_WORD(swp, twp, align) \
045fcd26	272	{ \
87d254a7	273	void __s = (swp), __t = (twp); \
d3a4a571 UD	274	unsigned char __s1 = __s, __t1 = __t; \
	275	unsigned short __s2 = __s, __t2 = __t; \
	276	unsigned long __s4 = __s, __t4 = __t; \
045fcd26 UD	277	switch ((align)) \
	278	{ \
	279	case 0: \
d3a4a571	280	__t4 = __s4; \
045fcd26 UD	281	break; \
045fcd26 UD	282	case 2: \
d3a4a571 UD	283	__t2++ = __s2++; \
d3a4a571 UD	284	__t2 = __s2; \
045fcd26 UD	285	break; \
045fcd26 UD	286	default: \
d3a4a571 UD	287	__t1++ = __s1++; \
	288	__t1++ = __s1++; \
	289	__t1++ = __s1++; \
	290	__t1 = __s1; \
045fcd26 UD	291	break; \
	292	} \
	293	}
	294
a1ffb40e	295	if (__glibc_unlikely (r_type == R_SH_RELATIVE))
65074d23 UD	296	{
65074d23 UD	297	#ifndef RTLD_BOOTSTRAP
5688da55	298	if (map != &GL(dl_rtld_map)) /* Already done in rtld itself. */
65074d23	299	#endif
876f9634 UD	300	{
876f9634 UD	301	if (reloc->r_addend)
045fcd26	302	value = map->l_addr + reloc->r_addend;
876f9634	303	else
045fcd26	304	{
87d254a7 AO	305	COPY_UNALIGNED_WORD (reloc_addr_arg, &value,
87d254a7 AO	306	(int) reloc_addr_arg & 3);
045fcd26 UD	307	value += map->l_addr;
045fcd26 UD	308	}
87d254a7 AO	309	COPY_UNALIGNED_WORD (&value, reloc_addr_arg,
87d254a7 AO	310	(int) reloc_addr_arg & 3);
876f9634	311	}
65074d23	312	}
1721af3f	313	#ifndef RTLD_BOOTSTRAP
a1ffb40e	314	else if (__glibc_unlikely (r_type == R_SH_NONE))
1721af3f UD	315	return;
	316	#endif
	317	else
65074d23 UD	318	{
65074d23 UD	319	const Elf32_Sym *const refsym = sym;
3632a260	320	struct link_map *sym_map = RESOLVE_MAP (&sym, version, r_type);
045fcd26	321
606832e6	322	value = sym_map == NULL ? 0 : sym_map->l_addr + sym->st_value;
65074d23 UD	323	value += reloc->r_addend;
65074d23 UD	324
3632a260	325	switch (r_type)
65074d23 UD	326	{
	327	case R_SH_COPY:
	328	if (sym == NULL)
	329	/* This can happen in trace mode if an object could not be
	330	found. */
	331	break;
	332	if (sym->st_size > refsym->st_size
d3a4a571	333	\|\| (sym->st_size < refsym->st_size && GLRO(dl_verbose)))
65074d23 UD	334	{
	335	const char *strtab;
	336
	337	strtab = (const char *) D_PTR (map, l_info[DT_STRTAB]);
35fc382a	338	_dl_error_printf ("\
729399c3	339	%s: Symbol `%s' has different size in shared object, consider re-linking\n",
b9375348	340	RTLD_PROGNAME, strtab + refsym->st_name);
65074d23	341	}
87d254a7 AO	342	memcpy (reloc_addr_arg, (void *) value,
87d254a7 AO	343	MIN (sym->st_size, refsym->st_size));
65074d23 UD	344	break;
	345	case R_SH_GLOB_DAT:
	346	case R_SH_JMP_SLOT:
045fcd26	347	/* These addresses are always aligned. */
65074d23 UD	348	*reloc_addr = value;
65074d23 UD	349	break;
3632a260 UD	350	/* XXX Remove TLS relocations which are not needed. */
3632a260 UD	351	case R_SH_TLS_DTPMOD32:
d063d164	352	#ifdef RTLD_BOOTSTRAP
3632a260 UD	353	/* During startup the dynamic linker is always the module
	354	with index 1.
	355	XXX If this relocation is necessary move before RESOLVE
	356	call. */
	357	*reloc_addr = 1;
d063d164	358	#else
3632a260 UD	359	/* Get the information from the link map returned by the
	360	resolv function. */
	361	if (sym_map != NULL)
	362	*reloc_addr = sym_map->l_tls_modid;
d063d164	363	#endif
3632a260 UD	364	break;
3632a260 UD	365	case R_SH_TLS_DTPOFF32:
d063d164	366	#ifndef RTLD_BOOTSTRAP
3632a260 UD	367	/* During relocation all TLS symbols are defined and used.
	368	Therefore the offset is already correct. */
	369	if (sym != NULL)
	370	*reloc_addr = sym->st_value;
d063d164	371	#endif
3632a260 UD	372	break;
	373	case R_SH_TLS_TPOFF32:
	374	/* The offset is positive, afterward from the thread pointer. */
d063d164	375	#ifdef RTLD_BOOTSTRAP
aa298c08	376	*reloc_addr = map->l_tls_offset + sym->st_value + reloc->r_addend;
d063d164	377	#else
3632a260 UD	378	/* We know the offset of object the symbol is contained in.
	379	It is a positive value which will be added to the thread
	380	pointer. To get the variable position in the TLS block
	381	we add the offset from that of the TLS block. */
d40eb37a UD	382	if (sym != NULL)
	383	{
	384	CHECK_STATIC_TLS (map, sym_map);
	385	*reloc_addr = sym_map->l_tls_offset + sym->st_value
	386	+ reloc->r_addend;
	387	}
d063d164	388	#endif
3632a260	389	break;
65074d23 UD	390	case R_SH_DIR32:
	391	{
	392	#ifndef RTLD_BOOTSTRAP
	393	/* This is defined in rtld.c, but nowhere in the static
	394	libc.a; make the reference weak so static programs can
	395	still link. This declaration cannot be done when
	396	compiling rtld.c (i.e. #ifdef RTLD_BOOTSTRAP) because
	397	rtld.c contains the common defn for _dl_rtld_map, which
	398	is incompatible with a weak decl in the same file. */
5688da55	399	# ifndef SHARED
d3a4a571	400	weak_extern (_dl_rtld_map);
5688da55 UD	401	# endif
5688da55 UD	402	if (map == &GL(dl_rtld_map))
65074d23 UD	403	/* Undo the relocation done here during bootstrapping.
	404	Now we will relocate it anew, possibly using a
	405	binding found in the user program or a loaded library
	406	rather than the dynamic linker's built-in definitions
	407	used while loading those libraries. */
	408	value -= map->l_addr + refsym->st_value + reloc->r_addend;
	409	#endif
87d254a7 AO	410	COPY_UNALIGNED_WORD (&value, reloc_addr_arg,
87d254a7 AO	411	(int) reloc_addr_arg & 3);
65074d23 UD	412	break;
	413	}
	414	case R_SH_REL32:
045fcd26	415	value = (value - (Elf32_Addr) reloc_addr);
87d254a7 AO	416	COPY_UNALIGNED_WORD (&value, reloc_addr_arg,
87d254a7 AO	417	(int) reloc_addr_arg & 3);
65074d23 UD	418	break;
65074d23 UD	419	default:
3632a260	420	_dl_reloc_bad_type (map, r_type, 0);
65074d23 UD	421	break;
	422	}
	423	}
1721af3f UD	424	}
1721af3f UD	425
c2a4357a UD	426	auto inline void
c2a4357a UD	427	__attribute__ ((always_inline))
1f2a1df3	428	elf_machine_rela_relative (Elf32_Addr l_addr, const Elf32_Rela *reloc,
87d254a7	429	void *const reloc_addr_arg)
1721af3f	430	{
9596d0dd UD	431	Elf32_Addr value;
9596d0dd UD	432
1721af3f UD	433	if (reloc->r_addend)
	434	value = l_addr + reloc->r_addend;
	435	else
	436	{
87d254a7	437	COPY_UNALIGNED_WORD (reloc_addr_arg, &value, (int) reloc_addr_arg & 3);
1721af3f UD	438	value += l_addr;
1721af3f UD	439	}
87d254a7	440	COPY_UNALIGNED_WORD (&value, reloc_addr_arg, (int) reloc_addr_arg & 3);
045fcd26 UD	441
045fcd26 UD	442	#undef COPY_UNALIGNED_WORD
65074d23 UD	443	}
65074d23 UD	444
c2a4357a UD	445	auto inline void
c2a4357a UD	446	__attribute__ ((always_inline))
65074d23	447	elf_machine_lazy_rel (struct link_map *map,
3a62d00d AS	448	Elf32_Addr l_addr, const Elf32_Rela *reloc,
3a62d00d AS	449	int skip_ifunc)
65074d23 UD	450	{
	451	Elf32_Addr const reloc_addr = (void ) (l_addr + reloc->r_offset);
	452	/* Check for unexpected PLT reloc type. */
	453	if (ELF32_R_TYPE (reloc->r_info) == R_SH_JMP_SLOT)
32e6df36 UD	454	{
	455	if (__builtin_expect (map->l_mach.plt, 0) == 0)
	456	*reloc_addr += l_addr;
	457	else
	458	*reloc_addr =
	459	map->l_mach.plt
	460	+ (((Elf32_Addr) reloc_addr) - map->l_mach.gotplt) * 7;
	461	}
65074d23 UD	462	else
	463	_dl_reloc_bad_type (map, ELF32_R_TYPE (reloc->r_info), 1);
	464	}
	465
537e7234	466	#endif /* RESOLVE_MAP */