Update.cvs/libc-ud-970307cvs/libc-970316cvs/libc-970315cvs/libc-970314cvs/libc-970313cvs/libc-970312cvs/libc-970311cvs/libc-970310cvs/libc-970309cvs/libc-970308

1997-03-08 05:30  Ulrich Drepper  <drepper@cygnus.com>

	* argp/Makefile (routines): Add argp-eexst.
	* argp/argp-ba.c (argp_program_bug_address): Make `const'.
	* argp/argp-eexst.c: New file.  Define exit status variable.
	* argp/argp-help.c (__argp_state_help): Use argp_err_exit_status
	variable instead of always exiting with value 1.
	* argp/argp-pv.c (argp_program_version): Make `const'.
	* argp/argp.h: Declare argp_err_exit_status.
	Patches by Miles Bader <miles@gnu.ai.mit.edu>.

	* locale/programs/localedef.c: Use argp_err_exit_status to
	terminate with correct value.

	* inet/rcmd.c (iruserok): Use euidaccess instead of half-hearted
	switching of UID before opening .rhosts.

	* libio/vsnprintf.c: Change implementation to follow ISO C 9X
	proposal.  The return value now is always the number of characters
	which would be written if enough space is available.
	* manual/stdio.texi: Update description for new behaviour.

	* locale/locale.h (__locale_t): Don't use __locale_t for struct
	name and pointer to struct since old gccs cannot keep the namespaces
	apart.  Rename struct to __locale_struct.
	* locale/duplocale.h: Likewise.
	* locale/newlocale.h: Likewise.

	* math/Makefile (headers): Add complex.h and cmathcalls.h.
	(routines): Remove w_cabs.  Add conj, cimag, creal, and cabs.
	* math/math.h: Undefine __MATHDECL_1, __MATHDECL, and __MATHCALL
	after use.
	(signgam): Move declaration to here from mathcalls.h.
	* math/mathcalls.h (cabs, __cabs_complex, signgam): Remove definition.
	Correct comment for fmin and fmax.
	Start implementing complex math function from ISO C 9X.
	* math/complex.h: New file.
	* math/cmathcalls.h: New file.
	* math/cabs.c: New file.
	* math/cabsf.c: New file.
	* math/cabsl.c: New file.
	* math/cimag.c: New file.
	* math/cimagf.c: New file.
	* math/cimagl.c: New file.
	* math/conj.c: New file.
	* math/conjf.c: New file.
	* math/conjl.c: New file.
	* math/creal.c: New file.
	* math/crealf.c: New file.
	* math/creall.c: New file.
	* sysdeps/libm-ieee754/w_cabs.c: Removed.
	* sysdeps/libm-ieee754/w_cabsf.c: Removed.
	* sysdeps/libm-ieee754/w_cabsl.c: Removed.

	* posix/regex.c: Merge with regex sources from Arnold Robbins'
	version in GNU awk.
	* posix/regex.h: Likewise.

	Add regex test suite by Tom Lord.
	* posix/Makefile (distribute): Add TESTS, TESTS2C.sed, and testcases.h.
	(tests): Add runtests.
	(before-compile): Add testcases.h.
	(testcases.h): New rule to generate header with tests.
	* posix/TESTS: New file.
	* posix/TESTS2C.sed.: New file.
	* posix/runtests.c: New file.
	* posix/testcases.h: New file.

	* sysdeps/unix/sysv/linux/poll.c: Test whether poll syscall is
	available and use fall-back implementation if not.

	* sysdeps/unix/sysv/linux/syscalls.list: Sort entries.

	* time/ialloc.c: Update from tzcode1997c.
	* time/private.h: Likewise.
	* time/scheck.c: Likewise.
	* time/tzselect.ksh: Likewise.
	* time/zdump.c: Likewise.
	* time/zic.c: Likewise.

	* time/tzfile.c: Pretty print.

1997-03-06 07:37  Geoff Keating  <geoffk@ozemail.com.au>

	Port to powerpc-*-linux-gnu.  Slightly tested, under MkLinux,
	on a 601.

	* sysdeps/powerpc/Implies: Added.
	* sysdeps/powerpc/__longjmp.S: Added.
	* sysdeps/powerpc/__math.h: Added.
	* sysdeps/powerpc/bsd-_setjmp.S: Added.
	* sysdeps/powerpc/bsd-setjmp.S: Added.
	* sysdeps/powerpc/dl-machine.h: Added.
	* sysdeps/powerpc/ffs.c: Added.
	* sysdeps/powerpc/fpu_control.h: Added.
	* sysdeps/powerpc/jmp_buf.h: Added.
	* sysdeps/powerpc/setjmp.S: Added.
	* sysdeps/powerpc/strlen.s: Added.
	* sysdeps/powerpc/elf/start.c: Added.
	* sysdeps/powerpc/fpu_control.h: Added.
	* sysdeps/powerpc/jmp_buf.h: Added.

	* sysdeps/unix/sysv/linux/powerpc/Dist: Added.
	* sysdeps/unix/sysv/linux/powerpc/_exit.S: Added.
	* sysdeps/unix/sysv/linux/powerpc/brk.c: Added.
	* sysdeps/unix/sysv/linux/powerpc/clone.S: Added.
	* sysdeps/unix/sysv/linux/powerpc/init-first.h: Added.
	* sysdeps/unix/sysv/linux/powerpc/ioctl-types.h: Added.
	* sysdeps/unix/sysv/linux/powerpc/profil.c: Added.
	* sysdeps/unix/sysv/linux/powerpc/sigreturn.S: Added.
	* sysdeps/unix/sysv/linux/powerpc/socket.S: Added.
	* sysdeps/unix/sysv/linux/powerpc/syscall.S: Added.
	* sysdeps/unix/sysv/linux/powerpc/syscalls.list: Added.
	* sysdeps/unix/sysv/linux/powerpc/sysdep.c: Added.
	* sysdeps/unix/sysv/linux/powerpc/sysdep.h: Added.
	* sysdeps/unix/sysv/linux/powerpc/termbits.h: Added.
	* sysdeps/unix/sysv/linux/powerpc/sys/syscall.h: Added.

1997-03-05 05:24  Geoff Keating  <geoffk@ozemail.com.au>

	* elf/dl-runtime.c (fixup): Add ELF_FIXUP_RETURNS_ADDRESS switch,
	because knowing the first instruction of a PowerPC PLT trampoline
	is not very helpful.

1997-03-04 08:04  Geoff Keating  <geoffk@ozemail.com.au>

	* elf/dl-load.c (ELF_PREFERRED_ADDRESS, ELF_PREFERRED_ADDRESS_DATA,
	ELF_FIXED_ADDRESS): Added. These are for dl-machine.h to indicate
	a preference as to where executables should be loaded.

1997-02-28 08:50  Geoff Keating  <geoffk@ozemail.com.au>

	* elf/elf.h: Add in all those PowerPC reloc types.

1997-02-24 07:12  Geoff Keating  <geoffk@ozemail.com.au>

	* stdio-common/vfscanf.c: Use __va_copy if available.

1997-03-06 13:50  Andreas Schwab  <schwab@issan.informatik.uni-dortmund.de>

	* malloc/malloc.c (mprotect) [_LIBC]: Define as __mprotect to
	clean up namespace.

1997-03-07 14:27  Ulrich Drepper  <drepper@cygnus.com>

	* sysdeps/libm-ieee754/s_fpclassify.c (__fpclassify): Don't use
	non-existing GET_WORDS macro, use EXTRACT_WORDS.
	Reported by Andres Schwab <schwab@issan.informatik.uni-dortmund.de>.

1997-03-07 05:27  Ulrich Drepper  <drepper@cygnus.com>

	* sysdeps/unix/sysv/linux/i386/sigaction.c: The user- and
	kernel-level sigaction structure is different.  handle this
	correctly.
	Bug report by Andres Jaeger <jaeger@informatik.uni-kl.de>.

1997-03-06 05:55  David Engel  <david@sw.ods.com>

	* sysdeps/generic/dl-cache.c (_dl_load_cache_lookup): Also
	recognize cache entries with flag == 3.

1997-03-06 01:05  Ulrich Drepper  <drepper@cygnus.com>

	* sysdeps/generic/netinet/in.h (INADDR_NONE): Cast to unsigned int.
	(INADDR_LOOPBACK): Likewise.
	* sysdeps/unix/sysv/linux/netinet/in.h: Likewise.

	* manual/socket.texi: Correct types of INADDR_* constants from
	unsigned long to unsigned.

1997-03-05 23:14  Ulrich Drepper  <drepper@cygnus.com>

	* time/antarctica: Update from tzdata1997c.
	* time/asia: Likewise.
	* time/zone.tab: Likewise.

1997-03-05 00:43  Andreas Schwab  <schwab@issan.informatik.uni-dortmund.de>

	* configure.in (libc_cv_asm_symver_directive,
	libc_cv_ld_version_script_option): Remove unknown instruction from
	assembler test file.

1997-03-04 19:14  Andreas Schwab  <schwab@issan.informatik.uni-dortmund.de>

	* sysdeps/m68k/fpu/__math.h: Update feature tests to use
	__USE_ISOC9X.
	[__USE_ISOC9X]: Define __log2 and __exp2 inlines.
	(fabs): Remove defininition, it is a gcc builtin.
	(sqrt, __sqrt): Remove definition, they have wrappers in libm.

1997-03-04 10:11  H.J. Lu  <hjl@lucon.org>

	* sunrpc/Makefile ($(objpfx)rpc-proto.c): Create subdir before
	generating file.

1997-03-05 03:59  Ulrich Drepper  <drepper@cygnus.com>

	* inet/rcmd.c (__ivaliduser): Don't use getline, but __getline
	instead to avoid namespace problems.
	Reported by David Mosberger-Tang <davidm@AZStarNet.COM>.

1997-03-03 19:01  Andreas Schwab  <schwab@issan.informatik.uni-dortmund.de>

	* login/utmp_file.c: Fix previous change.  Make portable by
	checking the _HAVE_UT_* feature macros.

	* libio/fileops.c (_IO_file_finish): Likewise.

1 files changed, 529 insertions, 0 deletions

diff --git a/sysdeps/powerpc/dl-machine.h b/sysdeps/powerpc/dl-machine.h
new file mode 100644
index 0000000..a60a297
--- /dev/null
+++ b/sysdeps/powerpc/dl-machine.h
@@ -0,0 +1,529 @@
+/* Machine-dependent ELF dynamic relocation inline functions.  PowerPC version.
+   Copyright (C) 1995, 1996, 1997 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 Library General Public License as
+   published by the Free Software Foundation; either version 2 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
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public
+   License along with the GNU C Library; see the file COPYING.LIB.  If not,
+   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+
+#define ELF_MACHINE_NAME "powerpc"
+
+#include <assert.h>
+#include <string.h>
+#include <link.h>
+
+/* stuff for the PLT */
+#define PLT_INITIAL_ENTRY_WORDS 18
+#define PLT_LONGBRANCH_ENTRY_WORDS 10
+#define OPCODE_ADDI(rd,ra,simm) \
+  (0x38000000 | (rd) << 21 | (ra) << 16 | (simm) & 0xffff)
+#define OPCODE_ADDIS(rd,ra,simm) \
+  (0x3c000000 | (rd) << 21 | (ra) << 16 | (simm) & 0xffff)
+#define OPCODE_ADD(rd,ra,rb) \
+  (0x7c000214 | (rd) << 21 | (ra) << 16 | (rb) << 11)
+#define OPCODE_B(target) (0x48000000 | (target) & 0x03fffffc)
+#define OPCODE_BA(target) (0x48000002 | (target) & 0x03fffffc)
+#define OPCODE_BCTR() 0x4e800420
+#define OPCODE_LWZ(rd,d,ra) \
+  (0x80000000 | (rd) << 21 | (ra) << 16 | (d) & 0xffff)
+#define OPCODE_MTCTR(rd) (0x7C0903A6 | (rd) << 21)
+#define OPCODE_RLWINM(ra,rs,sh,mb,me) \
+  (0x54000000 | (rs) << 21 | (ra) << 16 | (sh) << 11 | (mb) << 6 | (me) << 1)
+
+#define OPCODE_LI(rd,simm)    OPCODE_ADDI(rd,0,simm)
+#define OPCODE_SLWI(ra,rs,sh) OPCODE_RLWINM(ra,rs,sh,0,31-sh)
+
+
+/* Return nonzero iff E_MACHINE is compatible with the running host.  */
+static inline int
+elf_machine_matches_host (Elf32_Half e_machine)
+{
+  return e_machine == EM_PPC;
+}
+
+
+/* Return the link-time address of _DYNAMIC, the first value in the GOT.  */
+static inline Elf32_Addr
+elf_machine_dynamic (void)
+{
+  Elf32_Addr *got;
+  asm (" bl _GLOBAL_OFFSET_TABLE_-4@local"
+       : "=l"(got));
+  return *got;
+}
+
+/* Return the run-time load address of the shared object.  */
+static inline Elf32_Addr
+elf_machine_load_address (void)
+{
+  unsigned *got;
+  unsigned *branchaddr;
+
+  /* This is much harder than you'd expect.  Possibly I'm missing something.
+     The 'obvious' way:
+
+       Apparently, "bcl 20,31,$+4" is what should be used to load LR
+       with the address of the next instruction.
+       I think this is so that machines that do bl/blr pairing don't
+       get confused.
+
+     asm ("bcl 20,31,0f ;"
+          "0: mflr 0 ;"
+          "lis %0,0b@ha;"
+          "addi %0,%0,0b@l;"
+          "subf %0,%0,0"
+          : "=b" (addr) : : "r0", "lr");
+
+     doesn't work, because the linker doesn't have to (and in fact doesn't)
+     update the @ha and @l references; the loader (which runs after this
+     code) will do that.
+
+     Instead, we use the following trick:
+
+     The linker puts the _link-time_ address of _DYNAMIC at the first
+     word in the GOT. We could branch to that address, if we wanted,
+     by using an @local reloc; the linker works this out, so it's safe
+     to use now. We can't, of course, actually branch there, because
+     we'd cause an illegal instruction exception; so we need to compute
+     the address ourselves. That gives us the following code: */
+
+  /* Get address of the 'b _DYNAMIC@local'...  */
+  asm ("bl 0f ;"
+       "b _DYNAMIC@local;"
+       "0:"
+       : "=l"(branchaddr));
+
+  /* ... and the address of the GOT.  */
+  asm (" bl _GLOBAL_OFFSET_TABLE_-4@local"
+       : "=l"(got));
+
+  /* So now work out the difference between where the branch actually points,
+     and the offset of that location in memory from the start of the file.  */
+  return (Elf32_Addr)branchaddr - *got +
+    (*branchaddr & 0x3fffffc |
+     (int)(*branchaddr << 6 & 0x80000000) >> 6);
+}
+
+#define ELF_MACHINE_BEFORE_RTLD_RELOC(dynamic_info) /* nothing */
+
+/* Perform the relocation specified by RELOC and SYM (which is fully resolved).
+   LOADADDR is the load address of the object; INFO is an array indexed
+   by DT_* of the .dynamic section info.  */
+
+#ifdef RESOLVE
+
+static inline void
+elf_machine_rela (struct link_map *map, const Elf32_Rela *reloc,
+		  const Elf32_Sym *sym, const struct r_found_version *version)
+{
+  Elf32_Addr *const reloc_addr = (Elf32_Addr *)(map->l_addr + reloc->r_offset);
+  Elf32_Word loadbase, finaladdr;
+  const int rinfo = ELF32_R_TYPE (reloc->r_info);
+
+  if (rinfo == R_PPC_NONE)
+    return;
+
+  if (sym && ELF32_ST_TYPE (sym->st_info) == STT_SECTION ||
+      rinfo == R_PPC_RELATIVE)
+    {
+      /* Has already been relocated.  */
+      loadbase = map->l_addr;
+      finaladdr = loadbase + reloc->r_addend;
+    }
+  else
+    {
+      assert (sym != NULL);
+      if (rinfo == R_PPC_JMP_SLOT)
+	loadbase = (Elf32_Word) (char *) RESOLVE (&sym,
+						  version, DL_LOOKUP_NOPLT);
+      else
+	loadbase = (Elf32_Word) (char *) RESOLVE (&sym, version, 0);
+      if (sym == NULL)
+	{
+	  /* Weak symbol that wasn't actually defined anywhere.  */
+	  assert (loadbase == 0);
+	  finaladdr = reloc->r_addend;
+	}
+      else
+	finaladdr = (loadbase + (Elf32_Word)(char *)sym->st_value
+		     + reloc->r_addend);
+    }
+
+  switch (rinfo)
+    {
+    case R_PPC_UADDR16:
+    case R_PPC_ADDR16_LO:
+    case R_PPC_ADDR16:
+      *(Elf32_Half*) reloc_addr = finaladdr;
+      break;
+
+    case R_PPC_ADDR16_HI:
+      *(Elf32_Half*) reloc_addr = finaladdr >> 16;
+      break;
+
+    case R_PPC_ADDR16_HA:
+      *(Elf32_Half*) reloc_addr = finaladdr + 0x8000 >> 16;
+      break;
+
+    case R_PPC_REL24:
+      {
+	Elf32_Sword delta = finaladdr - (Elf32_Word) (char *) reloc_addr;
+	assert (delta << 6 >> 6 == delta);
+	*reloc_addr = *reloc_addr & 0xfc000003 | delta & 0x3fffffc;
+      }
+      break;
+
+    case R_PPC_UADDR32:
+    case R_PPC_GLOB_DAT:
+    case R_PPC_ADDR32:
+    case R_PPC_RELATIVE:
+      *reloc_addr = finaladdr;
+      break;
+
+    case R_PPC_ADDR24:
+      *reloc_addr = *reloc_addr & 0xfc000003 | finaladdr & 0x3fffffc;
+      break;
+
+    case R_PPC_REL14_BRTAKEN:
+    case R_PPC_REL14_BRNTAKEN:
+    case R_PPC_REL14:
+      {
+	Elf32_Sword delta = finaladdr - (Elf32_Word) (char *) reloc_addr;
+	*reloc_addr = *reloc_addr & 0xffdf0003 | delta & 0xfffc;
+	if (rinfo == R_PPC_REL14_BRTAKEN && delta >= 0 ||
+	    rinfo == R_PPC_REL14_BRNTAKEN && delta < 0)
+	  *reloc_addr |= 0x00200000;
+      }
+      break;
+
+    case R_PPC_COPY:
+      {
+	/* Can't use memcpy (because we can't call any functions here).  */
+	int i;
+	for (i = 0; i < sym->st_size; ++i)
+	  ((unsigned char *) reloc_addr)[i] =
+	    ((unsigned char *)finaladdr)[i];
+      }
+      break;
+
+    case R_PPC_REL32:
+      *reloc_addr = finaladdr - (Elf32_Word) (char *) reloc_addr;
+      break;
+
+    case R_PPC_JMP_SLOT:
+      if (finaladdr <= 0x01fffffc || finaladdr >= 0xfe000000)
+	*reloc_addr = OPCODE_BA (finaladdr);
+      else
+	{
+	  Elf32_Sword delta = finaladdr - (Elf32_Word) (char *) reloc_addr;
+	  if (delta <= 0x01fffffc && delta >= 0xfe000000)
+	    *reloc_addr = OPCODE_B (delta);
+	  else
+	    {
+	      Elf32_Word *plt =
+		(Elf32_Word *) ((char *) map->l_addr
+				+ map->l_info[DT_PLTGOT]->d_un.d_val);
+	      Elf32_Word index =((reloc_addr - plt - PLT_INITIAL_ENTRY_WORDS)
+				 / 2);
+	      int num_plt_entries = (map->l_info[DT_PLTRELSZ]->d_un.d_val
+				     / sizeof (Elf32_Rela));
+	      int rel_offset_words = (PLT_INITIAL_ENTRY_WORDS
+				      + num_plt_entries * 2);
+
+	      if (index >= (1 << 13))
+		{
+		  /* Indexes greater than or equal to 2^13 have 4
+		     words available instead of two.  */
+		  plt[index * 2 + PLT_INITIAL_ENTRY_WORDS] =
+		    OPCODE_LI (11, finaladdr);
+		  plt[index * 2 + 1 + PLT_INITIAL_ENTRY_WORDS] =
+		    OPCODE_ADDIS (11, 11, finaladdr + 0x8000 >> 16);
+		  plt[index * 2 + 2 + PLT_INITIAL_ENTRY_WORDS] =
+		    OPCODE_MTCTR (11);
+		  plt[index * 2 + 2 + PLT_INITIAL_ENTRY_WORDS] =
+		    OPCODE_BCTR ();
+		}
+	      else
+		{
+		  plt[index * 2 + PLT_INITIAL_ENTRY_WORDS] =
+		    OPCODE_LI (11, index * 4);
+		  plt[index * 2 + 1 + PLT_INITIAL_ENTRY_WORDS] =
+		    OPCODE_B(-(4 * (index * 2 + 1 + PLT_INITIAL_ENTRY_WORDS
+				    + PLT_LONGBRANCH_ENTRY_WORDS)));
+		  plt[index + rel_offset_words] = finaladdr;
+		}
+	    }
+	}
+      break;
+
+    default:
+      assert (! "unexpected dynamic reloc type");
+    }
+}
+
+#define ELF_MACHINE_NO_REL 1
+
+#endif
+
+/* Nonzero iff TYPE describes relocation of a PLT entry, so
+   PLT entries should not be allowed to define the value.  */
+#define elf_machine_pltrel_p(type) ((type) == R_PPC_JMP_SLOT)
+
+/* 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.  */
+
+/* This code does not presently work if there are more than 2^13 PLT
+   entries. */
+static inline void
+elf_machine_runtime_setup (struct link_map *map, int lazy)
+{
+  Elf32_Word *plt;
+  int i;
+  Elf32_Word num_plt_entries;
+  Elf32_Word rel_offset_words;
+  extern void _dl_runtime_resolve (void);
+
+  if (map->l_info[DT_JMPREL])
+    {
+      /* Fill in the PLT. Its initial contents are directed to a
+	 function earlier in the PLT which arranges for the dynamic
+	 linker to be called back.  */
+      plt = (Elf32_Word *) ((char *) map->l_addr +
+			    map->l_info[DT_PLTGOT]->d_un.d_val);
+      num_plt_entries = (map->l_info[DT_PLTRELSZ]->d_un.d_val
+			 / sizeof (Elf32_Rela));
+      rel_offset_words = PLT_INITIAL_ENTRY_WORDS + num_plt_entries * 2;
+
+      if (lazy)
+	for (i = 0; i < num_plt_entries; i++)
+	  if (i >= (1 << 13))
+	  {
+	    plt[i * 2 + (i - (1 << 13)) * 2 + PLT_INITIAL_ENTRY_WORDS] =
+	      OPCODE_LI (11, i * 4);
+	    plt[i * 2 + (i - (1 << 13)) * 2 + 1 + PLT_INITIAL_ENTRY_WORDS] =
+	      OPCODE_ADDIS (11, 11, i * 4 + 0x8000 >> 16);
+	    plt[i * 2 + (i - (1 << 13)) * 2 + 2 + PLT_INITIAL_ENTRY_WORDS] =
+	      OPCODE_B (-(4 * ( i * 2 + 1 + PLT_INITIAL_ENTRY_WORDS)));
+	  }
+	  else
+	  {
+	    plt[i * 2 + PLT_INITIAL_ENTRY_WORDS] = OPCODE_LI (11, i * 4);
+	    plt[i * 2 + 1 + PLT_INITIAL_ENTRY_WORDS] =
+	      OPCODE_B (-(4 * (i * 2 + 1 + PLT_INITIAL_ENTRY_WORDS)));
+	  }
+
+      /* Multiply index of entry, by 0xC.  */
+      plt[0] = OPCODE_SLWI (12, 11, 1);
+      plt[1] = OPCODE_ADD (11, 12, 11);
+      if ((Elf32_Word) (char *) _dl_runtime_resolve <= 0x01fffffc ||
+	  (Elf32_Word) (char *) _dl_runtime_resolve >= 0xfe000000)
+	{
+	  plt[2] = OPCODE_LI (12, (Elf32_Word) (char *) map);
+	  plt[3] = OPCODE_ADDIS (12, 12,
+				 (Elf32_Word) (char *) map + 0x8000 >> 16);
+	  plt[4] = OPCODE_BA ((Elf32_Word) (char *) _dl_runtime_resolve);
+	}
+      else
+	{
+	  plt[2] = OPCODE_LI (12, (Elf32_Word) (char *) _dl_runtime_resolve);
+	  plt[3] = OPCODE_ADDIS (12, 12, 0x8000 +
+				 ((Elf32_Word) (char *) _dl_runtime_resolve
+				  >> 16));
+	  plt[4] = OPCODE_MTCTR (12);
+	  plt[5] = OPCODE_LI (12, (Elf32_Word) (char *) map);
+	  plt[6] = OPCODE_ADDIS (12, 12, ((Elf32_Word) (char *) map
+					  + 0x8000 >> 16));
+	  plt[7] = OPCODE_BCTR ();
+	}
+      plt[PLT_LONGBRANCH_ENTRY_WORDS] =
+	OPCODE_ADDIS (11, 11, ((Elf32_Word) (char*) (plt+rel_offset_words)
+			       + 0x8000 >> 16));
+      plt[PLT_LONGBRANCH_ENTRY_WORDS+1] =
+	OPCODE_LWZ (11, (Elf32_Word) (char*) (plt + rel_offset_words), 11);
+      plt[PLT_LONGBRANCH_ENTRY_WORDS+2] = OPCODE_MTCTR (11);
+      plt[PLT_LONGBRANCH_ENTRY_WORDS+3] = OPCODE_BCTR ();
+    }
+}
+
+static inline void
+elf_machine_lazy_rel (struct link_map *map, const Elf32_Rela *reloc)
+{
+  if (ELF32_R_TYPE (reloc->r_info) != R_PPC_JMP_SLOT)
+      assert (! "unexpected PLT reloc type");
+
+  /* elf_machine_runtime_setup handles this. */
+}
+
+/* The PLT uses Elf32_Rela relocs.  */
+#define elf_machine_relplt elf_machine_rela
+
+  /* This code is used in dl-runtime.c to call the `fixup' function
+     and then redirect to the address it returns.  */
+#define ELF_MACHINE_RUNTIME_TRAMPOLINE asm ("\
+	.section \".text\"
+	.globl _dl_runtime_resolve
+_dl_runtime_resolve:
+	stwu 1,-48(1)
+	mflr 0
+	stw 3,16(1)
+	stw 4,20(1)
+	stw 0,52(1)
+	stw 5,24(1)
+	mfcr 0
+	stw 6,28(1)
+	stw 7,32(1)
+	stw 8,36(1)
+	stw 9,40(1)
+	stw 10,44(1)
+	stw 0,12(1)
+	mr 3,12
+	mr 4,11
+	bl fixup
+	mtctr 3
+	lwz 0,52(1)
+	lwz 10,44(1)
+	lwz 9,40(1)
+	mtlr 0
+	lwz 0,12(1)
+	lwz 8,36(1)
+	lwz 7,32(1)
+	lwz 6,28(1)
+	mtcrf 0xFF,0
+	lwz 5,24(1)
+	lwz 4,20(1)
+	lwz 3,16(1)
+	addi 1,1,48
+	bctr
+");
+
+/* 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.  */
+
+/* FIXME! We don't make provision for calling _dl_fini,
+   because Linux/PPC is somewhat broken. */
+#define RTLD_START \
+asm ("\
+	.text
+        .align 2
+	.globl _start
+        .type _start,@function
+_start:
+ # We start with the following on the stack, from top:
+ # argc (4 bytes)
+ # arguments for program (terminated by NULL)
+ # environment variables (terminated by NULL)
+ # arguments for the program loader
+
+ # Call _dl_start with one parameter pointing at argc
+        mr 3,1
+ #  (we have to frob the stack pointer a bit to allow room for
+ #   _dl_start to save the link register)
+        li 4,0
+        addi 1,1,-16
+        stw 4,0(1)
+        bl _dl_start@local
+
+ # Now, we do our main work of calling initialisation procedures.
+ # The ELF ABI doesn't say anything about parameters for these,
+ # so we just pass argc, argv, and the environment.
+ # Changing these is strongly discouraged (not least because argc is
+ # passed by value!).
+
+ #  put our GOT pointer in r31
+        bl _GLOBAL_OFFSET_TABLE_-4@local
+        mflr 31
+ #  the address of _start in r30
+        mr 30,3
+ #  &_dl_argc in 29, &_dl_argv in 27, and _dl_default_scope in 28
+	lwz 28,_dl_default_scope@got(31)
+	lwz 29,_dl_argc@got(31)
+	lwz 27,_dl_argv@got(31)
+0:
+ #  call initfunc = _dl_init_next(_dl_default_scope[2])
+	lwz 3,8(28)
+	bl _dl_init_next@plt
+ # if initfunc is NULL, we exit the loop
+	mr. 0,3
+	beq 1f
+ # call initfunc(_dl_argc, _dl_argv, _dl_argv+_dl_argc+1)
+	mtlr 0
+	lwz 3,0(29)
+	lwz 4,0(27)
+	slwi 5,3,2
+	add 5,4,5
+	addi 5,5,4
+	blrl
+ # and loop.
+	b 0b
+1:
+ # Now, to conform to the ELF ABI, we have to:
+ # pass argv (actually _dl_argv) in r4
+	lwz 4,0(27)
+ # pass argc (actually _dl_argc) in r3
+	lwz 3,0(29)
+ # pass envp (actually _dl_argv+_dl_argc+1) in r5
+	slwi 5,3,2
+	add 5,4,5
+	addi 5,5,4
+ # pass the auxilary vector in r6. This is passed just after _envp.
+	addi 6,5,-4
+2:	lwzu 0,4(6)
+	cmpwi 1,0,0
+	bne 2b
+	addi 6,6,4
+ # pass a termination function pointer (in this case _dl_fini) in r7
+	lwz 7,_dl_fini@got(31)
+ # now, call the start function in r30...
+	mtctr 30
+ # pass the stack pointer in r1 (so far so good), pointing to a NULL value
+ # (this lets our startup code distinguish between a program linked statically,
+ # which linux will call with argc on top of the stack which will hopefully
+ # never be zero, and a dynamically linked program which will always have
+ # a NULL on the top of the stack).
+ # Take the opportunity to clear LR, so anyone who accidentally returns
+ # from _start gets SEGV.
+	li 0,0
+	stw 0,0(1)
+	mtlr 0
+ # and also clear _dl_starting_up
+	lwz 26,_dl_starting_up@got(31)
+	stw 0,0(3)
+ # go do it!
+	bctr
+");
+
+#define ELF_PREFERRED_ADDRESS_DATA static ElfW(Addr) _dl_preferred_address = 0;
+#define ELF_PREFERRED_ADDRESS(loader, maplength, mapstartpref) \
+( {									      \
+   ElfW(Addr) prefd;							      \
+   if (mapstartpref != 0 && _dl_preferred_address == 0)			      \
+     _dl_preferred_address = mapstartpref;				      \
+   if (mapstartpref != 0)						      \
+     prefd = mapstartpref;						      \
+   else if (_dl_preferred_address < maplength + 0x50000)		      \
+     prefd = 0;								      \
+   else									      \
+     prefd = _dl_preferred_address =					      \
+	  (_dl_preferred_address - maplength - 0x10000) &		      \
+           ~(_dl_pagesize - 1);						      \
+   prefd;								      \
+} )
+#define ELF_FIXED_ADDRESS(loader, mapstart) \
+( {									      \
+   if (mapstart != 0 && _dl_preferred_address == 0)			      \
+     _dl_preferred_address = mapstart;					      \
+} )
+
+#define ELF_FIXUP_RETURNS_ADDRESS 1