Make it possible to use the (modified) 0.9.24 ldso code. This is a

temporary work around for my openwrt stuff since the current (.26+)
code still isn't working in some cases... for me at least.

2 files changed, 11873 insertions, 0 deletions

diff --git a/make/uclibc.mk b/make/uclibc.mk
index 22db81341..ff857aa49 100644
--- a/make/uclibc.mk
+++ b/make/uclibc.mk
@@ -44,6 +44,9 @@ endif
 	#(cd $(BUILD_DIR) ; ln -s $(DL_DIR)/uClibc)
 	#-mkdir $(UCLIBC_DIR)
 	#(cd $(DL_DIR)/uClibc && tar cf - .) | (cd $(UCLIBC_DIR) && tar xvfp - )
+ifeq ($(strip $(USE_UCLIBC_LDSO_0_9_24)),true)
+	$(SOURCE_DIR)/patch-kernel.sh $(UCLIBC_DIR) $(SOURCE_DIR) uClibc-ldso-0.9.24.patch
+endif
 	touch $(UCLIBC_DIR)/.unpacked
 
 $(UCLIBC_DIR)/.configured: $(UCLIBC_DIR)/.unpacked $(LINUX_DIR)/.configured
@@ -91,6 +94,15 @@ $(UCLIBC_DIR)/lib/libc.a: $(UCLIBC_DIR)/.configured $(LIBFLOAT_TARGET)
 		RUNTIME_PREFIX=/ \
 		HOSTCC="$(HOSTCC)" \
 		all
+ifeq ($(strip $(USE_UCLIBC_LDSO_0_9_24)),true)
+	#rm -rf $(UCLIBC_DIR)/ld-uClibc* $(UCLIBC_DIR)/libdl*
+	$(MAKE) -C $(UCLIBC_DIR)/ldso-0.9.24 \
+		PREFIX= \
+		DEVEL_PREFIX=$(REAL_GNU_TARGET_NAME)/ \
+		RUNTIME_PREFIX=/ \
+		HOSTCC="$(HOSTCC)" \
+		all shared
+endif
 
 $(STAGING_DIR)/$(REAL_GNU_TARGET_NAME)/lib/libc.a: $(UCLIBC_DIR)/lib/libc.a
 	$(MAKE) -C $(UCLIBC_DIR) \
diff --git a/sources/uClibc-ldso-0.9.24.patch b/sources/uClibc-ldso-0.9.24.patch
new file mode 100644
index 000000000..ee65aa193
--- /dev/null
+++ b/sources/uClibc-ldso-0.9.24.patch
@@ -0,0 +1,11861 @@
+diff -urN uClibc/ldso-0.9.24/COPYRIGHT uClibc.ldso.24/ldso-0.9.24/COPYRIGHT
+--- uClibc/ldso-0.9.24/COPYRIGHT	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/COPYRIGHT	2001-04-23 12:43:53.000000000 -0500
+@@ -0,0 +1,49 @@
++/*
++ * Copyright (c) 1994-2000 Eric Youngdale, Peter MacDonald, David Engel,
++ * Hongjiu Lu and Mitch D'Souza
++ *
++ * All rights reserved.
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions
++ * are met:
++ * 1. Redistributions of source code must retain the above copyright
++ *    notice, this list of conditions and the following disclaimer.
++ * 2. The name of the above contributors may not be
++ *    used to endorse or promote products derived from this software
++ *    without specific prior written permission.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND
++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ * ARE DISCLAIMED.  IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE
++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
++ * SUCH DAMAGE.
++ */
++
++/* Notice of general intent:
++ *
++ * The linux operating system generally contains large amounts of code
++ * that fall under the GNU General Public License, or GPL for short.
++ * This file contains source code that by it's very nature would always
++ * be linked with an application program, and because of this a GPL
++ * type of copyright on this file would place restrictions upon the
++ * distribution of binary-only commercial software.  Since the goal of
++ * the Linux project as a whole is not to discourage the development and
++ * distribution of commercial software for Linux, this file has been
++ * placed under a more relaxed BSD-style of copyright.
++ *
++ * It is the general understanding of the above contributors that a
++ * program executable linked to a library containing code that falls
++ * under the GPL or GLPL style of license is not subject to the terms of
++ * the GPL or GLPL license if the program executable(s) that are supplied
++ * are linked to a shared library form of the GPL or GLPL library, and as
++ * long as the form of the shared library is such that it is possible for
++ * the end user to modify and rebuild the library and use it in
++ * conjunction with the program executable.
++ */
+diff -urN uClibc/ldso-0.9.24/Makefile uClibc.ldso.24/ldso-0.9.24/Makefile
+--- uClibc/ldso-0.9.24/Makefile	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/Makefile	2003-11-06 16:38:45.000000000 -0600
+@@ -0,0 +1,52 @@
++# Makefile for uClibc
++#
++# Copyright (C) 2000,2001 Erik Andersen <andersen@uclibc.org>
++#
++# This program 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.
++#
++# 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 Library General Public License for more
++# details.
++#
++# You should have received a copy of the GNU Library 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
++#
++# Derived in part from the Linux-8086 C library, the GNU C Library, and several
++# other sundry sources.  Files within this library are copyright by their
++# respective copyright holders.
++
++TOPDIR=../
++include $(TOPDIR)Rules.mak
++
++ALL_SUBDIRS = ldso libdl
++
++
++all: headers
++ifeq ($(strip $(BUILD_UCLIBC_LDSO)),y)
++	$(MAKE) -C ldso;
++else
++	echo "Not building ld-uClibc"
++endif
++
++shared:
++ifeq ($(strip $(BUILD_UCLIBC_LDSO)),y)
++	$(MAKE) -C libdl;
++else
++	echo "Not building libdl"
++endif
++
++headers:
++	$(LN) -fs $(TOPDIR)../include/elf.h include/
++	$(LN) -fs ../ldso/$(TARGET_ARCH)/boot1_arch.h include/
++	$(LN) -fs ../ldso/$(TARGET_ARCH)/ld_syscalls.h include/
++	$(LN) -fs ../ldso/$(TARGET_ARCH)/ld_sysdep.h include/
++
++clean:
++	set -e ; for d in $(ALL_SUBDIRS) ; do $(MAKE) -C $$d $@ ; done
++	-find . -name '*~' | xargs $(RM)
++	$(RM) include/elf.h include/boot1_arch.h include/ld_syscalls.h include/ld_sysdep.h
+diff -urN uClibc/ldso-0.9.24/README uClibc.ldso.24/ldso-0.9.24/README
+--- uClibc/ldso-0.9.24/README	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/README	2001-05-31 16:23:20.000000000 -0500
+@@ -0,0 +1,841 @@
++
++Apr 20, 2001 -- Manuel Novoa III
++
++Inital port for uClibc from debian ld.so_1.9.11-9.tar.gz.
++
++Removed a.out support.
++
++****************** original ld.so.lsm file **************************
++Begin3
++Title:          Linux shared, dynamic linker and utilities.
++Version:        1.9.11
++Entered-date:   01MAY99
++Description:    This package contains ld.so, ld-linux.so, ldconfig,
++		ldd and libdl.
++Keywords:       dynamic linker, shared library, ld.so, ld-linux.so,
++		ldconfig, ldd, libdl
++Author:         david@ods.com (David Engel)
++Maintained-by:  david@ods.com (David Engel)
++Primary-site:   tsx-11.mit.edu /pub/linux/packages/GCC
++		ld.so-1.9.11.tar.gz
++Alternate-site: sunsite.unc.edu /pub/Linux/GCC
++		ld.so-1.9.11.tar.gz
++Platform:       Linux 2.0.0 or later.
++Copying-policy: Copyrighted but freely distributable.
++End
++*********************************************************************
++                   Original README starts here
++*********************************************************************
++
++This package contains my ELF dynamic linkers (ld-linux.so.1), dynamic
++linker library (libdl.so.1) and utilities (ldconfig and ldd) for Linux.
++
++You need Linux kernel 2.0.0 or later with ELF support compiled in
++(i.e. not loaded as a module) to use this package.
++
++The dynamic linker is used to bootstrap programs and load shared
++libraries at startup.  The dynamic linker library is used to
++dynamically load shared libraries after a program is running.
++Ldconfig is used to automatically update the symbolic links to shared
++libraries and build the cache file used by the dynamic linker.  Ldd is
++used to list the shared libraries used by a program.
++
++Please see the included manual pages for further details.
++
++To install, simply run "sh instldso.sh" as root.  Ready-to-go versions
++of all end-products are provided so nothing should need to be compiled
++or linked.  If you are still using libc5 as your primary development
++library, you should use the "--devfiles" option when running
++instldso.sh to install the file needed to compile with libdl.
++
++ELF versions of gcc, binutils and libc are now required to compile
++everything, including the old, unsupported, a.out dynamic linker.
++Finally, an optimization level of O2 or higher must be used to compile
++ld-linux.so and libdl.so due the use of inline functions.
++
++Notable contributors to this package include Eric Youngdale, Peter
++MacDonald, Hongjiu Lu, Linus Torvalds, Lars Wirzenius, Mitch D'Souza,
++Rik Faith, Andreas Schwab and Adam Richter (not necessarily in that
++order).
++
++###################### IMPORTANT NOTICES #############################
++
++A.OUT SUPPORT:
++
++As of ld.so-1.9.0, the old, a.out dynamic loader is no longer 
++officially supported.  The code is still included and built, but I 
++make no promises that it will work.  I will accept patches for it, 
++but they will not be tested by me.
++
++GLIBC (AKA LIBC6) SUPPORT:
++
++As of ld.so-1.9.0, the main focus of this package is to ease the
++transition to libc6.  No significant, new features are expected to be
++added.  If you need new features, switch to libc6.
++
++Except for libpthread.so, the sonames of the core libraries provided
++with libc6 have been chosen so they do not conflict with those
++provided by libc5 and ld.so.  However, the current plan is not use
++new, nonconflicting sonames for other libraries such as ncurses and
++X11.  This presents two problems.  First, libraries using the same
++soname for both libc5 and libc6 can not be placed in the same
++directory.  Second, the dynamic linkers need to make sure not to load
++a library for the wrong version of libc.
++
++The first problem is easy.  Just move the old, libc5-based libraries
++to new directories (e.g. /lib/libc5-compat, /usr/lib/libc5-compat,
++etc.) and add those directories to /etc/ld.so.conf.  Then install the
++new, libc6-based versions in the standard places.
++
++The second problem is more difficult.  Ideally, the dynamic linkers
++would be changed to perform a complete dependency analysis on every
++library to be loaded to make sure the wrong versions aren't used.
++This approach doesn't seem worth the added complexity, especially
++since we now have symbol versioning for ELF libraries.  Instead a
++simpler approach will be used, at least initially.
++
++Ldconfig has been modified to perform a (currently simple) dependency
++analysis on libraries and to store an indication in /etc/ld.so.cache
++of whether a library is for libc5, libc6 or an unknown libc.  The
++dynamic linkers then only need to make a simple check at run-time to
++make sure they don't load the wrong version of a library.
++
++The dynamic linker for libc5 provided in this package, has already
++been modified to use the new information in /etc/ld.so.cache.  For
++glibc versions 2.0.1 and earlier, the dynamic linker for libc6 needs
++the patch contained in glibc.patch.  You should apply the patch and
++rebuild glibc before using the new ldconfig.
++
++As stated above, the dependency analysis currently done by ldconfig is
++rather simple.  Basically, it looks for the sonames used by the
++various versions of libc, libm and libdl.  For any approach using a
++dependency analysis such as this to work, it is very important that
++shared libraries be built with complete dependency information.  This
++can be done by using the appropriate -l options when running 'gcc
++-shared'.  For example, when building libfoo.so which depends on libc
++and libbar, you should add -lbar and -lc gcc command line.
++
++######################################################################
++
++Changes in version 1.9.11:
++
++	Fixed a bug in ld-linux.so where a reference to an
++	undefined symbol could cause a segfault.
++
++	Added a clarification for LD_PRELOAD to the ld.so manual 
++	page and added a symlink for ld-linux.so (Bug#33123).
++
++	Don't install ldd for Debian except for the m68k arch
++	because glibc 2.1 now includes it (Bug#35458).
++
++Changes in version 1.9.10:
++
++	Changed ldconfig to issue a warning and not overwrite a
++	regular file with a symlink (Bug#30859).
++
++	Changed Debian packaging to conflict with and replace the
++	ldconfig package (Bug#29398).
++
++Changes in version 1.9.9:
++
++	Changed ld-linux.so and libdl.so to match glibc by not
++	allowing user preloads of system libraries into setu/gid
++	binaries unless the library itself is setuid.
++
++	Fixed problems in ld-linux.so on the sparc architecture
++	(Juan Cespedes).
++
++Changes in version 1.9.8:
++
++	Changed ldconfig to allow the expected type for all
++	libraries in a directory to be optionally specified
++	(Mark Phillips).  See the ldconfig man page.
++
++	Changed ldconfig to use the same type names used in the
++	change above when the -p option is used.
++
++Changes in version 1.9.7:
++
++	Changed ldd for m68k to use /lib/ld.so.1 instead of 
++	/lib/ld-linux.so.2.
++
++	Added support for dladdr to libdl.so (Eduard Gode).
++
++	Fixed a small memory leak in libdl.so (Richard Garnish).
++
++	Fixed a bug in ldconfig when the -l option was used on a
++	filename without a '/' in it.
++
++	Updated the man pages (Bug#6404, Bug#9721, Bug#10652, 
++	Bug#13494 and Bug#14127).  They could still use some work.
++
++	No longer install the info page since it's way out of date.
++
++	Fixed minor Debian packaging problems (Bug#13160, 
++	Bug#15577 and Bug#19345).
++
++Changes in version 1.9.6:
++
++	Changed ldd to not use the glibc dynamic linker when run
++	on a libc5-based shared library.
++
++	Added a -q option to ldconfig which causes warnings not
++	to be printed (Bob Tinsley).
++
++	Dropped support for the Debian libdl1-dev package.
++
++	Changed ld-linux.so to be compilable with gcc 2.8.0 (Sven 
++	Verdoolaege)
++
++Changes in version 1.9.5:
++
++	Fixed a bug in ldd where ld-linux.so.2 was not called
++	correctly when run on shared libraries.
++
++	Fixed a problem in the previous version where some
++	Makefiles were not architecture independent.
++
++Changes in version 1.9.4:
++
++	Fixed a bug in ld.so introduced in the previous version
++	which broke preloads.
++
++	Turned a.out support back on by default, at least for the
++	time being.  There are no promises to keep it.
++
++Changes in version 1.9.3:
++
++	Fixed buffer overflow bugs in ld-linux.so and ld.so.
++
++	Changed the README file a little to clarify a couple of
++	things.
++
++	Changed ldconfig to chroot to the specified directory when
++	the new -r option is used (Bob Tinsley).
++
++Changes in version 1.9.2:
++
++	Removed /usr/local/lib from the default /etc/ld.so.conf
++	for Debian (Bug#8181).
++
++	Changed ldconfig to be 64-bit clean (H.J. Lu).
++
++Changes in version 1.9.1:
++
++	Changed ldconfig to try to determine which libc a
++	library is for even if it doesn't have an soname.
++
++	Fixed a bug in ldconfig where an older library using
++	the glibc naming convention would be used instead of
++	a newer library.
++
++	Changed to ld-linux.so and libdl.so to not require the 
++	libc5 headers in order to compile.
++
++	Changed ldconfig and ldd to be compilable with either
++	libc5 or libc6.
++
++Changes in version 1.9.0:
++
++	Changed to not build the old, a.out dynamic loader by
++	default.
++
++	Changed instldso.sh to require the --force option to
++	make sure users read the README file.
++
++	Changed instldso.sh to not install the libdl.so
++	development files unless the --devfiles option is used.
++
++	Changed instldso.sh to not strip binaries and libraries
++	if the --no-strip option is used.
++
++	Changed the Debian packaging to put the development files 
++	which conflict with glibc in a new libdl1-dev package.
++
++	Changed ldd to use the glibc dynamic linker, if it is
++	available, when run on a shared library.
++
++	Changed ld-linux.so to print the load addresses of
++	libraries, ala glibc, when run by ldd.
++
++	Changed ld-linux.so to allow the libraries listed in 
++	LD_PRELOAD to be separated by white space in addition to 
++	colons.
++
++	Changed ld-linux.so to load the libraries listed in 
++	LD_PRELOAD for setu/gid programs as long as they can be 
++	loaded securely.
++
++	Changed ldconfig to update the symlinks for the dynamic
++	linkers.
++
++	Changed ldconfig to try to determine if an ELF library is
++	intended for libc5 or libc6 and save the infomation in the
++	cache.  The mechanism used is rather simplistic and may
++	need to be enhanced.
++
++	Changed ldconfig to print the type of ELF library when
++	printing the cache.
++
++	Changed ld-linux.so to only load ELF shared libraries for
++	use with libc5 or an unknown libc.
++
++Changes in version 1.8.10:
++
++	Fixed a bug in ldconfig where a symlink could be used
++	instead of a regular file.
++
++	Fixed a Debian packaging problem for the sparc 
++	architecture.
++
++Changes in version 1.8.9:
++
++	Changed ldconfig to only cache the symlinks it creates.
++	This make the behavior of the dynamic linkers consistent
++	with how they would behave if a cache was not used.
++
++	Changed ldconfig to cache the symlinks that it finds but
++	use the name of the symlink as the soname instead of the 
++	actual soname.
++
++Changes in version 1.8.8:
++
++	Minor documentation updates to reflect recent changes.
++
++	Changed ld.so and ld-linux.so to perform more complete
++	validation on ld.so.cache before using it.
++
++	Changed ldconfig to accept libraries with inconsistent
++	sonames since glibc is going to use them.  A warning is
++	still printed in debug mode.
++
++	Changed the install script to not strip _dl_debug_state
++	from ld-linux.so since gdb needs it.
++
++	More sparc fixes (Derrick Brashear).
++
++	Changed ldconfig to not issue a warning when a linker
++	script disguised as a shared library is found.
++
++	Fixed a bug in ld-linux.so where some registers were 
++	not preserved on the first call to a function causing 
++	problems for non-C-like languages (Tim Renouf).
++
++	Fixed a bug in ld-linux.so where global variables were 
++	not always mapped correctly across dynamically loaded 
++	libraries (Mikihiko Nakao).
++
++	Converted to new Debian source packaging format (Shaya
++	Potter).
++
++Changes in version 1.8.6/7:
++
++	Never released as some unofficial patches used these
++	version numbers.
++
++Changes in version 1.8.5:
++
++	Fixed a bug in ld.so introduced in the previous changes.
++
++Changes in version 1.8.4:
++
++	Changed ldconfig to completely ignore symbolic links.
++
++	Changed ldconfig to issue the warning concerning an
++	inconsistent soname in non-verbose mode.
++
++	Changed ld-linux.so back to not keep ld.so.cache mapped
++	at all times.
++
++	Changed Debian packaging to compress man pages, strip all
++	binaries (Bug#5125) and include a shlibs file.
++
++Changes in version 1.8.3:
++
++	Changed ld-linux.so to process LD_PRELOAD before
++	/etc/ld.so.preload.
++
++	Fixed a Debian packaging problem where libdl might not
++	be available if other packages were upgraded at the same
++	time (Debian Bug#4728).
++
++	Changed ldd to always exit with status 1 if any errors
++	occur (Debian Bug#4188).
++
++	Fixed some minor problems in instldso.sh (Mike Castle and
++	Wolfgang Franke).
++
++	Changed ldconfig to issue a warning in verbose mode when 
++	skipping a library because the soname doesn't match.
++
++	More sparc fixes (Miguel de Icaza).
++
++	Don't link with -N when building ld.so (Alan Modra).
++
++	Changed ld-linux.so to better support position-dependant
++	libraries (NIIBE Yutaka).
++
++Changes in version 1.8.2:
++
++	Added a texinfo file for ld.so and libdl (Michael 
++	Deutschmann).
++
++	Minor sparc and installation changes (Elliot Lee).
++
++	Added multiple architecture support for Debian (Leland
++	Lucius).
++
++	Changed libdl to better support RTLD_NEXT (Eric 
++	Youngdale).  Note: the exact meaning of ETLD_NEXT is 
++	still not clear in all cases.
++
++	Removed some libc dependencies from libdl.  Still need
++	to remove malloc and free.
++
++Changes in version 1.8.1:
++
++	Changed ld.so to be compiled as ELF.  This also means
++	that ELF support is now required.  A.out support is 
++	still optional.
++
++	Changed ld-linux.so and libdl.so to use the rpath in the 
++	executable instead of in the invoking shared library.
++
++	More m68k fixes (Andreas Schwab).
++
++	Various sparc fixes (Miguel de Icaza).
++
++	Changed ldcnnfig to ignore libraries ending in '~'.
++
++	Changed ldconfig to allow alternative conf and cache 
++	files to be specified on the command-line.
++
++	Changed libdl.so to work when dlsym is passed a NULL
++	handle pointer.
++
++Changes in version 1.8.0:
++
++	Changed ld-linux.so to be more liberal when checking to
++	see if a library is already loaded.  This should avoid
++	the duplicate loading problem for programs linkeed with
++	the -rpath option.
++
++	Various m68k fixes (Andreas Schwab).
++
++	Changed ld.so to only use LD_AOUT_LIBRARY_PATH and
++	LD_AOUT_PRELOAD and ld-linux.so to only use 
++	LD_LIBRARY_PATH and LD_PRELOAD.  LD_ELF_LIBRARY_PATH
++	and LD_ELF_PRELOAD are no longer supported.
++
++	Changed ld-linux.so to allow debugging of shared and
++	dynamically loaded libraries (H.J. Lu, Andreas Schwab).
++
++	Changed ld-linux.so to preload ELF shared libraries 
++	listed in /etc/ld.so.preload.  This allows secure 
++	preloads, even for setuid/setgid programs.
++
++	Changed ld-linux.so to keep ld.so.cache mapped at all
++	times.
++
++	Changed ldconfig to allow #-style comments in ld.so.conf.
++
++	Removed various compiler warnings (Richard Sladkey and
++	David Engel).
++
++	Changed ldd to work on ELF shared libraries.  This may
++	need a little more work.
++
++Changes in version 1.7.14:
++
++	Changed ldconfig to recognize ELF shared libraries
++	generated by post-2.6 versions of ld (Andreas Schwab).
++
++	Changed ldconfig to not remove stale links that do not
++	have a version number since they may be needed by ld.
++
++Changes in version 1.7.13:
++
++	Fixed a problem in ld-linux.so where a program linked
++	with a shared library that was not used could result in
++	a segmentation fault (H.J. Lu).
++
++Changes in version 1.7.12:
++
++	Fixed a problem in libdl.so where the wrong library
++	could be marked as global when RTLD_GLOBAL was used
++	(Lars Heete).
++
++	Installed dlfcn.h with libdl.so instead of requiring
++	it to be supplied with libc.
++
++	Removed support for libldso.a since it was nearly
++	impossible to use anyway.
++
++	Changed ldd to detect when the program being checked
++	exited abnormally.
++
++Changes in version 1.7.11:
++
++	Changed ld.so and ld-linux.so to delete all variations
++	of LD_PRELOAD and LD_LIBRARY_PATH for set[ug]id programs,
++	This makes it harder for broken set[ug]id programs to be
++	compromised.
++
++	Fixed a problem in libdl.so where dlsym would not accept
++	the handle returned from dlopen(0, *).
++
++Changes in version 1.7.10:
++
++	Changed ld-linux.so and libdl.so to support RTLD_GLOBAL
++	(Eric Youngdale).
++
++Changes in version 1.7.9:
++
++	Fixed a problem in ld-linux.so in detecting when the 
++	new user/group information is provided by the kernel.
++
++	Fixed a problem in ld-linux.so where a buffer could be
++	overflowed if a large number of libraries were loaded
++	(Thomas Moore).
++
++Changes in version 1.7.8:
++
++	Changed the Makefiles and install scripts to support 
++	a.out- and ELF-only configurations.
++
++	Changed ld-linux.so to use the user/group information
++	provided by linux 1.3.23+ instead of making syscalls
++	to get it.
++
++	Changed libdl.so to support RTLD_NEXT (Glenn Fowler).
++
++	Changed libdl.so to only execute the fini sections
++	instead of completely closing libraries at exit (Glenn
++	Fowler).
++
++	Changed ld.so and ld-linux.so to print the required
++	cache version when a mismatch is detected.
++
++	Changed ld-linux.so to not require on /dev/zero (Ralph
++	Loader).
++
++	Minor m68k cleanups (Andreas Schwab).
++
++Changes in version 1.7.7:
++
++	Fixed problems compiling with recent 1.3.x kernels.
++
++	Changed ld-linux.so to not use MAP_DENYWRITE until the
++	permission issue regarding it is resolved.
++
++Changes in version 1.7.6:
++
++	Fixed a bug in ld-linux.so dealing with a zero-length
++	LD_{ELF_}PRELOAD.
++
++	Changed ld.so and ld-linux.so to truncate all variations
++	of LD_PRELOAD and LD_LIBRARY_PATH for set[ug]id programs.
++
++Changes in version 1.7.5:
++
++	Changed ldconfig to recognize libraries without any
++	version number (eg. libXYZ.so).
++
++	Changed ldconfig to not generate a corrupt cache when
++	the disk is full or other write errors occur.
++
++	Changed ld-linux.so to map files with MAP_DENYWRITE to
++	keep them from being changed while the file is in use
++	(Rick Sladkey).
++
++	Changed libdl to not overwrite the scope pointer of a 
++	library if it was already loaded (H.J. Lu).
++
++	Changed ld-linux.so so gdb can be used on constructors
++	(Eric Youngdale).
++
++	Changed ldconfig to ignore ELF libraries where the soname
++	does not match the file name on the assumption that it is
++	a used at compile-time (eg. libcurses.so -> libncruses.so).
++
++Changes in version 1.7.4:
++
++	Changed ld-linux.so and libdl to use the appropriate
++	rpaths when searching for shared libraries (Eric
++	Youngdale).
++
++	Changed ld-linux.so to search rpath before using the
++	cache.  This more closely conforms to the IBCS standard.
++
++Changes in version 1.7.3:
++
++	Changed ld-linux.so to only print a library name the
++	first time it is loaded when run from ldd.
++
++	Fixed a bug in ldconfig where an invalid cache could be
++	generated if a directory was specified multiple times in
++	ld.so.conf.
++
++	Changed ld-linux.so so it will return the address of a
++	weak symbol when called from dlsym in libdl (Eric 
++	Youngdale.
++
++Changes in version 1.7.2:
++
++	Changed libdl.so again to fix the undefined foobar
++	problem.
++
++Changes in version 1.7.1:
++
++	Changed libdl so it will compile at optimization level
++	O3 or higher.
++
++	Changed ldconfig to always create the cache file with 
++	mode 644.
++
++	Changed ldconfig to not ingore valid symlinks.
++
++	Changed ldconfig to use the library name as the soname 
++	for ELF libraries that do not have an soname entry.
++
++	Changed ld-linux.so to print the actual, requested library
++	name at the time it is loaded instead of trying to figure
++	it out after the fact.
++
++Changes in version 1.7.0:
++
++	Changed ldconfig to read the actual soname from the image
++	for ELF libraries and make it available to ld-linux.so.  
++	The soname for DLL libraries is still determined by
++	truncating the minor numbers from the image file name.
++
++	Changed ldconfig to no longer support the undocumented
++	sort options.
++
++	Changed ld.so to require a valid cache to find libraries
++	in directories specified in ld.so.conf.  /usr/lib and /lib
++	are still searched as a last resort.  Ld-linux.so already
++	operated this way.
++
++	Fixed a bug in libldso.a where the arguments to
++	shared_loader were not parsed correctly (Wolfram Gloger).
++
++	Added support for RELA-style relocations under Linux/68k
++	(Andreas Schwab).
++
++	Changed ld-linux.so to only map the cache once for all
++	libraries instead of individually for each library.
++
++	Changed ld-linux.so continue searching the cache instead of
++	giving up when failing to load the first entry found.
++
++	Changed ld-linux.so to produce output similar to ld.so when
++	run from ldd or when errors occur.
++
++Changes in version 1.6.7:
++
++	Changed the install scripts to make sure that ld.so and
++	ld-linux.so are always usable.
++
++	Added support for Linux/Sparc (Eric Youngdale).
++
++	Added support for Linux/68k (Andreas Schwab).
++
++	Fixed various bugs in ld-linux.so dealing with closing
++	files, unmapping memory, dereferencing NULL pointers and 
++	printing library names (David Engel, Eric Youngdale and 
++	Andreas Schwab).
++
++	Replaced the manual page for libdl with a freely
++	distributable one (Adam Richter).
++
++	Fixed a bug in ld-linux.so where LD_LIBRARY_PATH and
++	LD_PRELOAD were not cleared for setuid/setgid programs.
++
++	Fixed a bug in libdl where dlsym would not return the
++	correct address of a symbol if it was redefined in another
++	library (Oleg Kibirev).
++
++	Changed ld-linux.so to use the following order to search 
++	for libraries:  LD_{ELF_}LIBRARY_PATH, ld.so.cache, rpath, 
++	/usr/lib and /lib.
++
++	Changed ld-linux.so to not needlessly allocate memory when
++	using ld.so.cache.
++
++Changes in version 1.6.6:
++
++	Changed ldconfig to not warn about removing stale links
++	unless the -v option is specified.
++
++	Added manual pages for libdl (from FreeBSD/Sun)
++
++	Fixed a bug in ld.so dealing with preloading of objects
++	generated by recent versions of ld (Mitch D'Souza).
++
++	Fixed bugs in ldd where some errors were either not
++	detected or not printed.
++
++	Fixed a bug in ld-linux.so where the trailing nul in a
++	library name was not being copied (Owen Taylor).
++
++Changes in version 1.6.5:
++
++	Changed ldconfig to remove stale symbolic links.
++
++	Added debug hooks in ld-linux.so and libdl.so to be used 
++	by a future version of gdb (Eric Youngdale).
++
++Changes in version 1.6.4:
++
++	Change ld-linux.so to print on stdout instead of stderr
++	when run from ldd.
++
++	Added support for Debian GNU/Linux packaging.
++
++Changes in version 1.6.3:
++
++	Fixed a bug in libdl when closing a library (H.J. Lu).
++
++Changes in version 1.6.2:
++
++	Changed the error message printed by ldd when a file is
++	not a.out or ELF.  It used to only list a.out formats.
++
++	Changed ldconfig to no longer cache and set up links for
++	ld-linux.so.
++
++	Changed ld-linux.so and libdl to not conflict with upcoming
++	changes in kernel header files.
++
++	Changed ld-linux.so to not print preloaded libraries.
++
++Changes in version 1.6.1:
++
++	Updated the installation script.
++
++	Changed ld.so and ld-linux.so to look for LD_AOUT_PRELOAD
++	and LD_ELF_PRELOAD, respectively, before LD_PRELOAD.
++
++	Changed ld.so and ld-linux.so to use LD_AOUT_LIBRARY_PATH
++	and LD_ELF_LIBRARY_PATH, respectively, instead of
++	AOUT_LD_LIBRARY_PATH and ELF_LD_LIBRARY_PATH.
++
++Changes in version 1.6.0:
++
++	Changed ldconfig to process libraries which do not have
++	a minor version or patch level number.
++
++	Incorporated ld-linux.so and libdl.so.
++
++	Changed ld.so and ld-linux.so to not miss entries in the
++	cache when the fully qualified library is requested.
++
++	Changed ldconfig to use stdout instead of stderr when
++	printing the cache.
++
++Changes in version 1.5.3:
++
++	LD_PRELOAD enhancements (Tristan Gigold).
++
++	LD_PRELOAD patch for linux-68k (Andreas Schwab).
++
++Changes in version 1.5.2:
++
++	More ELF changes (Mitch D'Souza).
++
++	Changed ldconfig to also update the link for ld-linux.so.
++
++Changes in version 1.5.1:
++
++	More ELF and LD_PRELOAD changes (Mitch D'Souza).
++
++Changes in version 1.5.0:
++
++	Chnaged all executables to QMAGIC (Mitch D'Souza and Rick
++	Sladkey).
++
++	Added preliminary support for ELF to ldd and ldconfig (Eric 
++	Youndale and H.J. Lu).
++
++	Added support for LD_PRELOAD to ld.so (Mitch D'Souza).
++
++	Removed the "advertising" clause from the copyright notices
++	in all source files.
++
++Changes in version 1.4.4:
++
++	Changed ldconfig to support QMAGIC libraries.
++
++	Fixed a bug in ld.so where some of the error messages had
++	transposed arguments.
++
++Changes in version 1.4.3:
++
++	Fixed an obscure bug in ld.so where an index was not being
++	incremented when a library was not found using the cache.
++
++Changes in version 1.4.2:
++
++	Changed ldconfig to issue a warning and continue instead
++	of an error and exiting when a link can't be updated.  
++	This is useful when some libraries are imported on read-
++	only file systems, such as an NFS mounted /usr.
++
++	Changed ld.so to be more robust in searching for libraries.
++	A library is not considered found unless it can actually be
++	loaded.  If a library is not found using the cache, the
++	standard directories are searched as in pre-cache versions.
++
++Changes in version 1.4.1:
++
++	Fixed minor Makefile problems.
++
++	Added support for linux-68k.
++
++	Fixed a bug in ld.so where libraries with absolute paths
++	were not handled correctly.
++
++	Changed ld.so to ignore the directory in the names of
++	shared libraries by default.  This allows older libraries
++	with absolute paths, such as the XView libraries, to take
++	advantage of the cache support.
++
++	Added a minimal usage message to ldconfig.
++
++Changes in version 1.4:
++
++	Fixed bug in ld.so where minor version numbers were not
++	reported correctly when a minor version incompatibility
++	was found.
++
++	Fixed bug in ldconfig where libraries with subversion
++	numbers greater than 9 were not compared correctly.
++
++	Added Mitch D'Souza's support for suppressing warning
++	messages from ld.so about minor version incompatibilities.
++
++	Added Mitch D'Souza's support for using a cache to speed
++	up searching for libraries in the standard directories.
++
++	Added Mitch D'Souza's support for a debugging version of
++	ld.so.  Link with -lldso if you think you are experiencing
++	dynamic linker problems.
++
++Changes in version 1.3:
++
++	Added support for libraries using absolute pathnames.  If I
++	had known that the XView libraries used them, I would have
++	added this earlier.
++
++	Fixed a bug handling old libraries using a pathname beginning
++	with '/' or '/lib/'.
++
++Changes in version 1.2a:
++
++	Fixed a minor bug in ldd which caused all files, specifically
++	scripts, to be recognized as binaries.  Thanks to Olaf Flebbe
++	for reporting it.
++
++David Engel
++david@sw.ods.com
+diff -urN uClibc/ldso-0.9.24/include/.cvsignore uClibc.ldso.24/ldso-0.9.24/include/.cvsignore
+--- uClibc/ldso-0.9.24/include/.cvsignore	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/include/.cvsignore	2003-08-19 01:05:30.000000000 -0500
+@@ -0,0 +1,4 @@
++elf.h
++ld_syscalls.h
++ld_sysdep.h
++boot1_arch.h
+diff -urN uClibc/ldso-0.9.24/include/dlfcn.h uClibc.ldso.24/ldso-0.9.24/include/dlfcn.h
+--- uClibc/ldso-0.9.24/include/dlfcn.h	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/include/dlfcn.h	2003-08-19 01:05:30.000000000 -0500
+@@ -0,0 +1,22 @@
++/* User functions for run-time dynamic loading.  libdl version */
++#ifndef	_DLFCN_H
++#define	_DLFCN_H 1
++
++#include <features.h>
++#include <bits/dlfcn.h>
++
++#define RTLD_NEXT	((void *) -1l)
++#define RTLD_DEFAULT	((void *) 0)
++
++/* Structure containing information about object searched using
++   `dladdr'.  */
++typedef struct
++{
++	__const char *dli_fname;	/* File name of defining object.  */
++	void *dli_fbase;		/* Load address of that object.  */
++	__const char *dli_sname;	/* Name of nearest symbol.  */
++	void *dli_saddr;		/* Exact value of nearest symbol.  */
++} Dl_info;
++
++
++#endif	/* dlfcn.h */
+diff -urN uClibc/ldso-0.9.24/include/ld_elf.h uClibc.ldso.24/ldso-0.9.24/include/ld_elf.h
+--- uClibc/ldso-0.9.24/include/ld_elf.h	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/include/ld_elf.h	2003-11-04 07:07:45.000000000 -0600
+@@ -0,0 +1,93 @@
++#ifndef LINUXELF_H
++#define LINUXELF_H
++
++#include <ld_sysdep.h> /* before elf.h to get ELF_USES_RELOCA right */
++#include <elf.h>
++#include <link.h>
++
++#ifdef DEBUG
++#  define LDSO_CONF  "../util/ld.so.conf"
++#  define LDSO_CACHE "../util/ld.so.cache"
++#  define LDSO_PRELOAD "../util/ld.so.preload"
++#else
++#  define LDSO_CONF  UCLIBC_RUNTIME_PREFIX "etc/ld.so.conf"
++#  define LDSO_CACHE UCLIBC_RUNTIME_PREFIX "etc/ld.so.cache"
++#  define LDSO_PRELOAD UCLIBC_RUNTIME_PREFIX "etc/ld.so.preload"
++#endif
++
++
++#define LIB_ANY	     -1
++#define LIB_DLL       0
++#define LIB_ELF       1
++#define LIB_ELF64     0x80
++#define LIB_ELF_LIBC5 2
++#define LIB_ELF_LIBC6 3
++#define LIB_ELF_LIBC0 4
++
++/* Forward declarations for stuff defined in ld_hash.h */
++struct dyn_elf;
++struct elf_resolve;
++
++
++/* Definitions and prototypes for cache stuff */
++#ifdef USE_CACHE
++extern int _dl_map_cache(void);
++extern int _dl_unmap_cache(void);
++
++#define LDSO_CACHE_MAGIC "ld.so-"
++#define LDSO_CACHE_MAGIC_LEN (sizeof LDSO_CACHE_MAGIC -1)
++#define LDSO_CACHE_VER "1.7.0"
++#define LDSO_CACHE_VER_LEN (sizeof LDSO_CACHE_VER -1)
++
++typedef struct {
++	char magic   [LDSO_CACHE_MAGIC_LEN];
++	char version [LDSO_CACHE_VER_LEN];
++	int nlibs;
++} header_t;
++
++typedef struct {
++	int flags;
++	int sooffset;
++	int liboffset;
++} libentry_t;
++
++#else
++static inline void _dl_map_cache(void) { }
++static inline void _dl_unmap_cache(void) { }
++#endif	
++
++
++/* Function prototypes for non-static stuff in readelflib1.c */
++int _dl_copy_fixups(struct dyn_elf * tpnt);
++extern int _dl_parse_copy_information(struct dyn_elf *rpnt,
++	unsigned long rel_addr, unsigned long rel_size, int type);
++extern void _dl_parse_lazy_relocation_information(struct elf_resolve *tpnt,
++	unsigned long rel_addr, unsigned long rel_size, int type);
++extern int _dl_parse_relocation_information(struct elf_resolve *tpnt,
++	unsigned long rel_addr, unsigned long rel_size, int type);
++extern struct elf_resolve * _dl_load_shared_library(int secure, 
++	struct dyn_elf **rpnt, struct elf_resolve *tpnt, char *full_libname);
++extern struct elf_resolve * _dl_load_elf_shared_library(int secure, 
++	struct dyn_elf **rpnt, char *libname);
++extern struct elf_resolve *_dl_check_if_named_library_is_loaded(const char *full_libname);
++extern int _dl_linux_resolve(void);
++
++
++/*
++ * Datatype of a relocation on this platform
++ */
++#ifdef ELF_USES_RELOCA
++# define ELF_RELOC	ElfW(Rela)
++#else
++# define ELF_RELOC	ElfW(Rel)
++#endif
++
++
++/* Convert between the Linux flags for page protections and the
++   ones specified in the ELF standard. */
++#define LXFLAGS(X) ( (((X) & PF_R) ? PROT_READ : 0) | \
++		    (((X) & PF_W) ? PROT_WRITE : 0) | \
++		    (((X) & PF_X) ? PROT_EXEC : 0))
++
++
++#endif	/* LINUXELF_H */
+diff -urN uClibc/ldso-0.9.24/include/ld_hash.h uClibc.ldso.24/ldso-0.9.24/include/ld_hash.h
+--- uClibc/ldso-0.9.24/include/ld_hash.h	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/include/ld_hash.h	2003-08-19 08:11:05.000000000 -0500
+@@ -0,0 +1,103 @@
++#ifndef _LD_HASH_H_
++#define _LD_HASH_H_
++
++#ifndef RTLD_NEXT
++#define RTLD_NEXT	((void*)-1)
++#endif
++
++struct dyn_elf{
++  unsigned long flags;
++  struct elf_resolve * dyn;
++  struct dyn_elf * next_handle;  /* Used by dlopen et al. */
++  struct dyn_elf * next;
++  struct dyn_elf * prev;
++};
++
++struct elf_resolve{
++  /* These entries must be in this order to be compatible with the interface used
++     by gdb to obtain the list of symbols. */
++  ElfW(Addr) loadaddr;		/* Base address shared object is loaded at.  */
++  char *libname;		/* Absolute file name object was found in.  */
++  ElfW(Dyn) *dynamic_addr;	/* Dynamic section of the shared object.  */
++  struct elf_resolve * next;
++  struct elf_resolve * prev;
++  /* Nothing after this address is used by gdb. */
++  enum {elf_lib, elf_executable,program_interpreter, loaded_file} libtype;
++  struct dyn_elf * symbol_scope;
++  unsigned short usage_count;
++  unsigned short int init_flag;
++  unsigned int nbucket;
++  unsigned long * elf_buckets;
++  /*
++   * These are only used with ELF style shared libraries
++   */
++  unsigned long nchain;
++  unsigned long * chains;
++  unsigned long dynamic_info[24];
++
++  unsigned long dynamic_size;
++  unsigned long n_phent;
++  Elf32_Phdr * ppnt;
++
++#if defined(__mips__)
++  /* Needed for MIPS relocation */
++  unsigned long mips_gotsym;
++  unsigned long mips_local_gotno;
++  unsigned long mips_symtabno;
++#endif
++
++#ifdef __powerpc__
++  /* this is used to store the address of relocation data words, so
++   * we don't have to calculate it every time, which requires a divide */
++  unsigned long data_words;
++#endif
++};
++
++#define COPY_RELOCS_DONE    1
++#define RELOCS_DONE         2
++#define JMP_RELOCS_DONE     4
++#define INIT_FUNCS_CALLED   8
++
++extern struct dyn_elf     * _dl_symbol_tables;
++extern struct elf_resolve * _dl_loaded_modules;
++extern struct dyn_elf 	  * _dl_handles;
++
++extern struct elf_resolve * _dl_check_hashed_files(const char * libname);
++extern struct elf_resolve * _dl_add_elf_hash_table(const char * libname, 
++	char * loadaddr, unsigned long * dynamic_info, 
++	unsigned long dynamic_addr, unsigned long dynamic_size);
++
++enum caller_type{symbolrel=0,copyrel=1,resolver=2};
++extern char * _dl_find_hash(const char * name, struct dyn_elf * rpnt1, 
++	struct elf_resolve * f_tpnt, enum caller_type);
++
++extern int _dl_linux_dynamic_link(void);
++
++extern char * _dl_library_path;
++extern char * _dl_not_lazy;
++extern unsigned long _dl_elf_hash(const char * name);
++
++static inline int _dl_symbol(char * name)
++{
++  if(name[0] != '_' || name[1] != 'd' || name[2] != 'l' || name[3] != '_')
++    return 0;
++  return 1;
++}
++
++
++#define LD_ERROR_NOFILE 1
++#define LD_ERROR_NOZERO 2
++#define LD_ERROR_NOTELF 3
++#define LD_ERROR_NOTMAGIC 4
++#define LD_ERROR_NOTDYN 5
++#define LD_ERROR_MMAP_FAILED 6
++#define LD_ERROR_NODYNAMIC 7
++#define LD_WRONG_RELOCS 8
++#define LD_BAD_HANDLE 9
++#define LD_NO_SYMBOL 10
++
++
++
++#endif /* _LD_HASH_H_ */
++
++
+diff -urN uClibc/ldso-0.9.24/include/ld_string.h uClibc.ldso.24/ldso-0.9.24/include/ld_string.h
+--- uClibc/ldso-0.9.24/include/ld_string.h	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/include/ld_string.h	2003-09-29 16:46:00.000000000 -0500
+@@ -0,0 +1,281 @@
++#ifndef _LINUX_STRING_H_
++#define _LINUX_STRING_H_
++
++extern void *_dl_malloc(int size);
++extern char *_dl_getenv(const char *symbol, char **envp);
++extern void _dl_unsetenv(const char *symbol, char **envp);
++extern char *_dl_strdup(const char *string);
++extern void _dl_dprintf(int, const char *, ...);
++
++
++static size_t _dl_strlen(const char * str);
++static char *_dl_strcat(char *dst, const char *src);
++static char * _dl_strcpy(char * dst,const char *src);
++static int _dl_strcmp(const char * s1,const char * s2);
++static int _dl_strncmp(const char * s1,const char * s2,size_t len);
++static char * _dl_strchr(const char * str,int c);
++static char *_dl_strrchr(const char *str, int c);
++static char *_dl_strstr(const char *s1, const char *s2);
++static void * _dl_memcpy(void * dst, const void * src, size_t len);
++static int _dl_memcmp(const void * s1,const void * s2,size_t len);
++static void *_dl_memset(void * str,int c,size_t len);
++static char *_dl_get_last_path_component(char *path);
++static char *_dl_simple_ltoa(char * local, unsigned long i);
++static char *_dl_simple_ltoahex(char * local, unsigned long i);
++
++#ifndef NULL
++#define NULL ((void *) 0)
++#endif
++
++static inline size_t _dl_strlen(const char * str)
++{
++	register char *ptr = (char *) str;
++
++	while (*ptr)
++		ptr++;
++	return (ptr - str);
++}
++
++static inline char *_dl_strcat(char *dst, const char *src)
++{
++	register char *ptr = dst;
++
++	while (*ptr)
++		ptr++;
++
++	while (*src)
++		*ptr++ = *src++;
++	*ptr = '\0';
++
++	return dst;
++}
++
++static inline char * _dl_strcpy(char * dst,const char *src)
++{
++	register char *ptr = dst;
++
++	while (*src)
++		*dst++ = *src++;
++	*dst = '\0';
++
++	return ptr;
++}
++ 
++static inline int _dl_strcmp(const char * s1,const char * s2)
++{
++	register unsigned char c1, c2;
++
++	do {
++		c1 = (unsigned char) *s1++;
++		c2 = (unsigned char) *s2++;
++		if (c1 == '\0')
++			return c1 - c2;
++	}
++	while (c1 == c2);
++
++	return c1 - c2;
++}
++
++static inline int _dl_strncmp(const char * s1,const char * s2,size_t len)
++{
++	register unsigned char c1 = '\0';
++	register unsigned char c2 = '\0';
++
++	while (len > 0) {
++		c1 = (unsigned char) *s1++;
++		c2 = (unsigned char) *s2++;
++		if (c1 == '\0' || c1 != c2)
++			return c1 - c2;
++		len--;
++	}
++
++	return c1 - c2;
++}
++
++static inline char * _dl_strchr(const char * str,int c)
++{
++	register char ch;
++
++	do {
++		if ((ch = *str) == c)
++			return (char *) str;
++		str++;
++	}
++	while (ch);
++
++	return 0;
++}
++
++static inline char *_dl_strrchr(const char *str, int c)
++{
++    register char *prev = 0;
++    register char *ptr = (char *) str;
++
++    while (*ptr != '\0') {
++	if (*ptr == c)
++	    prev = ptr;
++	ptr++;  
++    }   
++    if (c == '\0')
++	return(ptr);
++    return(prev);
++}
++
++
++static inline char *_dl_strstr(const char *s1, const char *s2)
++{
++    register const char *s = s1;
++    register const char *p = s2;
++    
++    do {
++        if (!*p) {
++	    return (char *) s1;;
++	}
++	if (*p == *s) {
++	    ++p;
++	    ++s;
++	} else {
++	    p = s2;
++	    if (!*s) {
++	      return NULL;
++	    }
++	    s = ++s1;
++	}
++    } while (1);
++}
++
++static inline void * _dl_memcpy(void * dst, const void * src, size_t len)
++{
++	register char *a = dst;
++	register const char *b = src;
++
++	while (len--)
++		*a++ = *b++;
++
++	return dst;
++}
++
++
++static inline int _dl_memcmp(const void * s1,const void * s2,size_t len)
++{
++	unsigned char *c1 = (unsigned char *)s1;
++	unsigned char *c2 = (unsigned char *)s2;
++
++	while (len--) {
++		if (*c1 != *c2) 
++			return *c1 - *c2;
++		c1++;
++		c2++;
++	}
++	return 0;
++}
++
++static inline void * _dl_memset(void * str,int c,size_t len)
++{
++	register char *a = str;
++
++	while (len--)
++		*a++ = c;
++
++	return str;
++}
++
++static inline char *_dl_get_last_path_component(char *path)
++{
++	char *s;
++	register char *ptr = path;
++	register char *prev = 0;
++
++	while (*ptr)
++		ptr++;
++	s = ptr - 1;
++
++	/* strip trailing slashes */
++	while (s != path && *s == '/') {
++		*s-- = '\0';
++	}
++
++	/* find last component */
++	ptr = path;
++	while (*ptr != '\0') {
++	    if (*ptr == '/')
++		prev = ptr;
++	    ptr++;  
++	}   
++	s = prev;
++
++	if (s == NULL || s[1] == '\0')
++		return path;
++	else
++		return s+1;
++}
++
++/* Early on, we can't call printf, so use this to print out
++ * numbers using the SEND_STDERR() macro */
++static inline char *_dl_simple_ltoa(char * local, unsigned long i)
++{
++	/* 21 digits plus null terminator, good for 64-bit or smaller ints */
++	char *p = &local[22];
++	*p-- = '\0';
++	do {
++		*p-- = '0' + i % 10;
++		i /= 10;
++	} while (i > 0);
++	return p + 1;
++}
++
++static inline char *_dl_simple_ltoahex(char * local, unsigned long i)
++{
++	/* 21 digits plus null terminator, good for 64-bit or smaller ints */
++	char *p = &local[22];
++	*p-- = '\0';
++	do {
++		char temp = i % 0x10;
++		if (temp <= 0x09)
++		    *p-- = '0' + temp;
++		else
++		    *p-- = 'a' - 0x0a + temp;
++		i /= 0x10;
++	} while (i > 0);
++	*p-- = 'x';
++	*p-- = '0';
++	return p + 1;
++}
++
++
++#if defined(mc68000) || defined(__arm__) || defined(__mips__) || defined(__sh__) ||  defined(__powerpc__)
++/* On some arches constant strings are referenced through the GOT. */
++/* XXX Requires load_addr to be defined. */
++#define SEND_STDERR(X)				\
++  { const char *__s = (X);			\
++    if (__s < (const char *) load_addr) __s += load_addr;	\
++    _dl_write (2, __s, _dl_strlen (__s));	\
++  }
++#else
++#define SEND_STDERR(X) _dl_write(2, X, _dl_strlen(X));
++#endif
++
++#define SEND_ADDRESS_STDERR(X, add_a_newline) { \
++    char tmp[22], *tmp1; \
++    _dl_memset(tmp, 0, sizeof(tmp)); \
++    tmp1=_dl_simple_ltoahex( tmp, (unsigned long)(X)); \
++    _dl_write(2, tmp1, _dl_strlen(tmp1)); \
++    if (add_a_newline) { \
++	tmp[0]='\n'; \
++	_dl_write(2, tmp, 1); \
++    } \
++};
++
++#define SEND_NUMBER_STDERR(X, add_a_newline) { \
++    char tmp[22], *tmp1; \
++    _dl_memset(tmp, 0, sizeof(tmp)); \
++    tmp1=_dl_simple_ltoa( tmp, (unsigned long)(X)); \
++    _dl_write(2, tmp1, _dl_strlen(tmp1)); \
++    if (add_a_newline) { \
++	tmp[0]='\n'; \
++	_dl_write(2, tmp, 1); \
++    } \
++};
++
++
++#endif
+diff -urN uClibc/ldso-0.9.24/include/ld_syscall.h uClibc.ldso.24/ldso-0.9.24/include/ld_syscall.h
+--- uClibc/ldso-0.9.24/include/ld_syscall.h	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/include/ld_syscall.h	2003-08-19 01:05:30.000000000 -0500
+@@ -0,0 +1,157 @@
++#ifndef _LD_SYSCALL_H_
++#define _LD_SYSCALL_H_
++
++/* Pull in the arch specific syscall implementation */
++#include <ld_syscalls.h>
++/*  For MAP_ANONYMOUS -- differs between platforms */
++#include <asm/mman.h>			
++/* Pull in whatever this particular arch's kernel thinks the kernel version of
++ * struct stat should look like.  It turns out that each arch has a different
++ * opinion on the subject, and different kernel revs use different names... */
++#define kernel_stat stat
++#include <bits/kernel_stat.h>
++
++
++/* Encoding of the file mode.  */
++#define	S_IFMT		0170000	/* These bits determine file type.  */
++
++/* File types.  */
++#define	S_IFDIR		0040000	/* Directory.  */
++#define	S_IFCHR		0020000	/* Character device.  */
++#define	S_IFBLK		0060000	/* Block device.  */
++#define	S_IFREG		0100000	/* Regular file.  */
++#define	S_IFIFO		0010000	/* FIFO.  */
++#define	S_IFLNK		0120000	/* Symbolic link.  */
++#define	S_IFSOCK	0140000	/* Socket.  */
++
++/* Protection bits.  */
++
++#define	S_ISUID		04000	/* Set user ID on execution.  */
++#define	S_ISGID		02000	/* Set group ID on execution.  */
++#define	S_ISVTX		01000	/* Save swapped text after use (sticky).  */
++#define	S_IREAD		0400	/* Read by owner.  */
++#define	S_IWRITE	0200	/* Write by owner.  */
++#define	S_IEXEC		0100	/* Execute by owner.  */
++
++
++/* Here are the definitions for some syscalls that are used
++   by the dynamic linker.  The idea is that we want to be able
++   to call these before the errno symbol is dynamicly linked, so
++   we use our own version here.  Note that we cannot assume any
++   dynamic linking at all, so we cannot return any error codes.
++   We just punt if there is an error. */
++
++
++#define __NR__dl_exit __NR_exit
++static inline _syscall1(void, _dl_exit, int, status);
++
++
++#define __NR__dl_close __NR_close
++static inline _syscall1(int, _dl_close, int, fd);
++
++
++#if defined(__powerpc__) || defined(__mips__) || defined(__sh__)
++/* PowerPC, MIPS and SuperH have a different calling convention for mmap(). */
++#define __NR__dl_mmap __NR_mmap
++static inline _syscall6(void *, _dl_mmap, void *, start, size_t, length,
++		int, prot, int, flags, int, fd, off_t, offset);
++#else
++#define __NR__dl_mmap_real __NR_mmap
++static inline _syscall1(void *, _dl_mmap_real, unsigned long *, buffer);
++
++static inline void * _dl_mmap(void * addr, unsigned long size, int prot,
++		int flags, int fd, unsigned long offset)
++{
++	unsigned long buffer[6];
++
++	buffer[0] = (unsigned long) addr;
++	buffer[1] = (unsigned long) size;
++	buffer[2] = (unsigned long) prot;
++	buffer[3] = (unsigned long) flags;
++	buffer[4] = (unsigned long) fd;
++	buffer[5] = (unsigned long) offset;
++	return (void *) _dl_mmap_real(buffer);
++}
++#endif
++
++#ifndef _dl_MAX_ERRNO
++#define _dl_MAX_ERRNO 4096
++#endif
++#define _dl_mmap_check_error(__res)	\
++	(((int)__res) < 0 && ((int)__res) >= -_dl_MAX_ERRNO)
++#ifndef MAP_ANONYMOUS
++#ifdef __sparc__
++#define MAP_ANONYMOUS 0x20
++#else
++#error MAP_ANONYMOUS not defined and suplementary value not known
++#endif
++#endif
++
++
++#define __NR__dl_open __NR_open
++#define O_RDONLY        0x0000
++#define O_WRONLY	     01
++#define O_RDWR		     02
++#define O_CREAT		   0100	/* not fcntl */
++static inline _syscall2(int, _dl_open, const char *, fn, int, flags);
++
++#define __NR__dl_write __NR_write
++static inline _syscall3(unsigned long, _dl_write, int, fd, 
++	    const void *, buf, unsigned long, count);
++
++
++#define __NR__dl_read __NR_read
++static inline _syscall3(unsigned long, _dl_read, int, fd, 
++	    const void *, buf, unsigned long, count);
++
++#define __NR__dl_mprotect __NR_mprotect
++static inline _syscall3(int, _dl_mprotect, const void *, addr, unsigned long, len, int, prot);
++
++
++
++#define __NR__dl_stat __NR_stat
++static inline _syscall2(int, _dl_stat, const char *, file_name, struct stat *, buf);
++
++
++#define __NR__dl_munmap __NR_munmap
++static inline _syscall2(int, _dl_munmap, void *, start, unsigned long, length);
++
++#define __NR__dl_getuid __NR_getuid
++static inline _syscall0(uid_t, _dl_getuid);
++
++#define __NR__dl_geteuid __NR_geteuid
++static inline _syscall0(uid_t, _dl_geteuid);
++
++#define __NR__dl_getgid __NR_getgid
++static inline _syscall0(gid_t, _dl_getgid);
++
++#define __NR__dl_getegid __NR_getegid
++static inline _syscall0(gid_t, _dl_getegid);
++
++#define __NR__dl_getpid __NR_getpid
++static inline _syscall0(gid_t, _dl_getpid);
++
++/*
++ * Not an actual syscall, but we need something in assembly to say whether
++ * this is OK or not.
++ */
++static inline int _dl_suid_ok(void)
++{
++    uid_t uid, euid, gid, egid;
++
++    uid = _dl_getuid();
++    euid = _dl_geteuid();
++    gid = _dl_getgid();
++    egid = _dl_getegid();
++
++    if(uid == euid && gid == egid)
++	return 1;
++    else
++	return 0;
++}
++
++#define __NR__dl_readlink __NR_readlink
++static inline _syscall3(int, _dl_readlink, const char *, path, char *, buf, size_t, bufsiz);
++
++#endif /* _LD_SYSCALL_H_ */
++
+diff -urN uClibc/ldso-0.9.24/include/ldso.h uClibc.ldso.24/ldso-0.9.24/include/ldso.h
+--- uClibc/ldso-0.9.24/include/ldso.h	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/include/ldso.h	2003-08-19 01:05:30.000000000 -0500
+@@ -0,0 +1,11 @@
++#include <features.h>
++/* Pull in compiler and arch stuff */
++#include <stdlib.h>
++#include <stdarg.h>
++/* Pull in the arch specific type information */
++#include <sys/types.h>
++/* Now the ldso specific headers */
++#include <ld_elf.h>
++#include <ld_syscall.h>
++#include <ld_hash.h>
++#include <ld_string.h>
+diff -urN uClibc/ldso-0.9.24/ldso/.cvsignore uClibc.ldso.24/ldso-0.9.24/ldso/.cvsignore
+--- uClibc/ldso-0.9.24/ldso/.cvsignore	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/.cvsignore	2003-08-19 01:05:31.000000000 -0500
+@@ -0,0 +1,2 @@
++ld-uclibc.so*
++_dl_progname.h
+diff -urN uClibc/ldso-0.9.24/ldso/Makefile uClibc.ldso.24/ldso-0.9.24/ldso/Makefile
+--- uClibc/ldso-0.9.24/ldso/Makefile	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/Makefile	2004-03-01 02:58:58.000000000 -0600
+@@ -0,0 +1,101 @@
++# Makefile for uClibc
++#
++# Copyright (C) 2000 by Lineo, inc.
++# Copyright (C) 2000-2002 Erik Andersen <andersen@uclibc.org>
++#
++# This program 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.
++#
++# 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 Library General Public License for more
++# details.
++#
++# You should have received a copy of the GNU Library 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
++#
++# Derived in part from the Linux-8086 C library, the GNU C Library, and several
++# other sundry sources.  Files within this library are copyright by their
++# respective copyright holders.
++
++
++TOPDIR=../../
++include $(TOPDIR)Rules.mak
++LDSO_FULLNAME=ld-uClibc-$(MAJOR_VERSION).$(MINOR_VERSION).$(SUBLEVEL).so
++
++
++XXFLAGS=$(XWARNINGS) $(OPTIMIZATION) $(XARCH_CFLAGS) $(CPU_CFLAGS) $(PICFLAG) \
++	-DUCLIBC_RUNTIME_PREFIX=\"$(RUNTIME_PREFIX)\" \
++	-fno-builtin -nostdinc -I$(TOPDIR)ldso-0.9.24/include -I. -I$(TOPDIR)include
++
++ifeq ($(SUPPORT_LD_DEBUG),y)
++XXFLAGS=$(XWARNINGS) $(XARCH_CFLAGS) $(CPU_CFLAGS) $(PICFLAG) \
++	-DUCLIBC_RUNTIME_PREFIX=\"$(RUNTIME_PREFIX)\" \
++	-fno-builtin -nostdinc -I$(TOPDIR)ldso-0.9.24/include -I. -I$(TOPDIR)include
++# Not really much point in including debugging info, since gdb
++# can't really debug ldso, since gdb requires help from ldso to
++# debug things....
++XXFLAGS+=-Os #-g3
++endif
++
++# BEWARE!!! At least mips* will die if -O0 is used!!!
++XXFLAGS :=$(XXFLAGS:-O0=-O1)
++
++XXFLAGS+=$(shell $(CC) -print-search-dirs | sed -ne "s/install: *\(.*\)/-I\1include/gp")
++LDFLAGS=$(CPU_LDFLAGS-y) -shared --warn-common --export-dynamic --sort-common \
++	-z combreloc --discard-locals --discard-all --no-undefined
++
++CSRC= ldso.c #hash.c readelflib1.c $(TARGET_ARCH)/elfinterp.c
++COBJS=$(patsubst %.c,%.o, $(CSRC))
++ASRC=$(shell ls $(TARGET_ARCH)/*.S)
++AOBJS=$(patsubst %.S,%.o, $(ASRC))
++OBJS=$(AOBJS) $(COBJS)
++
++ifneq ($(strip $(SUPPORT_LD_DEBUG)),y)
++LDFLAGS+=-s
++endif
++
++ifeq ($(strip $(SUPPORT_LD_DEBUG)),y)
++XXFLAGS+=-D__SUPPORT_LD_DEBUG__
++endif
++
++ifeq ($(strip $(SUPPORT_LD_DEBUG_EARLY)),y)
++XXFLAGS+=-D__SUPPORT_LD_DEBUG_EARLY__
++endif
++
++ifeq ($(strip $(FORCE_SHAREABLE_TEXT_SEGMENTS)),y)
++XXFLAGS+=-DFORCE_SHAREABLE_TEXT_SEGMENTS
++endif
++
++#This stuff will not work with -fomit-frame-pointer
++XXFLAGS := $(XXFLAGS:-fomit-frame-pointer=)
++
++all: lib
++
++lib:: _dl_progname.h $(OBJS) $(DLINK_OBJS)
++	$(LD) $(LDFLAGS) -e _dl_boot -soname=$(UCLIBC_LDSO) \
++		-o $(LDSO_FULLNAME) $(OBJS) $(LIBGCC);
++	$(INSTALL) -d $(TOPDIR)lib
++	$(INSTALL) -m 755 $(LDSO_FULLNAME) $(TOPDIR)lib
++	$(LN) -sf $(LDSO_FULLNAME) $(TOPDIR)lib/$(UCLIBC_LDSO)
++
++_dl_progname.h: Makefile
++	echo "const char *_dl_progname=\""$(UCLIBC_LDSO)"\";" > _dl_progname.h
++	echo "#include \"$(TARGET_ARCH)/elfinterp.c\"" >> _dl_progname.h
++
++
++$(COBJS): %.o : %.c
++	$(CC) $(XXFLAGS) -I../libdl -c $< -o $@
++	$(STRIPTOOL) -x -R .note -R .comment $*.o
++
++$(AOBJS): %.o : %.S
++	$(CC) $(XXFLAGS) -I../libdl -c $< -o $@
++	$(STRIPTOOL) -x -R .note -R .comment $*.o
++
++ldso.o: ldso.c hash.c readelflib1.c $(TARGET_ARCH)/elfinterp.c _dl_progname.h
++
++clean:
++	$(RM) $(UCLIBC_LDSO)* $(OBJS) $(LDSO_FULLNAME)* core *.o *.a *.s *.i _dl_progname.h ldso.h *~
+diff -urN uClibc/ldso-0.9.24/ldso/arm/boot1_arch.h uClibc.ldso.24/ldso-0.9.24/ldso/arm/boot1_arch.h
+--- uClibc/ldso-0.9.24/ldso/arm/boot1_arch.h	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/arm/boot1_arch.h	2002-11-13 18:53:49.000000000 -0600
+@@ -0,0 +1,30 @@
++/* Any assmbly language/system dependent hacks needed to setup boot1.c so it
++ * will work as expected and cope with whatever platform specific wierdness is
++ * needed for this architecture.  */
++
++/* Overrive the default _dl_boot function, and replace it with a bit of asm.
++ * Then call the real _dl_boot function, which is now named _dl_boot2. */
++
++asm("" \
++"	.text\n"			\
++"	.globl	_dl_boot\n"		\
++"_dl_boot:\n"				\
++"	mov	r7, sp\n"		\
++"	@ldr	r0, [sp], #4\n"		\
++"	mov	r0, sp\n"		\
++"	bl	_dl_boot2\n"		\
++"	mov	r6, r0\n"		\
++"	mov	r0, r7\n"		\
++"	mov	pc, r6\n"		\
++);
++
++#define _dl_boot _dl_boot2
++#define LD_BOOT(X)   static void *  __attribute__ ((unused)) _dl_boot (X)
++
++
++ /* It seems ARM needs an offset here */
++#undef ELFMAGIC
++#define	    ELFMAGIC	ELFMAG+load_addr 
++
++
++
+diff -urN uClibc/ldso-0.9.24/ldso/arm/elfinterp.c uClibc.ldso.24/ldso-0.9.24/ldso/arm/elfinterp.c
+--- uClibc/ldso-0.9.24/ldso/arm/elfinterp.c	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/arm/elfinterp.c	2002-11-07 21:20:59.000000000 -0600
+@@ -0,0 +1,462 @@
++/* vi: set sw=4 ts=4: */
++/* ARM ELF shared library loader suppport
++ *
++ * Copyright (C) 2001-2002, Erik Andersen
++ *
++ * All rights reserved.
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions
++ * are met:
++ * 1. Redistributions of source code must retain the above copyright
++ *    notice, this list of conditions and the following disclaimer.
++ * 2. The name of the above contributors may not be
++ *    used to endorse or promote products derived from this software
++ *    without specific prior written permission.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND
++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ * ARE DISCLAIMED.  IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE
++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
++ * SUCH DAMAGE.
++ */
++
++#if defined (__SUPPORT_LD_DEBUG__)
++static const char *_dl_reltypes_tab[] =
++{
++  [0]	"R_ARM_NONE",	    "R_ARM_PC24",	"R_ARM_ABS32",		"R_ARM_REL32",
++  [4]	"R_ARM_PC13",	    "R_ARM_ABS16",	"R_ARM_ABS12",		"R_ARM_THM_ABS5",
++  [8]	"R_ARM_ABS8",		"R_ARM_SBREL32","R_ARM_THM_PC22",	"R_ARM_THM_PC8",
++  [12]	"R_ARM_AMP_VCALL9",	"R_ARM_SWI24",	"R_ARM_THM_SWI8",	"R_ARM_XPC25",
++  [16]	"R_ARM_THM_XPC22",
++  [20]	"R_ARM_COPY",		"R_ARM_GLOB_DAT","R_ARM_JUMP_SLOT",	"R_ARM_RELATIVE",
++  [24]	"R_ARM_GOTOFF",		"R_ARM_GOTPC",	 "R_ARM_GOT32",		"R_ARM_PLT32",
++  [32]	"R_ARM_ALU_PCREL_7_0","R_ARM_ALU_PCREL_15_8","R_ARM_ALU_PCREL_23_15","R_ARM_LDR_SBREL_11_0",
++  [36]	"R_ARM_ALU_SBREL_19_12","R_ARM_ALU_SBREL_27_20",
++  [100]	"R_ARM_GNU_VTENTRY","R_ARM_GNU_VTINHERIT","R_ARM_THM_PC11","R_ARM_THM_PC9",
++  [249] "R_ARM_RXPC25", "R_ARM_RSBREL32", "R_ARM_THM_RPC22", "R_ARM_RREL32",
++  [253] "R_ARM_RABS22", "R_ARM_RPC24", "R_ARM_RBASE",
++};
++
++static const char *
++_dl_reltypes(int type)
++{
++  static char buf[22];  
++  const char *str;
++  
++  if (type >= (sizeof (_dl_reltypes_tab)/sizeof(_dl_reltypes_tab[0])) ||
++      NULL == (str = _dl_reltypes_tab[type]))
++  {
++    str =_dl_simple_ltoa( buf, (unsigned long)(type));
++  }
++  return str;
++}
++
++static 
++void debug_sym(Elf32_Sym *symtab,char *strtab,int symtab_index)
++{
++  if(_dl_debug_symbols)
++  {
++    if(symtab_index){
++      _dl_dprintf(_dl_debug_file, "\n%s\tvalue=%x\tsize=%x\tinfo=%x\tother=%x\tshndx=%x",
++		  strtab + symtab[symtab_index].st_name,
++		  symtab[symtab_index].st_value,
++		  symtab[symtab_index].st_size,
++		  symtab[symtab_index].st_info,
++		  symtab[symtab_index].st_other,
++		  symtab[symtab_index].st_shndx);
++    }
++  }
++}
++
++static void debug_reloc(Elf32_Sym *symtab,char *strtab, ELF_RELOC *rpnt)
++{
++  if(_dl_debug_reloc)
++  {
++    int symtab_index;
++    const char *sym;
++    symtab_index = ELF32_R_SYM(rpnt->r_info);
++    sym = symtab_index ? strtab + symtab[symtab_index].st_name : "sym=0x0";
++    
++#ifdef ELF_USES_RELOCA
++    _dl_dprintf(_dl_debug_file, "\n%s\toffset=%x\taddend=%x %s",
++		_dl_reltypes(ELF32_R_TYPE(rpnt->r_info)),
++		rpnt->r_offset,
++		rpnt->r_addend,
++		sym);
++#else
++    _dl_dprintf(_dl_debug_file, "\n%s\toffset=%x %s",
++		_dl_reltypes(ELF32_R_TYPE(rpnt->r_info)),
++		rpnt->r_offset,
++		sym);
++#endif
++  }
++}
++#endif
++
++/* Program to load an ELF binary on a linux system, and run it.
++   References to symbols in sharable libraries can be resolved by either
++   an ELF sharable library or a linux style of shared library. */
++
++/* Disclaimer:  I have never seen any AT&T source code for SVr4, nor have
++   I ever taken any courses on internals.  This program was developed using
++   information available through the book "UNIX SYSTEM V RELEASE 4,
++   Programmers guide: Ansi C and Programming Support Tools", which did
++   a more than adequate job of explaining everything required to get this
++   working. */
++
++extern int _dl_linux_resolve(void);
++
++unsigned long _dl_linux_resolver(struct elf_resolve *tpnt, int reloc_entry)
++{
++	int reloc_type;
++	ELF_RELOC *this_reloc;
++	char *strtab;
++	Elf32_Sym *symtab;
++	ELF_RELOC *rel_addr;
++	int symtab_index;
++	char *new_addr;
++	char **got_addr;
++	unsigned long instr_addr;
++
++	rel_addr = (ELF_RELOC *) (tpnt->dynamic_info[DT_JMPREL] + tpnt->loadaddr);
++
++	this_reloc = rel_addr + (reloc_entry >> 3);
++	reloc_type = ELF32_R_TYPE(this_reloc->r_info);
++	symtab_index = ELF32_R_SYM(this_reloc->r_info);
++
++	symtab = (Elf32_Sym *) (tpnt->dynamic_info[DT_SYMTAB] + tpnt->loadaddr);
++	strtab = (char *) (tpnt->dynamic_info[DT_STRTAB] + tpnt->loadaddr);
++
++
++	if (reloc_type != R_ARM_JUMP_SLOT) {
++		_dl_dprintf(2, "%s: Incorrect relocation type in jump relocations\n", 
++			_dl_progname);
++		_dl_exit(1);
++	};
++
++	/* Address of jump instruction to fix up */
++	instr_addr = ((unsigned long) this_reloc->r_offset + 
++		(unsigned long) tpnt->loadaddr);
++	got_addr = (char **) instr_addr;
++
++	/* Get the address of the GOT entry */
++	new_addr = _dl_find_hash(strtab + symtab[symtab_index].st_name, 
++		tpnt->symbol_scope, tpnt, resolver);
++	if (!new_addr) {
++		_dl_dprintf(2, "%s: can't resolve symbol '%s'\n", 
++			_dl_progname, strtab + symtab[symtab_index].st_name);
++		_dl_exit(1);
++	};
++#if defined (__SUPPORT_LD_DEBUG__)
++	if ((unsigned long) got_addr < 0x40000000)
++	{
++		if (_dl_debug_bindings)
++		{
++			_dl_dprintf(_dl_debug_file, "\nresolve function: %s",
++					strtab + symtab[symtab_index].st_name);
++			if(_dl_debug_detail) _dl_dprintf(_dl_debug_file, 
++					"\tpatch %x ==> %x @ %x", *got_addr, new_addr, got_addr);
++		}
++	}
++	if (!_dl_debug_nofixups) {
++		*got_addr = new_addr;
++	}
++#else
++	*got_addr = new_addr;
++#endif
++
++	return (unsigned long) new_addr;
++}
++
++static int
++_dl_parse(struct elf_resolve *tpnt, struct dyn_elf *scope,
++	  unsigned long rel_addr, unsigned long rel_size,
++	  int (*reloc_fnc) (struct elf_resolve *tpnt, struct dyn_elf *scope,
++			    ELF_RELOC *rpnt, Elf32_Sym *symtab, char *strtab))
++{
++	int i;
++	char *strtab;
++	int goof = 0;
++	Elf32_Sym *symtab;
++	ELF_RELOC *rpnt;
++	int symtab_index;
++	/* Now parse the relocation information */
++
++	rpnt = (ELF_RELOC *) (rel_addr + tpnt->loadaddr);
++	rel_size = rel_size / sizeof(ELF_RELOC);
++
++	symtab = (Elf32_Sym *) (tpnt->dynamic_info[DT_SYMTAB] + tpnt->loadaddr);
++	strtab = (char *) (tpnt->dynamic_info[DT_STRTAB] + tpnt->loadaddr);
++
++	  for (i = 0; i < rel_size; i++, rpnt++) {
++	        int res;
++	    
++		symtab_index = ELF32_R_SYM(rpnt->r_info);
++		
++		/* When the dynamic linker bootstrapped itself, it resolved some symbols.
++		   Make sure we do not do them again */
++		if (!symtab_index && tpnt->libtype == program_interpreter)
++			continue;
++		if (symtab_index && tpnt->libtype == program_interpreter &&
++		    _dl_symbol(strtab + symtab[symtab_index].st_name))
++			continue;
++
++#if defined (__SUPPORT_LD_DEBUG__)
++		debug_sym(symtab,strtab,symtab_index);
++		debug_reloc(symtab,strtab,rpnt);
++#endif
++
++		res = reloc_fnc (tpnt, scope, rpnt, symtab, strtab);
++
++		if (res==0) continue;
++
++		_dl_dprintf(2, "\n%s: ",_dl_progname);
++		
++		if (symtab_index)
++		  _dl_dprintf(2, "symbol '%s': ", strtab + symtab[symtab_index].st_name);
++		  
++		if (res <0)
++		{
++		        int reloc_type = ELF32_R_TYPE(rpnt->r_info);
++#if defined (__SUPPORT_LD_DEBUG__)
++			_dl_dprintf(2, "can't handle reloc type %s\n ", _dl_reltypes(reloc_type));
++#else
++			_dl_dprintf(2, "can't handle reloc type %x\n", reloc_type);
++#endif			
++			_dl_exit(-res);
++		}
++		else if (res >0)
++		{
++			_dl_dprintf(2, "can't resolve symbol\n");
++			goof += res;
++		}
++	  }
++	  return goof;
++}
++
++static unsigned long
++fix_bad_pc24 (unsigned long *const reloc_addr, unsigned long value)
++{
++  static void *fix_page;
++  static unsigned int fix_offset;
++  unsigned int *fix_address;
++  if (! fix_page)
++    {
++      fix_page = _dl_mmap (NULL,  4096   , PROT_READ | PROT_WRITE | PROT_EXEC,
++                       MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
++      fix_offset = 0;
++    }
++
++  fix_address = (unsigned int *)(fix_page + fix_offset);
++  fix_address[0] = 0xe51ff004;  /* ldr pc, [pc, #-4] */
++  fix_address[1] = value;
++
++  fix_offset += 8;
++  if (fix_offset >= 4096)
++    fix_page = NULL;
++
++  return (unsigned long)fix_address;
++}
++
++static int
++_dl_do_reloc (struct elf_resolve *tpnt,struct dyn_elf *scope,
++	      ELF_RELOC *rpnt, Elf32_Sym *symtab, char *strtab)
++{
++	int reloc_type;
++	int symtab_index;
++	unsigned long *reloc_addr;
++	unsigned long symbol_addr;
++	int goof = 0;
++
++	reloc_addr = (unsigned long *) (tpnt->loadaddr + (unsigned long) rpnt->r_offset);
++	reloc_type = ELF32_R_TYPE(rpnt->r_info);
++	symtab_index = ELF32_R_SYM(rpnt->r_info);
++	symbol_addr = 0;
++
++	if (symtab_index) {
++
++		symbol_addr = (unsigned long) _dl_find_hash(strtab + symtab[symtab_index].st_name, 
++				scope, (reloc_type == R_ARM_JUMP_SLOT ? tpnt : NULL), symbolrel);
++
++		/*
++		 * We want to allow undefined references to weak symbols - this might
++		 * have been intentional.  We should not be linking local symbols
++		 * here, so all bases should be covered.
++		 */
++		if (!symbol_addr && ELF32_ST_BIND(symtab[symtab_index].st_info) == STB_GLOBAL) {
++			goof++;
++		}
++	}
++
++#if defined (__SUPPORT_LD_DEBUG__)
++	{
++		unsigned long old_val = *reloc_addr;
++#endif
++		switch (reloc_type) {
++			case R_ARM_NONE:
++				break;
++			case R_ARM_ABS32:
++				*reloc_addr += symbol_addr;
++				break;
++			case R_ARM_PC24:
++				{
++					unsigned long addend;
++					long newvalue, topbits;
++
++					addend = *reloc_addr & 0x00ffffff;
++					if (addend & 0x00800000) addend |= 0xff000000;
++
++					newvalue = symbol_addr - (unsigned long)reloc_addr + (addend << 2);
++					topbits = newvalue & 0xfe000000;
++					if (topbits != 0xfe000000 && topbits != 0x00000000)
++					{
++						newvalue = fix_bad_pc24(reloc_addr, symbol_addr)
++							- (unsigned long)reloc_addr + (addend << 2);
++						topbits = newvalue & 0xfe000000;
++						if (topbits != 0xfe000000 && topbits != 0x00000000)
++						{
++							_dl_dprintf(2,"symbol '%s': R_ARM_PC24 relocation out of range.", 
++								symtab[symtab_index].st_name);
++							_dl_exit(1);
++						}
++					}
++					newvalue >>= 2;
++					symbol_addr = (*reloc_addr & 0xff000000) | (newvalue & 0x00ffffff);
++					*reloc_addr = symbol_addr;
++					break;
++				}
++			case R_ARM_GLOB_DAT:
++			case R_ARM_JUMP_SLOT:
++				*reloc_addr = symbol_addr;
++				break;
++			case R_ARM_RELATIVE:
++				*reloc_addr += (unsigned long) tpnt->loadaddr;
++				break;
++			case R_ARM_COPY:						
++#if 0							
++				/* Do this later */
++				_dl_dprintf(2, "Doing copy for symbol ");
++				if (symtab_index) _dl_dprintf(2, strtab + symtab[symtab_index].st_name);
++				_dl_dprintf(2, "\n");
++				_dl_memcpy((void *) symtab[symtab_index].st_value, 
++						(void *) symbol_addr, symtab[symtab_index].st_size);
++#endif
++				break;
++			default:
++				return -1; /*call _dl_exit(1) */
++		}
++#if defined (__SUPPORT_LD_DEBUG__)
++		if(_dl_debug_reloc && _dl_debug_detail)
++			_dl_dprintf(_dl_debug_file, "\tpatch: %x ==> %x @ %x", old_val, *reloc_addr, reloc_addr);
++	}
++
++#endif
++
++	return goof;
++}
++
++static int
++_dl_do_lazy_reloc (struct elf_resolve *tpnt, struct dyn_elf *scope,
++		   ELF_RELOC *rpnt, Elf32_Sym *symtab, char *strtab)
++{
++	int reloc_type;
++	unsigned long *reloc_addr;
++
++	reloc_addr = (unsigned long *) (tpnt->loadaddr + (unsigned long) rpnt->r_offset);
++	reloc_type = ELF32_R_TYPE(rpnt->r_info);
++
++#if defined (__SUPPORT_LD_DEBUG__)
++	{
++		unsigned long old_val = *reloc_addr;
++#endif
++		switch (reloc_type) {
++			case R_ARM_NONE:
++				break;
++			case R_ARM_JUMP_SLOT:
++				*reloc_addr += (unsigned long) tpnt->loadaddr;
++				break;
++			default:
++				return -1; /*call _dl_exit(1) */
++		}
++#if defined (__SUPPORT_LD_DEBUG__)
++		if(_dl_debug_reloc && _dl_debug_detail)
++			_dl_dprintf(_dl_debug_file, "\tpatch: %x ==> %x @ %x", old_val, *reloc_addr, reloc_addr);
++	}
++
++#endif
++	return 0;
++
++}
++
++/* This is done as a separate step, because there are cases where
++   information is first copied and later initialized.  This results in
++   the wrong information being copied.  Someone at Sun was complaining about
++   a bug in the handling of _COPY by SVr4, and this may in fact be what he
++   was talking about.  Sigh. */
++
++/* No, there are cases where the SVr4 linker fails to emit COPY relocs
++   at all */
++static int
++_dl_do_copy (struct elf_resolve *tpnt, struct dyn_elf *scope,
++	     ELF_RELOC *rpnt, Elf32_Sym *symtab, char *strtab)
++{
++        int reloc_type;
++	int symtab_index;
++	unsigned long *reloc_addr;
++	unsigned long symbol_addr;
++	int goof = 0;
++	  
++	reloc_addr = (unsigned long *) (tpnt->loadaddr + (unsigned long) rpnt->r_offset);
++	reloc_type = ELF32_R_TYPE(rpnt->r_info);
++	if (reloc_type != R_ARM_COPY) 
++		return 0;
++	symtab_index = ELF32_R_SYM(rpnt->r_info);
++	symbol_addr = 0;
++		
++	if (symtab_index) {
++
++		symbol_addr = (unsigned long) _dl_find_hash(strtab + 
++			symtab[symtab_index].st_name, scope, 
++			NULL, copyrel);
++		if (!symbol_addr) goof++;
++	}
++	if (!goof) {
++#if defined (__SUPPORT_LD_DEBUG__)
++	        if(_dl_debug_move)
++		  _dl_dprintf(_dl_debug_file,"\n%s move %x bytes from %x to %x",
++			     strtab + symtab[symtab_index].st_name,
++			     symtab[symtab_index].st_size,
++			     symbol_addr, symtab[symtab_index].st_value);
++#endif
++		_dl_memcpy((char *) symtab[symtab_index].st_value, 
++			(char *) symbol_addr, symtab[symtab_index].st_size);
++	}
++
++	return goof;
++}
++
++void _dl_parse_lazy_relocation_information(struct elf_resolve *tpnt, 
++	unsigned long rel_addr, unsigned long rel_size, int type)
++{
++  (void)_dl_parse(tpnt, NULL, rel_addr, rel_size, _dl_do_lazy_reloc);
++}
++
++int _dl_parse_relocation_information(struct elf_resolve *tpnt, 
++	unsigned long rel_addr, unsigned long rel_size, int type)
++{
++  return _dl_parse(tpnt, tpnt->symbol_scope, rel_addr, rel_size, _dl_do_reloc);
++}
++
++int _dl_parse_copy_information(struct dyn_elf *xpnt, unsigned long rel_addr, 
++	unsigned long rel_size, int type)
++{
++  return _dl_parse(xpnt->dyn, xpnt->next, rel_addr, rel_size, _dl_do_copy);
++}
++
+diff -urN uClibc/ldso-0.9.24/ldso/arm/ld_syscalls.h uClibc.ldso.24/ldso-0.9.24/ldso/arm/ld_syscalls.h
+--- uClibc/ldso-0.9.24/ldso/arm/ld_syscalls.h	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/arm/ld_syscalls.h	2003-09-09 01:11:11.000000000 -0500
+@@ -0,0 +1,19 @@
++/* Define the __set_errno macro as nothing so that INLINE_SYSCALL
++ * won't set errno, which is important since we make system calls
++ * before the errno symbol is dynamicly linked. */
++
++#define __set_errno(X) {(void)(X);}
++
++/* Prepare for the case that `__builtin_expect' is not available.  */
++#if __GNUC__ == 2 && __GNUC_MINOR__ < 96
++#define __builtin_expect(x, expected_value) (x)
++#endif
++#ifndef likely
++# define likely(x)	__builtin_expect((!!(x)),1)
++#endif
++#ifndef unlikely
++# define unlikely(x)	__builtin_expect((!!(x)),0)
++#endif
++
++#include "sys/syscall.h"
++
+diff -urN uClibc/ldso-0.9.24/ldso/arm/ld_sysdep.h uClibc.ldso.24/ldso-0.9.24/ldso/arm/ld_sysdep.h
+--- uClibc/ldso-0.9.24/ldso/arm/ld_sysdep.h	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/arm/ld_sysdep.h	2002-08-09 09:41:04.000000000 -0500
+@@ -0,0 +1,124 @@
++/*
++ * Various assmbly language/system dependent  hacks that are required
++ * so that we can minimize the amount of platform specific code.
++ */
++
++/* 
++ * Define this if the system uses RELOCA.
++ */
++#undef ELF_USES_RELOCA
++
++/*
++ * Get a pointer to the argv array.  On many platforms this can be just
++ * the address if the first argument, on other platforms we need to
++ * do something a little more subtle here.
++ */
++#define GET_ARGV(ARGVP, ARGS) ARGVP = ((unsigned long*)   ARGS)
++
++/*
++ * Initialization sequence for a GOT.
++ */
++#define INIT_GOT(GOT_BASE,MODULE) \
++{				\
++  GOT_BASE[2] = (unsigned long) _dl_linux_resolve; \
++  GOT_BASE[1] = (unsigned long) MODULE; \
++}
++
++/*
++ * Here is a macro to perform a relocation.  This is only used when
++ * bootstrapping the dynamic loader.  RELP is the relocation that we
++ * are performing, REL is the pointer to the address we are relocating.
++ * SYMBOL is the symbol involved in the relocation, and LOAD is the
++ * load address.
++ */
++#define PERFORM_BOOTSTRAP_RELOC(RELP,REL,SYMBOL,LOAD)		\
++	switch(ELF32_R_TYPE((RELP)->r_info)){			\
++	case R_ARM_ABS32:					\
++	  *REL += SYMBOL;					\
++	  break;						\
++        case R_ARM_PC24:					\
++	    { long newvalue, topbits;				\
++	    unsigned long addend = *REL & 0x00ffffff;		\
++	    if (addend & 0x00800000) addend |= 0xff000000;	\
++	    newvalue=SYMBOL-(unsigned long)REL+(addend<<2);	\
++	    topbits = newvalue & 0xfe000000;			\
++	    if (topbits!=0xfe000000&&topbits!=0x00000000){	\
++	    newvalue = fix_bad_pc24(REL, SYMBOL)		\
++		-(unsigned long)REL+(addend<<2);		\
++	    topbits = newvalue & 0xfe000000;			\
++	    if (topbits!=0xfe000000&&topbits!=0x00000000){	\
++	    SEND_STDERR("R_ARM_PC24 relocation out of range\n");\
++	    _dl_exit(1); } }					\
++	    newvalue>>=2;					\
++	    SYMBOL=(*REL&0xff000000)|(newvalue & 0x00ffffff);	\
++	    *REL=SYMBOL;					\
++	    }							\
++	  break;						\
++	case R_ARM_GLOB_DAT:					\
++	case R_ARM_JUMP_SLOT:					\
++	  *REL = SYMBOL;					\
++	  break;						\
++        case R_ARM_RELATIVE:					\
++	  *REL += (unsigned long) LOAD;				\
++	  break;						\
++        case R_ARM_NONE:					\
++	  break;						\
++	default:						\
++	  SEND_STDERR("Aiieeee!");				\
++	  _dl_exit(1);						\
++	}
++
++
++/*
++ * Transfer control to the user's application, once the dynamic loader
++ * is done.  This routine has to exit the current function, then 
++ * call the _dl_elf_main function.
++ */
++
++#define START()   return _dl_elf_main;      
++
++
++
++/* Here we define the magic numbers that this dynamic loader should accept */
++
++#define MAGIC1 EM_ARM
++#undef  MAGIC2
++/* Used for error messages */
++#define ELF_TARGET "ARM"
++
++struct elf_resolve;
++unsigned long _dl_linux_resolver(struct elf_resolve * tpnt, int reloc_entry);
++
++static inline unsigned long arm_modulus(unsigned long m, unsigned long p) {
++	unsigned long i,t,inc;
++        i=p; t=0;
++        while(!(i&(1<<31))) {
++                i<<=1;
++                t++;
++        }
++        t--;
++        for(inc=t;inc>2;inc--) {
++                i=p<<inc;
++                if(i&(1<<31))
++                        break;
++                while(m>=i) {
++                        m-=i;
++                        i<<=1;
++                        if(i&(1<<31))
++                                break;
++                        if(i<p)
++                                break;
++                }
++        }
++        while(m>=p) {
++                m-=p;
++        }
++        return m;
++}
++
++#define do_rem(result, n, base)  result=arm_modulus(n,base);
++
++/* 4096 bytes alignment */
++#define PAGE_ALIGN 0xfffff000
++#define ADDR_ALIGN 0xfff
++#define OFFS_ALIGN 0x7ffff000
+diff -urN uClibc/ldso-0.9.24/ldso/arm/resolve.S uClibc.ldso.24/ldso-0.9.24/ldso/arm/resolve.S
+--- uClibc/ldso-0.9.24/ldso/arm/resolve.S	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/arm/resolve.S	2002-08-12 04:03:30.000000000 -0500
+@@ -0,0 +1,43 @@
++/*
++ * This function is _not_ called directly.  It is jumped to (so no return
++ * address is on the stack) when attempting to use a symbol that has not yet
++ * been resolved.  The first time a jump symbol (such as a function call inside
++ * a shared library) is used (before it gets resolved) it will jump here to
++ * _dl_linux_resolve.  When we get called the stack looks like this:
++ *	reloc_entry
++ *	tpnt
++ *
++ * This function saves all the registers, puts a copy of reloc_entry and tpnt
++ * on the stack (as function arguments) then make the function call
++ * _dl_linux_resolver(tpnt, reloc_entry).  _dl_linux_resolver() figures out
++ * where the jump symbol is _really_ supposed to have jumped to and returns
++ * that to us.  Once we have that, we overwrite tpnt with this fixed up
++ * address. We then clean up after ourselves, put all the registers back how we
++ * found them, then we jump to the fixed up address, which is where the jump
++ * symbol that got us here really wanted to jump to in the first place.  
++ *  -Erik Andersen
++ */
++
++#define sl r10
++#define fp r11
++#define ip r12
++
++.text
++.globl _dl_linux_resolve
++.type _dl_linux_resolve,%function
++.align 4;
++
++_dl_linux_resolve:
++	stmdb sp!, {r0, r1, r2, r3, sl, fp}
++	sub r1, ip, lr
++	sub r1, r1, #4
++	add r1, r1, r1
++	ldr r0, [lr, #-4]
++	mov r3,r0
++
++	bl _dl_linux_resolver
++
++	mov ip, r0
++	ldmia sp!, {r0, r1, r2, r3, sl, fp, lr}
++	mov pc,ip
++.size _dl_linux_resolve, .-_dl_linux_resolve
+diff -urN uClibc/ldso-0.9.24/ldso/cris/boot1_arch.h uClibc.ldso.24/ldso-0.9.24/ldso/cris/boot1_arch.h
+--- uClibc/ldso-0.9.24/ldso/cris/boot1_arch.h	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/cris/boot1_arch.h	2003-09-19 07:11:43.000000000 -0500
+@@ -0,0 +1,17 @@
++/*
++ * This code fix the stack pointer so that the dynamic linker
++ * can find argc, argv and auxvt (Auxillary Vector Table).
++ */
++asm(""					\
++"	.text\n"			\
++"	.globl _dl_boot\n"		\
++"	.type _dl_boot,@function\n"	\
++"_dl_boot:\n"				\
++"	move.d $sp,$r10\n"		\
++"	move.d $pc,$r9\n"		\
++"	add.d _dl_boot2 - ., $r9\n"	\
++"	jsr $r9\n"			\
++);
++
++#define _dl_boot _dl_boot2
++#define LD_BOOT(X) static void * __attribute__ ((unused)) _dl_boot(X)
+diff -urN uClibc/ldso-0.9.24/ldso/cris/elfinterp.c uClibc.ldso.24/ldso-0.9.24/ldso/cris/elfinterp.c
+--- uClibc/ldso-0.9.24/ldso/cris/elfinterp.c	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/cris/elfinterp.c	2003-09-30 06:51:11.000000000 -0500
+@@ -0,0 +1,414 @@
++/*
++ * CRIS ELF shared library loader support.
++ *
++ * Program to load an elf binary on a linux system, and run it.
++ * References to symbols in sharable libraries can be resolved
++ * by either an ELF sharable library or a linux style of shared
++ * library.
++ *
++ * Copyright (C) 2002, Axis Communications AB
++ * All rights reserved
++ *
++ * Author: Tobias Anderberg, <tobiasa@axis.com>
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions
++ * are met:
++ * 1. Redistributions of source code must retain the above copyright
++ *    notice, this list of conditions and the following disclaimer.
++ * 2. The name of the above contributors may not be
++ *    used to endorse or promote products derived from this software
++ *    without specific prior written permission.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND
++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ * ARE DISCLAIMED.  IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE
++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
++ * SUCH DAMAGE.
++ */
++
++/* Support for the LD_DEBUG variable. */
++#if defined (__SUPPORT_LD_DEBUG__)
++static const char *_dl_reltypes_tab[] = {
++	[0]		"R_CRIS_NONE", "R_CRIS_8", "R_CRIS_16", "R_CRIS_32",
++	[4]		"R_CRIS_8_PCREL", "R_CRIS_16_PCREL", "R_CRIS_32_PCREL", "R_CRIS_GNU_VTINHERIT",
++	[8]		"R_CRIS_GNU_VTENTRY", "R_CRIS_COPY", "R_CRIS_GLOB_DAT", "R_CRIS_JUMP_SLOT",
++	[16]	"R_CRIS_RELATIVE", "R_CRIS_16_GOT", "R_CRIS_32_GOT", "R_CRIS_16_GOTPLT",
++	[32]	"R_CRIS_32_GOTPLT", "R_CRIS_32_GOTREL", "R_CRIS_32_PLT_GOTREL", "R_CRIS_32_PLT_PCREL",
++
++};
++
++
++static const char *
++_dl_reltypes(int type)
++{
++	const char *str;
++	static char buf[22];
++
++	if (type >= (sizeof(_dl_reltypes_tab)/sizeof(_dl_reltypes_tab[0])) ||
++		NULL == (str = _dl_reltypes_tab[type]))
++		str = _dl_simple_ltoa(buf, (unsigned long) (type));
++	
++	return str;
++}
++
++static void 
++debug_sym(Elf32_Sym *symtab, char *strtab, int symtab_index)
++{ 
++	if (_dl_debug_symbols) { 
++		if (symtab_index) {
++			_dl_dprintf(_dl_debug_file, 
++				"\n%s\tvalue=%x\tsize=%x\tinfo=%x\tother=%x\tshndx=%x",
++				strtab + symtab[symtab_index].st_name,
++				symtab[symtab_index].st_value,
++				symtab[symtab_index].st_size,
++				symtab[symtab_index].st_info,
++				symtab[symtab_index].st_other,
++				symtab[symtab_index].st_shndx);
++		}
++  	}
++}
++
++static void
++debug_reloc(Elf32_Sym *symtab, char *strtab, ELF_RELOC *rpnt)
++{
++	if (_dl_debug_reloc) {
++		int symtab_index;
++		const char *sym;
++
++		symtab_index = ELF32_R_SYM(rpnt->r_info);
++		sym = symtab_index ? strtab + symtab[symtab_index].st_name : "sym=0x0";
++
++		if (_dl_debug_symbols)
++			_dl_dprintf(_dl_debug_file, "\n\t");
++		else
++			_dl_dprintf(_dl_debug_file, "\n%s\n\t", sym);
++
++#ifdef ELF_USES_RELOCA
++		_dl_dprintf(_dl_debug_file, "%s\toffset=%x\taddend=%x",
++			_dl_reltypes(ELF32_R_TYPE(rpnt->r_info)),
++			rpnt->r_offset,
++			rpnt->r_addend);
++#else
++		_dl_dprintf(_dl_debug_file, "%s\toffset%x\n",
++			_dl_reltypes(ELF32_R_TYPE(rpnt->r_info)),
++			rpnt->r_offset);
++#endif
++	}
++}
++#endif /* __SUPPORT_LD_DEBUG__ */
++
++/* Defined in resolve.S. */
++extern int _dl_linux_resolv(void);
++
++unsigned long
++_dl_linux_resolver(struct elf_resolve *tpnt, int reloc_entry)
++{
++	int reloc_type;
++	int symtab_index;
++	char *strtab;
++	char *symname;
++	char *new_addr;
++	char *rel_addr;
++	char **got_addr;
++	Elf32_Sym *symtab;
++	ELF_RELOC *this_reloc;
++	unsigned long instr_addr;
++
++	rel_addr = (char *) (tpnt->dynamic_info[DT_JMPREL] + tpnt->loadaddr);
++
++	this_reloc = (ELF_RELOC *) (intptr_t)(rel_addr + reloc_entry);
++	reloc_type = ELF32_R_TYPE(this_reloc->r_info);
++	symtab_index = ELF32_R_SYM(this_reloc->r_info);
++
++	symtab = (Elf32_Sym *) (intptr_t)(tpnt->dynamic_info[DT_SYMTAB] + tpnt->loadaddr);
++	strtab = (char *)(tpnt->dynamic_info[DT_STRTAB] + tpnt->loadaddr);
++	symname = strtab + symtab[symtab_index].st_name;
++
++	if (reloc_type != R_CRIS_JUMP_SLOT) {
++		_dl_dprintf(2, "%s: Incorrect relocation type for jump relocations.\n",
++			_dl_progname);
++		_dl_exit(1);
++	}
++
++	/* Fetch the address of the jump instruction to fix up. */
++	instr_addr = ((unsigned long) this_reloc->r_offset + (unsigned long) tpnt->loadaddr);
++	got_addr = (char **) instr_addr;
++
++	/* Fetch the address of the GOT entry. */
++	new_addr = _dl_find_hash(symname, tpnt->symbol_scope, tpnt, resolver);
++
++	if (!new_addr) {
++		new_addr = _dl_find_hash(symname, NULL, NULL, resolver);
++
++		if (new_addr)
++			return (unsigned long) new_addr;
++
++		_dl_dprintf(2, "%s: Can't resolv symbol '%s'\n", _dl_progname, symname);
++		_dl_exit(1);
++	}
++
++#if defined (__SUPPORT_LD_DEBUG__)
++	if (_dl_debug_bindings) {
++		_dl_dprintf(_dl_debug_file, "\nresolve function: %s", symname);
++		
++		if (_dl_debug_detail)
++			_dl_dprintf(_dl_debug_file, "\tpatch %x ==> %x @ %x", *got_addr, new_addr, got_addr);
++	}
++#endif
++
++	*got_addr = new_addr;
++	return (unsigned long) new_addr;
++}
++
++static int
++_dl_parse(struct elf_resolve *tpnt, struct dyn_elf *scope, unsigned long rel_addr,
++	unsigned long rel_size, int (*reloc_fnc)(struct elf_resolve *tpnt, struct dyn_elf *scope, 
++	                            ELF_RELOC *rpnt, Elf32_Sym *symtab, char *strtab))
++{
++	int symtab_index;
++	int res;
++	unsigned int i;
++	char *strtab;
++	Elf32_Sym *symtab;
++	ELF_RELOC *rpnt;
++
++	/* Parse the relocation information. */
++	rpnt = (ELF_RELOC *) (intptr_t) (rel_addr + tpnt->loadaddr);
++	rel_size /= sizeof(ELF_RELOC);
++
++	symtab = (Elf32_Sym *) (intptr_t) (tpnt->dynamic_info[DT_SYMTAB] + tpnt->loadaddr);
++	strtab = (char *) (tpnt->dynamic_info[DT_STRTAB] + tpnt->loadaddr);
++
++	for (i = 0; i < rel_size; i++, rpnt++) {
++		symtab_index = ELF32_R_SYM(rpnt->r_info);
++
++		/* 
++		 * Make sure the same symbols that the linker resolved when it
++		 * bootstapped itself isn't resolved again.
++		 */
++		if (!symtab_index && tpnt->libtype == program_interpreter)
++			continue;
++
++		if (symtab_index && tpnt->libtype == program_interpreter &&
++			_dl_symbol(strtab + symtab[symtab_index].st_name))
++			continue;
++
++#if defined (__SUPPORT_LD_DEBUG__)
++		debug_sym(symtab, strtab, symtab_index);
++		debug_reloc(symtab, strtab, rpnt);
++#endif
++
++		/* Pass over to actual relocation function. */
++		res = reloc_fnc(tpnt, scope, rpnt, symtab, strtab);
++
++		if (res == 0)
++			continue;
++
++		_dl_dprintf(2, "\n%s: ", _dl_progname);
++
++		if (symtab_index)
++			_dl_dprintf(2, "symbol '%s': ", strtab + symtab[symtab_index].st_name);
++
++		if (res < 0) {
++			int reloc_type = ELF32_R_TYPE(rpnt->r_info);
++
++#if defined (__SUPPORT_LD_DEBUG__)
++			_dl_dprintf(2, "can't handle relocation type '%s'\n", _dl_reltypes(reloc_type));
++#else
++			_dl_dprintf(2, "can't handle relocation type %x\n", reloc_type);
++#endif
++			_dl_exit(-res);
++		}
++		else if (res > 0) {
++			_dl_dprintf(2, "can't resolv symbol\n");
++			return res;
++		}
++	}
++
++	return 0;
++}
++
++static int
++_dl_do_reloc(struct elf_resolve *tpnt, struct dyn_elf *scope, ELF_RELOC *rpnt,
++	Elf32_Sym *symtab, char *strtab)
++{
++	int reloc_type;
++	int symtab_index;
++	char *symname;
++	unsigned long *reloc_addr;
++	unsigned symbol_addr;
++#if defined (__SUPPORT_LD_DEBUG__)
++	unsigned long old_val;
++#endif
++
++	reloc_addr = (unsigned long *)(intptr_t)(tpnt->loadaddr + (unsigned long) rpnt->r_offset);
++	reloc_type = ELF32_R_TYPE(rpnt->r_info);
++	symtab_index = ELF32_R_SYM(rpnt->r_info);
++	symbol_addr = 0;
++	symname = strtab + symtab[symtab_index].st_name;
++
++	if (symtab_index) {
++		if (symtab[symtab_index].st_shndx != SHN_UNDEF && 
++			ELF32_ST_BIND(symtab[symtab_index].st_info) == STB_LOCAL) {
++			symbol_addr = (unsigned long) tpnt->loadaddr;
++		}
++		else {
++			symbol_addr = (unsigned long) _dl_find_hash(symname, scope,
++				(reloc_type == R_CRIS_JUMP_SLOT ? tpnt : NULL), symbolrel);
++		}
++
++		if (!symbol_addr && ELF32_ST_BIND(symtab[symtab_index].st_info) == STB_GLOBAL) {
++#if defined (__SUPPORT_LD_DEBUG__)
++			_dl_dprintf(2, "\tglobal symbol '%s' already defined in '%s'\n",
++				symname, tpnt->libname);
++#endif
++			return 0;
++		}
++
++		symbol_addr += rpnt->r_addend;
++	}
++
++#if defined (__SUPPORT_LD_DEBUG__)
++	old_val = *reloc_addr;
++#endif
++
++	switch (reloc_type) {
++		case R_CRIS_NONE:
++			break;
++		case R_CRIS_GLOB_DAT:
++		case R_CRIS_JUMP_SLOT:
++		case R_CRIS_32:
++		case R_CRIS_COPY:
++			*reloc_addr = symbol_addr;
++			break;
++		case R_CRIS_RELATIVE:
++			*reloc_addr = (unsigned long) tpnt->loadaddr + rpnt->r_addend;
++			break;
++		default:
++			return -1;	/* Call _dl_exit(1). */
++	}
++
++#if defined (__SUPPORT_LD_DEBUG__)
++	if (_dl_debug_reloc && _dl_debug_detail)
++		_dl_dprintf(_dl_debug_file, "\tpatched: %x ==> %x @ %x", old_val, *reloc_addr, reloc_addr);
++#endif
++
++	return 0;
++}
++
++static int
++_dl_do_lazy_reloc(struct elf_resolve *tpnt, struct dyn_elf *scope, ELF_RELOC *rpnt,
++	Elf32_Sym *symtab, char *strtab)
++{
++	int reloc_type;
++	unsigned long *reloc_addr;
++#if defined (__SUPPORT_LD_DEBUG__)
++	unsigned long old_val;
++#endif
++
++	/* Don't care about these, just keep the compiler happy. */
++	(void) scope;
++	(void) symtab;
++	(void) strtab;
++
++	reloc_addr = (unsigned long *)(intptr_t)(tpnt->loadaddr + (unsigned long) rpnt->r_offset);
++	reloc_type = ELF32_R_TYPE(rpnt->r_info);
++
++#if defined (__SUPPORT_LD_DEBUG__)
++	old_val = *reloc_addr;
++#endif
++
++	switch (reloc_type) {
++		case R_CRIS_NONE:
++			break;
++		case R_CRIS_JUMP_SLOT:
++			*reloc_addr += (unsigned long) tpnt->loadaddr;
++			break;
++		default:
++			return -1;	/* Calls _dl_exit(1). */
++	}
++
++#if defined (__SUPPORT_LD_DEBUG__)
++	if (_dl_debug_reloc && _dl_debug_detail)
++		_dl_dprintf(_dl_debug_file, "\tpatched: %x ==> %x @ %x", old_val, *reloc_addr, reloc_addr);
++#endif
++
++	return 0;
++}
++
++static int
++_dl_do_copy_reloc(struct elf_resolve *tpnt, struct dyn_elf *scope, ELF_RELOC *rpnt,
++	Elf32_Sym *symtab, char *strtab)
++{
++	int goof;
++	int reloc_type;
++	int symtab_index;
++	char *symname;
++	unsigned long *reloc_addr;
++	unsigned long symbol_addr;
++
++	reloc_addr = (unsigned long *)(intptr_t) (tpnt->loadaddr + (unsigned long) rpnt->r_offset);
++	reloc_type = ELF32_R_TYPE(rpnt->r_info);
++
++	if (reloc_type != R_CRIS_COPY)
++		return 0;
++	
++	symtab_index = ELF32_R_SYM(rpnt->r_info);
++	symbol_addr = 0;
++	symname = strtab + symtab[symtab_index].st_name;
++	goof = 0;
++
++	if (symtab_index) {
++		symbol_addr = (unsigned long) _dl_find_hash(symname, scope, NULL, copyrel);
++
++		if (!symbol_addr)
++			goof++;
++	}
++
++	if (!goof) {
++#if defined (__SUPPORT_LD_DEBUG__)
++		if (_dl_debug_move)
++			_dl_dprintf(_dl_debug_file, "\n%s move %x bytes from %x to %x",
++				symname, symtab[symtab_index].st_size, symbol_addr, symtab[symtab_index].st_value);
++#endif
++			_dl_memcpy((char *) symtab[symtab_index].st_value,
++				(char *) symbol_addr, symtab[symtab_index].st_size);
++	}
++
++	return goof;
++}
++
++/* External interface to the generic part of the dynamic linker. */
++
++int
++_dl_parse_relocation_information(struct elf_resolve *tpnt, unsigned long rel_addr,
++	unsigned long rel_size, int type)
++{
++	/* Keep the compiler happy. */
++	(void) type;
++	return _dl_parse(tpnt, tpnt->symbol_scope, rel_addr, rel_size, _dl_do_reloc);
++}
++void
++_dl_parse_lazy_relocation_information(struct elf_resolve *tpnt, unsigned long rel_addr,
++	unsigned long rel_size, int type)
++{
++	/* Keep the compiler happy. */
++	(void) type;
++	_dl_parse(tpnt, NULL, rel_addr, rel_size, _dl_do_lazy_reloc);
++}
++
++int
++_dl_parse_copy_information(struct dyn_elf *xpnt, unsigned long rel_addr,
++	unsigned long rel_size, int type)
++{
++	/* Keep the compiler happy. */
++	(void) type;
++	return _dl_parse(xpnt->dyn, xpnt->next, rel_addr, rel_size, _dl_do_copy_reloc);
++}
+diff -urN uClibc/ldso-0.9.24/ldso/cris/ld_syscalls.h uClibc.ldso.24/ldso-0.9.24/ldso/cris/ld_syscalls.h
+--- uClibc/ldso-0.9.24/ldso/cris/ld_syscalls.h	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/cris/ld_syscalls.h	2002-09-23 05:37:16.000000000 -0500
+@@ -0,0 +1,7 @@
++/* 
++ * Define the __set_errno macro as nothing so that INLINE_SYSCALL
++ * won't set errno, which is important since we make system calls
++ * before the errno symbol is dynamicly linked. 
++ */
++#define __set_errno(X) {(void)(X);}
++#include "sys/syscall.h"
+diff -urN uClibc/ldso-0.9.24/ldso/cris/ld_sysdep.h uClibc.ldso.24/ldso-0.9.24/ldso/cris/ld_sysdep.h
+--- uClibc/ldso-0.9.24/ldso/cris/ld_sysdep.h	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/cris/ld_sysdep.h	2003-08-27 07:59:23.000000000 -0500
+@@ -0,0 +1,112 @@
++/* CRIS can never use Elf32_Rel relocations. */
++#define ELF_USES_RELOCA
++
++/*
++ * Get a pointer to the argv array.  On many platforms this can be just
++ * the address if the first argument, on other platforms we need to
++ * do something a little more subtle here.
++ */
++#define GET_ARGV(ARGVP, ARGS) ARGVP = ((unsigned long *) ARGS)
++
++/*
++ * Initialization sequence for a GOT.
++ */
++#define INIT_GOT(GOT_BASE,MODULE)				\
++{								\
++	GOT_BASE[1] = (unsigned long) MODULE; 			\
++	GOT_BASE[2] = (unsigned long) _dl_linux_resolve; 	\
++}
++
++/*
++ * Here is a macro to perform a relocation.  This is only used when
++ * bootstrapping the dynamic loader.  RELP is the relocation that we
++ * are performing, REL is the pointer to the address we are relocating.
++ * SYMBOL is the symbol involved in the relocation, and LOAD is the
++ * load address.
++ */
++#define PERFORM_BOOTSTRAP_RELOC(RELP, REL, SYMBOL, LOAD)		\
++	switch (ELF32_R_TYPE((RELP)->r_info)) {				\
++		case R_CRIS_GLOB_DAT:					\
++		case R_CRIS_JUMP_SLOT:					\
++		case R_CRIS_32:						\
++			*REL = SYMBOL;					\
++			break;						\
++		case R_CRIS_16_PCREL:					\
++			*(short *) *REL = SYMBOL + (RELP)->r_addend - *REL - 2;	\
++			break;						\
++		case R_CRIS_32_PCREL:					\
++			*REL = SYMBOL + (RELP)->r_addend - *REL - 4;	\
++			break;						\
++		case R_CRIS_NONE:					\
++			break;						\
++		case R_CRIS_RELATIVE:					\
++			*REL = (unsigned long) LOAD + (RELP)->r_addend;	\
++			break;						\
++		default:						\
++			_dl_exit(1);					\
++			break;						\
++	}
++
++/*
++ * Transfer control to the user's application once the dynamic loader
++ * is done. This routine has to exit the current function, then call
++ * _dl_elf_main.
++ */
++#define START() __asm__ volatile ("moveq 0,$r8\n\t" \
++				  "move $r8,$srp\n\t" \
++				  "move.d %1,$sp\n\t" \
++				  "jump %0\n\t" \
++				  : : "r" (_dl_elf_main), "r" (args))
++
++/* Defined some magic numbers that this ld.so should accept. */
++#define MAGIC1 EM_CRIS
++#undef MAGIC2
++#define ELF_TARGET "CRIS"
++
++struct elf_resolve;
++extern unsigned long _dl_linux_resolver(struct elf_resolve *tpnt, int reloc_entry);
++
++/* Cheap modulo implementation, taken from arm/ld_sysdep.h. */
++static inline unsigned long
++cris_mod(unsigned long m, unsigned long p)
++{
++	unsigned long i, t, inc;
++
++	i = p;
++	t = 0;
++
++	while (!(i & (1 << 31))) {
++		i <<= 1;
++		t++;
++	}
++
++	t--;
++
++	for (inc = t; inc > 2; inc--) {
++		i = p << inc;
++
++		if (i & (1 << 31))
++			break;
++
++		while (m >= i) {
++			m -= i;
++			i <<= 1;
++			if (i & (1 << 31))
++				break;
++			if (i < p)
++				break;
++		}
++	}
++
++	while (m >= p)
++		m -= p;
++
++	return m;
++}
++
++#define do_rem(result, n, base) result = cris_mod(n, base);
++
++/* 8192 bytes alignment */
++#define PAGE_ALIGN 0xffffe000
++#define ADDR_ALIGN 0x1fff
++#define OFFS_ALIGN 0xffffe000
+diff -urN uClibc/ldso-0.9.24/ldso/cris/resolve.S uClibc.ldso.24/ldso-0.9.24/ldso/cris/resolve.S
+--- uClibc/ldso-0.9.24/ldso/cris/resolve.S	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/cris/resolve.S	2002-09-16 03:11:43.000000000 -0500
+@@ -0,0 +1,48 @@
++/*
++ * This function is _not_ called directly.  It is jumped to from PLT when 
++ * attempting to use a symbol that has not yet been resolved.  The first 
++ * time a jump symbol (such as a function call inside a shared library) 
++ * is used (before it gets resolved) it will jump here.  When we get called 
++ * the stack contains reloc_offset and tpnt is in MOF.
++ *
++ * We save all the registers, setup R10 and R11 with the right arguments 
++ * then call _dl_linux_resolver(tpnt, reloc_offset). _dl_linux_resolver() 
++ * figures out where the jump symbol is _really_ supposed to have jumped to 
++ * and returns that to us.  Once we have that, we overwrite tpnt with this 
++ * fixed up address. We then clean up after ourselves, put all the registers 
++ * back how we found them, then we jump to where the fixed up address, which 
++ * is where the jump symbol that got us here really wanted to jump to in the 
++ * first place.
++ */		  
++
++.globl _dl_linux_resolve
++.type _dl_linux_resolve,@function
++
++_dl_linux_resolve:
++	push $r13
++	push $r12
++	push $r11
++	push $r10
++	push $r9
++	push $srp
++	move.d [$sp+6*4],$r11
++	move $mof,$r10
++#ifdef __PIC__
++	move.d $pc,$r0
++	sub.d .:GOTOFF,$r0
++	move.d _dl_linux_resolver:PLTG,$r9
++	add.d $r0,$r9
++	jsr $r9
++#else
++	jsr _dl_linux_resolver
++#endif
++	move.d $r10,[$sp+6*4]
++	pop $srp
++	pop $r9
++	pop $r10
++	pop $r11
++	pop $r12
++	pop $r13
++	jump [$sp+]
++
++	.size _dl_linux_resolve, . - _dl_linux_resolve
+diff -urN uClibc/ldso-0.9.24/ldso/hash.c uClibc.ldso.24/ldso-0.9.24/ldso/hash.c
+--- uClibc/ldso-0.9.24/ldso/hash.c	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/hash.c	2003-08-19 08:11:06.000000000 -0500
+@@ -0,0 +1,327 @@
++/* vi: set sw=4 ts=4: */
++/* Program to load an ELF binary on a linux system, and run it
++ * after resolving ELF shared library symbols
++ *
++ * Copyright (c) 1994-2000 Eric Youngdale, Peter MacDonald, 
++ *				David Engel, Hongjiu Lu and Mitch D'Souza
++ * Copyright (C) 2001-2002, Erik Andersen
++ *
++ * All rights reserved.
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions
++ * are met:
++ * 1. Redistributions of source code must retain the above copyright
++ *    notice, this list of conditions and the following disclaimer.
++ * 2. The name of the above contributors may not be
++ *    used to endorse or promote products derived from this software
++ *    without specific prior written permission.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND
++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ * ARE DISCLAIMED.  IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE
++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
++ * SUCH DAMAGE.
++ */
++
++
++/* Various symbol table handling functions, including symbol lookup */
++
++/*
++ * This is the start of the linked list that describes all of the files present
++ * in the system with pointers to all of the symbol, string, and hash tables, 
++ * as well as all of the other good stuff in the binary.
++ */
++
++struct elf_resolve *_dl_loaded_modules = NULL;
++
++/*
++ * This is the list of modules that are loaded when the image is first
++ * started.  As we add more via dlopen, they get added into other
++ * chains.
++ */
++struct dyn_elf *_dl_symbol_tables = NULL;
++
++/*
++ * This is the list of modules that are loaded via dlopen.  We may need
++ * to search these for RTLD_GLOBAL files.
++ */
++struct dyn_elf *_dl_handles = NULL;
++
++
++/*
++ * This is the hash function that is used by the ELF linker to generate
++ * the hash table that each executable and library is required to
++ * have.  We need it to decode the hash table.
++ */
++
++unsigned long _dl_elf_hash(const char *name)
++{
++	unsigned long hash = 0;
++	unsigned long tmp;
++
++	while (*name) {
++		hash = (hash << 4) + *name++;
++		if ((tmp = hash & 0xf0000000))
++			hash ^= tmp >> 24;
++		hash &= ~tmp;
++	};
++	return hash;
++}
++
++/*
++ * Check to see if a library has already been added to the hash chain.
++ */
++struct elf_resolve *_dl_check_hashed_files(const char *libname)
++{
++	struct elf_resolve *tpnt;
++	int len = _dl_strlen(libname);
++
++	for (tpnt = _dl_loaded_modules; tpnt; tpnt = tpnt->next) {
++		if (_dl_strncmp(tpnt->libname, libname, len) == 0 &&
++			(tpnt->libname[len] == '\0' || tpnt->libname[len] == '.'))
++			return tpnt;
++	}
++
++	return NULL;
++}
++
++/*
++ * We call this function when we have just read an ELF library or executable.
++ * We add the relevant info to the symbol chain, so that we can resolve all
++ * externals properly.
++ */
++
++struct elf_resolve *_dl_add_elf_hash_table(const char *libname, 
++	char *loadaddr, unsigned long *dynamic_info, unsigned long dynamic_addr, 
++	unsigned long dynamic_size)
++{
++	unsigned long *hash_addr;
++	struct elf_resolve *tpnt;
++	int i;
++
++	if (!_dl_loaded_modules) {
++		tpnt = _dl_loaded_modules = 
++		    (struct elf_resolve *) _dl_malloc(sizeof(struct elf_resolve));
++		_dl_memset(tpnt, 0, sizeof(struct elf_resolve));
++	} else {
++		tpnt = _dl_loaded_modules;
++		while (tpnt->next)
++			tpnt = tpnt->next;
++		tpnt->next = (struct elf_resolve *) _dl_malloc(sizeof(struct elf_resolve));
++		_dl_memset(tpnt->next, 0, sizeof(struct elf_resolve));
++		tpnt->next->prev = tpnt;
++		tpnt = tpnt->next;
++	};
++
++	tpnt->next = NULL;
++	tpnt->init_flag = 0;
++	tpnt->libname = _dl_strdup(libname);
++	tpnt->dynamic_addr = (ElfW(Dyn) *)dynamic_addr;
++	tpnt->dynamic_size = dynamic_size;
++	tpnt->libtype = loaded_file;
++
++	if (dynamic_info[DT_HASH] != 0) {
++		hash_addr = (unsigned long *) (intptr_t)(dynamic_info[DT_HASH] + loadaddr);
++		tpnt->nbucket = *hash_addr++;
++		tpnt->nchain = *hash_addr++;
++		tpnt->elf_buckets = hash_addr;
++		hash_addr += tpnt->nbucket;
++		tpnt->chains = hash_addr;
++	}
++	tpnt->loadaddr = (ElfW(Addr))loadaddr;
++	for (i = 0; i < 24; i++)
++		tpnt->dynamic_info[i] = dynamic_info[i];
++#ifdef __mips__
++	{
++		Elf32_Dyn *dpnt = (Elf32_Dyn *) dynamic_addr;
++
++		while(dpnt->d_tag) {
++			if (dpnt->d_tag == DT_MIPS_GOTSYM)
++				tpnt->mips_gotsym = dpnt->d_un.d_val;
++			if (dpnt->d_tag == DT_MIPS_LOCAL_GOTNO)
++				tpnt->mips_local_gotno = dpnt->d_un.d_val;
++			if (dpnt->d_tag == DT_MIPS_SYMTABNO)
++				tpnt->mips_symtabno = dpnt->d_un.d_val;
++			dpnt++;
++		}
++	}
++#endif
++	return tpnt;
++}
++
++
++/*
++ * This function resolves externals, and this is either called when we process
++ * relocations or when we call an entry in the PLT table for the first time.
++ */
++
++char *_dl_find_hash(const char *name, struct dyn_elf *rpnt1, 
++	struct elf_resolve *f_tpnt, enum caller_type caller_type)
++{
++	struct elf_resolve *tpnt;
++	int si;
++	char *pnt;
++	int pass;
++	char *strtab;
++	Elf32_Sym *symtab;
++	unsigned long elf_hash_number, hn;
++	char *weak_result;
++	struct elf_resolve *first_def;
++	struct dyn_elf *rpnt, first;
++	char *data_result = 0;		/* nakao */
++
++	weak_result = 0;
++	elf_hash_number = _dl_elf_hash(name);
++
++	/* A quick little hack to make sure that any symbol in the executable
++	   will be preferred to one in a shared library.  This is necessary so
++	   that any shared library data symbols referenced in the executable
++	   will be seen at the same address by the executable, shared libraries
++	   and dynamically loaded code. -Rob Ryan (robr@cmu.edu) */
++	if (_dl_symbol_tables && !caller_type && rpnt1) {
++		first = (*_dl_symbol_tables);
++		first.next = rpnt1;
++		rpnt1 = (&first);
++	}
++
++	/*
++	 * The passes are so that we can first search the regular symbols
++	 * for whatever module was specified, and then search anything
++	 * loaded with RTLD_GLOBAL.  When pass is 1, it means we are just
++	 * starting the first dlopened module, and anything above that
++	 * is just the next one in the chain.
++	 */
++	for (pass = 0; (1 == 1); pass++) {
++
++		/*
++		 * If we are just starting to search for RTLD_GLOBAL, setup
++		 * the pointer for the start of the search.
++		 */
++		if (pass == 1) {
++			rpnt1 = _dl_handles;
++		}
++
++		/*
++		 * Anything after this, we need to skip to the next module.
++		 */
++		else if (pass >= 2) {
++			rpnt1 = rpnt1->next_handle;
++		}
++
++		/*
++		 * Make sure we still have a module, and make sure that this
++		 * module was loaded with RTLD_GLOBAL.
++		 */
++		if (pass != 0) {
++			if (rpnt1 == NULL)
++				break;
++			if ((rpnt1->flags & RTLD_GLOBAL) == 0)
++				continue;
++		}
++
++		for (rpnt = (rpnt1 ? rpnt1 : _dl_symbol_tables); rpnt; rpnt = rpnt->next) {
++			tpnt = rpnt->dyn;
++
++			/*
++			 * The idea here is that if we are using dlsym, we want to
++			 * first search the entire chain loaded from dlopen, and
++			 * return a result from that if we found anything.  If this
++			 * fails, then we continue the search into the stuff loaded
++			 * when the image was activated.  For normal lookups, we start
++			 * with rpnt == NULL, so we should never hit this.  
++			 */
++			if (tpnt->libtype == elf_executable && weak_result != 0) {
++				break;
++			}
++
++			/*
++			 * Avoid calling .urem here.
++			 */
++			do_rem(hn, elf_hash_number, tpnt->nbucket);
++			symtab = (Elf32_Sym *) (intptr_t) (tpnt->dynamic_info[DT_SYMTAB] + tpnt->loadaddr);
++			strtab = (char *) (tpnt->dynamic_info[DT_STRTAB] + tpnt->loadaddr);
++			/*
++			 * This crap is required because the first instance of a
++			 * symbol on the chain will be used for all symbol references.
++			 * Thus this instance must be resolved to an address that
++			 * contains the actual function, 
++			 */
++
++			first_def = NULL;
++
++			for (si = tpnt->elf_buckets[hn]; si; si = tpnt->chains[si]) {
++				pnt = strtab + symtab[si].st_name;
++
++				if (_dl_strcmp(pnt, name) == 0 &&
++				    symtab[si].st_value != 0)
++				{
++				  if ((ELF32_ST_TYPE(symtab[si].st_info) == STT_FUNC ||
++				       ELF32_ST_TYPE(symtab[si].st_info) == STT_NOTYPE ||
++				       ELF32_ST_TYPE(symtab[si].st_info) == STT_OBJECT) &&
++				      symtab[si].st_shndx != SHN_UNDEF) {
++
++					/* Here we make sure that we find a module where the symbol is
++					 * actually defined.
++					 */
++
++					if (f_tpnt) {
++						if (!first_def)
++							first_def = tpnt;
++						if (first_def == f_tpnt
++							&& symtab[si].st_shndx == 0)
++							continue;
++					}
++
++					switch (ELF32_ST_BIND(symtab[si].st_info)) {
++					case STB_GLOBAL:
++						if (tpnt->libtype != elf_executable && 
++							ELF32_ST_TYPE(symtab[si].st_info) 
++							== STT_NOTYPE) 
++						{	/* nakao */
++							data_result = (char *)tpnt->loadaddr + 
++							    symtab[si].st_value;	/* nakao */
++							break;	/* nakao */
++						} else	/* nakao */
++							return (char*)tpnt->loadaddr + symtab[si].st_value;
++					case STB_WEAK:
++						if (!weak_result)
++							weak_result = (char *)tpnt->loadaddr + symtab[si].st_value;
++						break;
++					default:	/* Do local symbols need to be examined? */
++						break;
++					}
++				  }
++#ifndef __mips__
++				  /*
++				   * References to the address of a function from an executable file and
++				   * the shared objects associated with it might not resolve to the same
++				   * value. To allow comparisons of function addresses we must resolve
++				   * to the address of the plt entry of the executable instead of the
++				   * real function address.
++				   * see "TIS ELF Specification Version 1.2, Book 3, A-11 (Function
++				   * Adresses) 
++				   */				 
++				  if (resolver != caller_type &&
++				      NULL==f_tpnt && /*trick: don't  handle R_??_JMP_SLOT reloc type*/
++				      tpnt->libtype == elf_executable &&
++				      ELF32_ST_TYPE(symtab[si].st_info) == STT_FUNC &&
++				      symtab[si].st_shndx == SHN_UNDEF)
++				  {
++				      return (char*)symtab[si].st_value;
++				  }
++#endif
++				}
++			}
++		}
++	}
++	if (data_result)
++		return data_result;		/* nakao */
++	return weak_result;
++}
+diff -urN uClibc/ldso-0.9.24/ldso/i386/boot1_arch.h uClibc.ldso.24/ldso-0.9.24/ldso/i386/boot1_arch.h
+--- uClibc/ldso-0.9.24/ldso/i386/boot1_arch.h	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/i386/boot1_arch.h	2002-08-08 09:35:31.000000000 -0500
+@@ -0,0 +1,7 @@
++/* Any assmbly language/system dependent hacks needed to setup boot1.c so it
++ * will work as expected and cope with whatever platform specific wierdness is
++ * needed for this architecture.  See arm/boot1_arch.h for an example of what
++ * can be done.
++ */
++
++#define LD_BOOT(X)   void _dl_boot (X)
+diff -urN uClibc/ldso-0.9.24/ldso/i386/elfinterp.c uClibc.ldso.24/ldso-0.9.24/ldso/i386/elfinterp.c
+--- uClibc/ldso-0.9.24/ldso/i386/elfinterp.c	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/i386/elfinterp.c	2003-11-06 16:09:38.000000000 -0600
+@@ -0,0 +1,415 @@
++/* vi: set sw=4 ts=4: */
++/* i386 ELF shared library loader suppport
++ *
++ * Copyright (c) 1994-2000 Eric Youngdale, Peter MacDonald, 
++ *				David Engel, Hongjiu Lu and Mitch D'Souza
++ * Copyright (C) 2001-2002, Erik Andersen
++ *
++ * All rights reserved.
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions
++ * are met:
++ * 1. Redistributions of source code must retain the above copyright
++ *    notice, this list of conditions and the following disclaimer.
++ * 2. The name of the above contributors may not be
++ *    used to endorse or promote products derived from this software
++ *    without specific prior written permission.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND
++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ * ARE DISCLAIMED.  IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE
++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
++ * SUCH DAMAGE.
++ */
++
++#if defined (__SUPPORT_LD_DEBUG__)
++static const char *_dl_reltypes_tab[] =
++{
++  [0]	"R_386_NONE",	    "R_386_32",	    "R_386_PC32",	"R_386_GOT32",
++  [4]	"R_386_PLT32",	    "R_386_COPY",   "R_386_GLOB_DAT",	"R_386_JMP_SLOT",
++  [8]	"R_386_RELATIVE",   "R_386_GOTOFF", "R_386_GOTPC",
++};
++
++static const char *
++_dl_reltypes(int type)
++{
++  static char buf[22];  
++  const char *str;
++  
++  if (type >= (int)(sizeof (_dl_reltypes_tab)/sizeof(_dl_reltypes_tab[0])) ||
++      NULL == (str = _dl_reltypes_tab[type]))
++  {
++    str =_dl_simple_ltoa( buf, (unsigned long)(type));
++  }
++  return str;
++}
++
++static 
++void debug_sym(Elf32_Sym *symtab,char *strtab,int symtab_index)
++{
++  if(_dl_debug_symbols)
++  {
++    if(symtab_index){
++      _dl_dprintf(_dl_debug_file, "\n%s\n\tvalue=%x\tsize=%x\tinfo=%x\tother=%x\tshndx=%x",
++		  strtab + symtab[symtab_index].st_name,
++		  symtab[symtab_index].st_value,
++		  symtab[symtab_index].st_size,
++		  symtab[symtab_index].st_info,
++		  symtab[symtab_index].st_other,
++		  symtab[symtab_index].st_shndx);
++    }
++  }
++}
++
++static void debug_reloc(Elf32_Sym *symtab,char *strtab, ELF_RELOC *rpnt)
++{
++  if(_dl_debug_reloc)
++  {
++    int symtab_index;
++    const char *sym;
++    symtab_index = ELF32_R_SYM(rpnt->r_info);
++    sym = symtab_index ? strtab + symtab[symtab_index].st_name : "sym=0x0";
++    
++  if(_dl_debug_symbols)
++	  _dl_dprintf(_dl_debug_file, "\n\t");
++  else
++	  _dl_dprintf(_dl_debug_file, "\n%s\n\t", sym);
++#ifdef ELF_USES_RELOCA
++    _dl_dprintf(_dl_debug_file, "%s\toffset=%x\taddend=%x",
++		_dl_reltypes(ELF32_R_TYPE(rpnt->r_info)),
++		rpnt->r_offset,
++		rpnt->r_addend);
++#else
++    _dl_dprintf(_dl_debug_file, "%s\toffset=%x\n",
++		_dl_reltypes(ELF32_R_TYPE(rpnt->r_info)),
++		rpnt->r_offset);
++#endif
++  }
++}
++#endif
++
++/* Program to load an ELF binary on a linux system, and run it.
++   References to symbols in sharable libraries can be resolved by either
++   an ELF sharable library or a linux style of shared library. */
++
++/* Disclaimer:  I have never seen any AT&T source code for SVr4, nor have
++   I ever taken any courses on internals.  This program was developed using
++   information available through the book "UNIX SYSTEM V RELEASE 4,
++   Programmers guide: Ansi C and Programming Support Tools", which did
++   a more than adequate job of explaining everything required to get this
++   working. */
++
++extern int _dl_linux_resolve(void);
++
++unsigned long _dl_linux_resolver(struct elf_resolve *tpnt, int reloc_entry)
++{
++	int reloc_type;
++	ELF_RELOC *this_reloc;
++	char *strtab;
++	Elf32_Sym *symtab;
++	int symtab_index;
++	char *rel_addr;
++	char *new_addr;
++	char **got_addr;
++	unsigned long instr_addr;
++	char *symname;
++
++	rel_addr = (char *) (tpnt->dynamic_info[DT_JMPREL] + tpnt->loadaddr);
++
++	this_reloc = (ELF_RELOC *)(intptr_t)(rel_addr + reloc_entry);
++	reloc_type = ELF32_R_TYPE(this_reloc->r_info);
++	symtab_index = ELF32_R_SYM(this_reloc->r_info);
++
++	symtab = (Elf32_Sym *)(intptr_t) (tpnt->dynamic_info[DT_SYMTAB] + tpnt->loadaddr);
++	strtab = (char *) (tpnt->dynamic_info[DT_STRTAB] + tpnt->loadaddr);
++	symname= strtab + symtab[symtab_index].st_name;
++
++	if (reloc_type != R_386_JMP_SLOT) {
++		_dl_dprintf(2, "%s: Incorrect relocation type in jump relocations\n", 
++				_dl_progname);
++		_dl_exit(1);
++	}
++
++	/* Address of jump instruction to fix up */
++	instr_addr = ((unsigned long) this_reloc->r_offset + 
++			(unsigned long) tpnt->loadaddr);
++	got_addr = (char **) instr_addr;
++
++	/* Get the address of the GOT entry */
++	new_addr = _dl_find_hash(symname, tpnt->symbol_scope, tpnt, resolver);
++	if (!new_addr) {
++		new_addr = _dl_find_hash(symname, NULL, NULL, resolver);
++		if (new_addr) {
++			return (unsigned long) new_addr;
++		}
++		_dl_dprintf(2, "%s: can't resolve symbol '%s'\n", _dl_progname, symname);
++		_dl_exit(1);
++	}
++
++#if defined (__SUPPORT_LD_DEBUG__)
++	if ((unsigned long) got_addr < 0x40000000)
++	{
++		if (_dl_debug_bindings)
++		{
++			_dl_dprintf(_dl_debug_file, "\nresolve function: %s", symname);
++			if(_dl_debug_detail) _dl_dprintf(_dl_debug_file, 
++					"\n\tpatched %x ==> %x @ %x\n", *got_addr, new_addr, got_addr);
++		}
++	}
++	if (!_dl_debug_nofixups) {
++		*got_addr = new_addr;
++	}
++#else
++	*got_addr = new_addr;
++#endif
++
++	return (unsigned long) new_addr;
++}
++
++static int
++_dl_parse(struct elf_resolve *tpnt, struct dyn_elf *scope,
++	  unsigned long rel_addr, unsigned long rel_size,
++	  int (*reloc_fnc) (struct elf_resolve *tpnt, struct dyn_elf *scope,
++			    ELF_RELOC *rpnt, Elf32_Sym *symtab, char *strtab))
++{
++	unsigned int i;
++	char *strtab;
++	Elf32_Sym *symtab;
++	ELF_RELOC *rpnt;
++	int symtab_index;
++
++	/* Now parse the relocation information */
++	rpnt = (ELF_RELOC *)(intptr_t) (rel_addr + tpnt->loadaddr);
++	rel_size = rel_size / sizeof(ELF_RELOC);
++
++	symtab = (Elf32_Sym *)(intptr_t) (tpnt->dynamic_info[DT_SYMTAB] + tpnt->loadaddr);
++	strtab = (char *) (tpnt->dynamic_info[DT_STRTAB] + tpnt->loadaddr);
++
++	  for (i = 0; i < rel_size; i++, rpnt++) {
++	        int res;
++	    
++		symtab_index = ELF32_R_SYM(rpnt->r_info);
++		
++		/* When the dynamic linker bootstrapped itself, it resolved some symbols.
++		   Make sure we do not do them again */
++		if (!symtab_index && tpnt->libtype == program_interpreter)
++			continue;
++		if (symtab_index && tpnt->libtype == program_interpreter &&
++		    _dl_symbol(strtab + symtab[symtab_index].st_name))
++			continue;
++
++#if defined (__SUPPORT_LD_DEBUG__)
++		debug_sym(symtab,strtab,symtab_index);
++		debug_reloc(symtab,strtab,rpnt);
++#endif
++
++		res = reloc_fnc (tpnt, scope, rpnt, symtab, strtab);
++
++		if (res==0) continue;
++
++		_dl_dprintf(2, "\n%s: ",_dl_progname);
++		
++		if (symtab_index)
++		  _dl_dprintf(2, "symbol '%s': ", strtab + symtab[symtab_index].st_name);
++		  
++		if (res <0)
++		{
++		        int reloc_type = ELF32_R_TYPE(rpnt->r_info);
++#if defined (__SUPPORT_LD_DEBUG__)
++			_dl_dprintf(2, "can't handle reloc type %s\n ", _dl_reltypes(reloc_type));
++#else
++			_dl_dprintf(2, "can't handle reloc type %x\n", reloc_type);
++#endif			
++			_dl_exit(-res);
++		}
++		else if (res >0)
++		{
++			_dl_dprintf(2, "can't resolve symbol\n");
++			return res;
++		}
++	  }
++	  return 0;
++}
++
++
++static int
++_dl_do_reloc (struct elf_resolve *tpnt,struct dyn_elf *scope,
++	      ELF_RELOC *rpnt, Elf32_Sym *symtab, char *strtab)
++{
++	int reloc_type;
++	int symtab_index;
++	char *symname;
++	unsigned long *reloc_addr;
++	unsigned long symbol_addr;
++#if defined (__SUPPORT_LD_DEBUG__)
++	unsigned long old_val;
++#endif
++
++	reloc_addr   = (unsigned long *)(intptr_t) (tpnt->loadaddr + (unsigned long) rpnt->r_offset);
++	reloc_type   = ELF32_R_TYPE(rpnt->r_info);
++	symtab_index = ELF32_R_SYM(rpnt->r_info);
++	symbol_addr  = 0;
++	symname      = strtab + symtab[symtab_index].st_name;
++
++	if (symtab_index) {
++
++		symbol_addr = (unsigned long) _dl_find_hash(symname, scope, 
++				(reloc_type == R_386_JMP_SLOT ? tpnt : NULL), symbolrel);
++
++		/*
++		 * We want to allow undefined references to weak symbols - this might
++		 * have been intentional.  We should not be linking local symbols
++		 * here, so all bases should be covered.
++		 */
++
++		if (!symbol_addr && ELF32_ST_BIND(symtab[symtab_index].st_info) == STB_GLOBAL) {
++#if defined (__SUPPORT_LD_DEBUG__)
++			_dl_dprintf(2, "\tglobal symbol '%s' already defined in '%s'\n",
++					symname, tpnt->libname);
++#endif
++			return 0;
++		}
++	}
++
++#if defined (__SUPPORT_LD_DEBUG__)
++	old_val = *reloc_addr;
++#endif
++		switch (reloc_type) {
++			case R_386_NONE:
++				break;
++			case R_386_32:
++				*reloc_addr += symbol_addr;
++				break;
++			case R_386_PC32:
++				*reloc_addr += symbol_addr - (unsigned long) reloc_addr;
++				break;
++			case R_386_GLOB_DAT:
++			case R_386_JMP_SLOT:
++				*reloc_addr = symbol_addr;
++				break;
++			case R_386_RELATIVE:
++				*reloc_addr += (unsigned long) tpnt->loadaddr;
++				break;
++			case R_386_COPY:
++				/* handled later on */
++				break;
++			default:
++				return -1; /*call _dl_exit(1) */
++		}
++#if defined (__SUPPORT_LD_DEBUG__)
++	if(_dl_debug_reloc && _dl_debug_detail)
++		_dl_dprintf(_dl_debug_file, "\tpatched: %x ==> %x @ %x", old_val, *reloc_addr, reloc_addr);
++#endif
++
++	return 0;
++}
++
++static int
++_dl_do_lazy_reloc (struct elf_resolve *tpnt, struct dyn_elf *scope,
++		   ELF_RELOC *rpnt, Elf32_Sym *symtab, char *strtab)
++{
++	int reloc_type;
++	unsigned long *reloc_addr;
++#if defined (__SUPPORT_LD_DEBUG__)
++	unsigned long old_val;
++#endif
++	(void)scope;
++	(void)symtab;
++	(void)strtab;
++
++	reloc_addr = (unsigned long *)(intptr_t) (tpnt->loadaddr + (unsigned long) rpnt->r_offset);
++	reloc_type = ELF32_R_TYPE(rpnt->r_info);
++
++#if defined (__SUPPORT_LD_DEBUG__)
++	old_val = *reloc_addr;
++#endif
++		switch (reloc_type) {
++			case R_386_NONE:
++				break;
++			case R_386_JMP_SLOT:
++				*reloc_addr += (unsigned long) tpnt->loadaddr;
++				break;
++			default:
++				return -1; /*call _dl_exit(1) */
++		}
++#if defined (__SUPPORT_LD_DEBUG__)
++	if(_dl_debug_reloc && _dl_debug_detail)
++		_dl_dprintf(_dl_debug_file, "\tpatched: %x ==> %x @ %x", old_val, *reloc_addr, reloc_addr);
++#endif
++	return 0;
++
++}
++
++/* This is done as a separate step, because there are cases where
++   information is first copied and later initialized.  This results in
++   the wrong information being copied.  Someone at Sun was complaining about
++   a bug in the handling of _COPY by SVr4, and this may in fact be what he
++   was talking about.  Sigh. */
++
++/* No, there are cases where the SVr4 linker fails to emit COPY relocs
++   at all */
++static int
++_dl_do_copy (struct elf_resolve *tpnt, struct dyn_elf *scope,
++	     ELF_RELOC *rpnt, Elf32_Sym *symtab, char *strtab)
++{
++	int reloc_type;
++	int symtab_index;
++	unsigned long *reloc_addr;
++	unsigned long symbol_addr;
++	int goof = 0;
++	char *symname;
++	  
++	reloc_addr = (unsigned long *)(intptr_t) (tpnt->loadaddr + (unsigned long) rpnt->r_offset);
++	reloc_type = ELF32_R_TYPE(rpnt->r_info);
++	if (reloc_type != R_386_COPY) 
++		return 0;
++	symtab_index = ELF32_R_SYM(rpnt->r_info);
++	symbol_addr = 0;
++	symname      = strtab + symtab[symtab_index].st_name;
++		
++	if (symtab_index) {
++		symbol_addr = (unsigned long) _dl_find_hash(symname, scope, NULL, copyrel);
++		if (!symbol_addr) goof++;
++	}
++	if (!goof) {
++#if defined (__SUPPORT_LD_DEBUG__)
++	        if(_dl_debug_move)
++		  _dl_dprintf(_dl_debug_file,"\n%s move %x bytes from %x to %x",
++			     symname, symtab[symtab_index].st_size,
++			     symbol_addr, symtab[symtab_index].st_value);
++#endif
++		_dl_memcpy((char *) symtab[symtab_index].st_value, 
++			(char *) symbol_addr, symtab[symtab_index].st_size);
++	}
++
++	return goof;
++}
++
++void _dl_parse_lazy_relocation_information(struct elf_resolve *tpnt, 
++	unsigned long rel_addr, unsigned long rel_size, int type)
++{
++	(void) type;
++	(void)_dl_parse(tpnt, NULL, rel_addr, rel_size, _dl_do_lazy_reloc);
++}
++
++int _dl_parse_relocation_information(struct elf_resolve *tpnt, 
++	unsigned long rel_addr, unsigned long rel_size, int type)
++{
++	(void) type;
++	return _dl_parse(tpnt, tpnt->symbol_scope, rel_addr, rel_size, _dl_do_reloc);
++}
++
++int _dl_parse_copy_information(struct dyn_elf *xpnt, unsigned long rel_addr, 
++	unsigned long rel_size, int type)
++{
++	(void) type;
++	return _dl_parse(xpnt->dyn, xpnt->next, rel_addr, rel_size, _dl_do_copy);
++}
++
+diff -urN uClibc/ldso-0.9.24/ldso/i386/ld_syscalls.h uClibc.ldso.24/ldso-0.9.24/ldso/i386/ld_syscalls.h
+--- uClibc/ldso-0.9.24/ldso/i386/ld_syscalls.h	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/i386/ld_syscalls.h	2002-08-09 07:20:21.000000000 -0500
+@@ -0,0 +1,7 @@
++/* Define the __set_errno macro as nothing so that INLINE_SYSCALL
++ * won't set errno, which is important since we make system calls
++ * before the errno symbol is dynamicly linked. */
++
++#define __set_errno(X) {(void)(X);}
++#include "sys/syscall.h"
++
+diff -urN uClibc/ldso-0.9.24/ldso/i386/ld_sysdep.h uClibc.ldso.24/ldso-0.9.24/ldso/i386/ld_sysdep.h
+--- uClibc/ldso-0.9.24/ldso/i386/ld_sysdep.h	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/i386/ld_sysdep.h	2002-05-28 16:33:32.000000000 -0500
+@@ -0,0 +1,81 @@
++/*
++ * Various assmbly language/system dependent  hacks that are required
++ * so that we can minimize the amount of platform specific code.
++ */
++
++/*
++ * Define this if the system uses RELOCA.
++ */
++#undef ELF_USES_RELOCA
++
++/*
++ * Get a pointer to the argv array.  On many platforms this can be just
++ * the address if the first argument, on other platforms we need to
++ * do something a little more subtle here.
++ */
++#define GET_ARGV(ARGVP, ARGS) ARGVP = ((unsigned long*) & ARGS)
++
++/*
++ * Initialization sequence for a GOT.
++ */
++#define INIT_GOT(GOT_BASE,MODULE) \
++{				\
++  GOT_BASE[2] = (unsigned long) _dl_linux_resolve; \
++  GOT_BASE[1] = (unsigned long) MODULE; \
++}
++
++/*
++ * Here is a macro to perform a relocation.  This is only used when
++ * bootstrapping the dynamic loader.  RELP is the relocation that we
++ * are performing, REL is the pointer to the address we are relocating.
++ * SYMBOL is the symbol involved in the relocation, and LOAD is the
++ * load address.
++ */
++#define PERFORM_BOOTSTRAP_RELOC(RELP,REL,SYMBOL,LOAD) \
++	switch(ELF32_R_TYPE((RELP)->r_info)){		\
++	case R_386_32:		\
++	  *REL += SYMBOL;		\
++	  break;		\
++	case R_386_PC32:		\
++	  *REL += SYMBOL - (unsigned long) REL;		\
++	  break;		\
++	case R_386_GLOB_DAT:		\
++	case R_386_JMP_SLOT:		\
++	  *REL = SYMBOL;		\
++	  break;		\
++	case R_386_RELATIVE:		\
++	  *REL += (unsigned long) LOAD;		\
++	  break;		\
++	default:		\
++	  _dl_exit(1);		\
++	}
++
++
++/*
++ * Transfer control to the user's application, once the dynamic loader
++ * is done.  This routine has to exit the current function, then 
++ * call the _dl_elf_main function.
++ */
++#define START()		\
++	__asm__ volatile ("leave\n\t" \
++		    "jmp *%%eax\n\t"	\
++		    : "=a" (status) :	"a" (_dl_elf_main))
++
++
++
++/* Here we define the magic numbers that this dynamic loader should accept */
++
++#define MAGIC1 EM_386
++#undef  MAGIC2
++/* Used for error messages */
++#define ELF_TARGET "386"
++
++struct elf_resolve;
++extern unsigned long _dl_linux_resolver(struct elf_resolve * tpnt, int reloc_entry);
++
++#define do_rem(result, n, base)  result = (n % base)
++
++/* 4096 bytes alignment */
++#define PAGE_ALIGN 0xfffff000
++#define ADDR_ALIGN 0xfff
++#define OFFS_ALIGN 0x7ffff000
+diff -urN uClibc/ldso-0.9.24/ldso/i386/resolve.S uClibc.ldso.24/ldso-0.9.24/ldso/i386/resolve.S
+--- uClibc/ldso-0.9.24/ldso/i386/resolve.S	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/i386/resolve.S	2001-06-14 16:51:51.000000000 -0500
+@@ -0,0 +1,52 @@
++/*
++ * This function is _not_ called directly.  It is jumped to (so no return
++ * address is on the stack) when attempting to use a symbol that has not yet
++ * been resolved.  The first time a jump symbol (such as a function call inside
++ * a shared library) is used (before it gets resolved) it will jump here to
++ * _dl_linux_resolve.  When we get called the stack looks like this:
++ *	reloc_entry
++ *	tpnt
++ *
++ * This function saves all the registers, puts a copy of reloc_entry and tpnt
++ * on the stack (as function arguments) then make the function call
++ * _dl_linux_resolver(tpnt, reloc_entry).  _dl_linux_resolver() figures out
++ * where the jump symbol is _really_ supposed to have jumped to and returns
++ * that to us.  Once we have that, we overwrite tpnt with this fixed up
++ * address. We then clean up after ourselves, put all the registers back how we
++ * found them, then we jump to where the fixed up address, which is where the
++ * jump symbol that got us here really wanted to jump to in the first place.
++ * found them, then we jump to the fixed up address, which is where the jump
++ * symbol that got us here really wanted to jump to in the first place.  
++ *  -Erik Andersen
++ */
++
++.text
++.align 4
++
++.globl _dl_linux_resolve
++.type	_dl_linux_resolve,@function
++
++_dl_linux_resolve:
++	pusha				/* preserve all regs */
++	lea	0x20(%esp),%eax		/* eax = tpnt and reloc_entry params */
++	pushl	4(%eax)			/* push copy of reloc_entry param */
++	pushl	(%eax)			/* push copy of tpnt param */
++					 
++#ifdef __PIC__
++	call	.L24
++.L24:
++	popl	%ebx
++	addl	$_GLOBAL_OFFSET_TABLE_+[.-.L24],%ebx
++	movl _dl_linux_resolver@GOT(%ebx),%ebx	/* eax = resolved func */
++	call *%ebx
++#else
++	call _dl_linux_resolver
++#endif
++	movl	%eax,0x28(%esp)		/* store func addr over original
++					 * tpnt param */
++	addl	$0x8,%esp		/* remove copy parameters */
++	popa				/* restore regs */
++	ret	$4			/* jump to func removing original
++					 * reloc_entry param from stack */
++.LFE2:
++	.size _dl_linux_resolve,.LFE2-_dl_linux_resolve
+diff -urN uClibc/ldso-0.9.24/ldso/ldso.c uClibc.ldso.24/ldso-0.9.24/ldso/ldso.c
+--- uClibc/ldso-0.9.24/ldso/ldso.c	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/ldso.c	2003-12-05 14:24:26.000000000 -0600
+@@ -0,0 +1,1296 @@
++/* vi: set sw=4 ts=4: */
++/* Program to load an ELF binary on a linux system, and run it
++ * after resolving ELF shared library symbols
++ *
++ * Copyright (c) 1994-2000 Eric Youngdale, Peter MacDonald, 
++ *				David Engel, Hongjiu Lu and Mitch D'Souza
++ * Copyright (C) 2001-2002, Erik Andersen
++ *
++ * All rights reserved.
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions
++ * are met:
++ * 1. Redistributions of source code must retain the above copyright
++ *    notice, this list of conditions and the following disclaimer.
++ * 2. The name of the above contributors may not be
++ *    used to endorse or promote products derived from this software
++ *    without specific prior written permission.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND
++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ * ARE DISCLAIMED.  IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE
++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
++ * SUCH DAMAGE.
++ */
++
++// Support a list of library preloads in /etc/ld.so.preload
++//#define SUPPORT_LDSO_PRELOAD_FILE
++
++
++/* Disclaimer:  I have never seen any AT&T source code for SVr4, nor have
++   I ever taken any courses on internals.  This program was developed using
++   information available through the book "UNIX SYSTEM V RELEASE 4,
++   Programmers guide: Ansi C and Programming Support Tools", which did
++   a more than adequate job of explaining everything required to get this
++   working. */
++
++/*
++ * The main trick with this program is that initially, we ourselves are
++ * not dynamicly linked.  This means that we cannot access any global
++ * variables or call any functions.  No globals initially, since the
++ * Global Offset Table (GOT) is initialized by the linker assuming a
++ * virtual address of 0, and no function calls initially since the
++ * Procedure Linkage Table (PLT) is not yet initialized.
++ *
++ * There are additional initial restrictions - we cannot use large
++ * switch statements, since the compiler generates tables of addresses
++ * and jumps through them.  We can use inline functions, because these
++ * do not transfer control to a new address, but they must be static so
++ * that they are not exported from the modules.  We cannot use normal
++ * syscall stubs, because these all reference the errno global variable
++ * which is not yet initialized.  We can use all of the local stack
++ * variables that we want.
++ *
++ * Life is further complicated by the fact that initially we do not
++ * want to do a complete dynamic linking.  We want to allow the user to
++ * supply new functions to override symbols (i.e. weak symbols and/or
++ * LD_PRELOAD).  So initially, we only perform relocations for
++ * variables that start with "_dl_" since ANSI specifies that the user
++ * is not supposed to redefine any of these variables.
++ *
++ * Fortunately, the linker itself leaves a few clues lying around, and
++ * when the kernel starts the image, there are a few further clues.
++ * First of all, there is Auxiliary Vector Table information sitting on
++ * which is provided to us by the kernel, and which includes
++ * information about the load address that the program interpreter was
++ * loaded at, the number of sections, the address the application was
++ * loaded at and so forth.  Here this information is stored in the
++ * array auxvt.  For details see linux/fs/binfmt_elf.c where it calls
++ * NEW_AUX_ENT() a bunch of time....
++ *
++ * Next, we need to find the GOT.  On most arches there is a register
++ * pointing to the GOT, but just in case (and for new ports) I've added
++ * some (slow) C code to locate the GOT for you. 
++ *
++ * This code was originally written for SVr4, and there the kernel
++ * would load all text pages R/O, so they needed to call mprotect a
++ * zillion times to mark all text pages as writable so dynamic linking
++ * would succeed.  Then when they were done, they would change the
++ * protections for all the pages back again.  Well, under Linux
++ * everything is loaded writable (since Linux does copy on write
++ * anyways) so all the mprotect stuff has been disabled.
++ *
++ * Initially, we do not have access to _dl_malloc since we can't yet
++ * make function calls, so we mmap one page to use as scratch space.
++ * Later on, when we can call _dl_malloc we reuse this this memory.
++ * This is also beneficial, since we do not want to use the same memory
++ * pool as malloc anyway - esp if the user redefines malloc to do
++ * something funky.
++ *
++ * Our first task is to perform a minimal linking so that we can call
++ * other portions of the dynamic linker.  Once we have done this, we
++ * then build the list of modules that the application requires, using
++ * LD_LIBRARY_PATH if this is not a suid program (/usr/lib otherwise).
++ * Once this is done, we can do the dynamic linking as required, and we
++ * must omit the things we did to get the dynamic linker up and running
++ * in the first place.  After we have done this, we just have a few
++ * housekeeping chores and we can transfer control to the user's
++ * application.
++ */
++
++#include "ldso.h"
++
++
++#define ALLOW_ZERO_PLTGOT
++
++/*  Some arches may need to override this in boot1_arch.h */
++#define	    ELFMAGIC	ELFMAG
++
++/* This is a poor man's malloc, used prior to resolving our internal poor man's malloc */
++#define LD_MALLOC(SIZE) ((void *) (malloc_buffer += SIZE, malloc_buffer - SIZE)) ;  REALIGN();
++/*
++ * Make sure that the malloc buffer is aligned on 4 byte boundary.  For 64 bit
++ * platforms we may need to increase this to 8, but this is good enough for
++ * now.  This is typically called after LD_MALLOC.
++ */
++#define REALIGN() malloc_buffer = (char *) (((unsigned long) malloc_buffer + 3) & ~(3))
++
++char *_dl_library_path = 0;		/* Where we look for libraries */
++char *_dl_preload = 0;			/* Things to be loaded before the libs. */
++char *_dl_ldsopath = 0;
++static int _dl_be_lazy = RTLD_LAZY;
++#ifdef __SUPPORT_LD_DEBUG__
++char *_dl_debug  = 0;
++char *_dl_debug_symbols = 0;
++char *_dl_debug_move    = 0;
++char *_dl_debug_reloc   = 0;
++char *_dl_debug_detail  = 0;
++char *_dl_debug_nofixups  = 0;
++char *_dl_debug_bindings  = 0;
++int   _dl_debug_file = 2;
++#else
++#define _dl_debug_file 2
++#endif
++static char *_dl_malloc_addr, *_dl_mmap_zero;
++
++static char *_dl_trace_loaded_objects = 0;
++static int (*_dl_elf_main) (int, char **, char **);
++struct r_debug *_dl_debug_addr = NULL;
++unsigned long *_dl_brkp;
++unsigned long *_dl_envp;
++int _dl_fixup(struct elf_resolve *tpnt, int lazy);
++void _dl_debug_state(void);
++char *_dl_get_last_path_component(char *path);
++static void _dl_get_ready_to_run(struct elf_resolve *tpnt, struct elf_resolve *app_tpnt, 
++		unsigned long load_addr, unsigned long *hash_addr, Elf32_auxv_t auxvt[AT_EGID + 1], 
++		char **envp, struct r_debug *debug_addr);
++
++#include "boot1_arch.h"
++#include "_dl_progname.h"				/* Pull in the value of _dl_progname */
++
++/* When we enter this piece of code, the program stack looks like this:
++        argc            argument counter (integer)
++        argv[0]         program name (pointer)
++        argv[1...N]     program args (pointers)
++        argv[argc-1]    end of args (integer)
++		NULL
++        env[0...N]      environment variables (pointers)
++        NULL
++		auxvt[0...N]   Auxiliary Vector Table elements (mixed types)
++*/
++
++#ifdef __SUPPORT_LD_DEBUG_EARLY__
++/* Debugging is especially tricky on PowerPC, since string literals
++ * require relocations.  Thus, you can't use _dl_dprintf() for
++ * anything until the bootstrap relocations are finished. */
++static inline void hexprint(unsigned long x)
++{
++	int i;
++	char c;
++
++	for (i = 0; i < 8; i++) {
++		c = ((x >> 28) + '0');
++		if (c > '9')
++			c += 'a' - '9' - 1;
++		_dl_write(1, &c, 1);
++		x <<= 4;
++	}
++	c = '\n';
++	_dl_write(1, &c, 1);
++}
++#endif
++
++LD_BOOT(unsigned long args) __attribute__ ((unused));
++
++LD_BOOT(unsigned long args)
++{
++	unsigned int argc;
++	char **argv, **envp;
++	unsigned long load_addr;
++	unsigned long *got;
++	unsigned long *aux_dat;
++	int goof = 0;
++	ElfW(Ehdr) *header;
++	struct elf_resolve *tpnt;
++	struct elf_resolve *app_tpnt;
++	Elf32_auxv_t auxvt[AT_EGID + 1];
++	unsigned char *malloc_buffer, *mmap_zero;
++	Elf32_Dyn *dpnt;
++	unsigned long *hash_addr;
++	struct r_debug *debug_addr = NULL;
++	int indx;
++	int status;
++
++
++	/* WARNING! -- we cannot make _any_ funtion calls until we have
++	 * taken care of fixing up our own relocations.  Making static
++	 * inline calls is ok, but _no_ function calls.  Not yet
++	 * anyways. */
++
++	/* First obtain the information on the stack that tells us more about
++	   what binary is loaded, where it is loaded, etc, etc */
++	GET_ARGV(aux_dat, args);
++#if defined (__arm__) || defined (__mips__) || defined (__cris__)
++	aux_dat += 1;
++#endif
++	argc = *(aux_dat - 1);
++	argv = (char **) aux_dat;
++	aux_dat += argc;			/* Skip over the argv pointers */
++	aux_dat++;					/* Skip over NULL at end of argv */
++	envp = (char **) aux_dat;
++	while (*aux_dat)
++		aux_dat++;				/* Skip over the envp pointers */
++	aux_dat++;					/* Skip over NULL at end of envp */
++
++	/* Place -1 here as a checkpoint.  We later check if it was changed
++	 * when we read in the auxvt */
++	auxvt[AT_UID].a_type = -1;
++
++	/* The junk on the stack immediately following the environment is  
++	 * the Auxiliary Vector Table.  Read out the elements of the auxvt,
++	 * sort and store them in auxvt for later use. */
++	while (*aux_dat) {
++		Elf32_auxv_t *auxv_entry = (Elf32_auxv_t *) aux_dat;
++
++		if (auxv_entry->a_type <= AT_EGID) {
++			_dl_memcpy(&(auxvt[auxv_entry->a_type]), auxv_entry, sizeof(Elf32_auxv_t));
++		}
++		aux_dat += 2;
++	}
++
++	/* locate the ELF header.   We need this done as soon as possible 
++	 * (esp since SEND_STDERR() needs this on some platforms... */
++	load_addr = auxvt[AT_BASE].a_un.a_val;
++	header = (ElfW(Ehdr) *) auxvt[AT_BASE].a_un.a_ptr;
++
++	/* Check the ELF header to make sure everything looks ok.  */
++	if (!header || header->e_ident[EI_CLASS] != ELFCLASS32 ||
++		header->e_ident[EI_VERSION] != EV_CURRENT
++#if !defined(__powerpc__) && !defined(__mips__) && !defined(__sh__)
++		|| _dl_strncmp((void *) header, ELFMAGIC, SELFMAG) != 0
++#else
++	        || header->e_ident[EI_MAG0] != ELFMAG0
++	        || header->e_ident[EI_MAG1] != ELFMAG1
++	        || header->e_ident[EI_MAG2] != ELFMAG2
++	        || header->e_ident[EI_MAG3] != ELFMAG3
++#endif
++		) {
++		SEND_STDERR("Invalid ELF header\n");
++		_dl_exit(0);
++	}
++#ifdef __SUPPORT_LD_DEBUG_EARLY__
++	SEND_STDERR("ELF header=");
++	SEND_ADDRESS_STDERR(load_addr, 1);
++#endif
++
++
++	/* Locate the global offset table.  Since this code must be PIC  
++	 * we can take advantage of the magic offset register, if we
++	 * happen to know what that is for this architecture.  If not,
++	 * we can always read stuff out of the ELF file to find it... */
++#if defined(__i386__)
++  __asm__("\tmovl %%ebx,%0\n\t":"=a"(got));
++#elif defined(__m68k__)
++  __asm__("movel %%a5,%0":"=g"(got))
++#elif defined(__sparc__)
++  __asm__("\tmov %%l7,%0\n\t":"=r"(got))
++#elif defined(__arm__)
++  __asm__("\tmov %0, r10\n\t":"=r"(got));
++#elif defined(__powerpc__)
++  __asm__("\tbl _GLOBAL_OFFSET_TABLE_-4@local\n\t":"=l"(got));
++#elif defined(__mips__)
++  __asm__("\tmove %0, $28\n\tsubu %0,%0,0x7ff0\n\t":"=r"(got));
++#elif defined(__sh__)
++  __asm__(
++"       mov.l    1f, %0\n"
++"       mova     1f, r0\n"
++"       bra      2f\n"
++"       add r0,  %0\n"
++"       .balign  4\n"
++"1:     .long    _GLOBAL_OFFSET_TABLE_\n"
++"2:" : "=r" (got) : : "r0");
++#elif defined(__cris__)
++  __asm__("\tmove.d $pc,%0\n\tsub.d .:GOTOFF,%0\n\t":"=r"(got));
++#else
++	/* Do things the slow way in C */
++	{
++		unsigned long tx_reloc;
++		Elf32_Dyn *dynamic = NULL;
++		Elf32_Shdr *shdr;
++		Elf32_Phdr *pt_load;
++
++#ifdef __SUPPORT_LD_DEBUG_EARLY__
++		SEND_STDERR("Finding the GOT using C code to read the ELF file\n");
++#endif
++		/* Find where the dynamic linking information section is hiding */
++		shdr = (Elf32_Shdr *) (header->e_shoff + (char *) header);
++		for (indx = header->e_shnum; --indx >= 0; ++shdr) {
++			if (shdr->sh_type == SHT_DYNAMIC) {
++				goto found_dynamic;
++			}
++		}
++		SEND_STDERR("missing dynamic linking information section \n");
++		_dl_exit(0);
++
++	  found_dynamic:
++		dynamic = (Elf32_Dyn *) (shdr->sh_offset + (char *) header);
++
++		/* Find where PT_LOAD is hiding */
++		pt_load = (Elf32_Phdr *) (header->e_phoff + (char *) header);
++		for (indx = header->e_phnum; --indx >= 0; ++pt_load) {
++			if (pt_load->p_type == PT_LOAD) {
++				goto found_pt_load;
++			}
++		}
++		SEND_STDERR("missing loadable program segment\n");
++		_dl_exit(0);
++
++	  found_pt_load:
++		/* Now (finally) find where DT_PLTGOT is hiding */
++		tx_reloc = pt_load->p_vaddr - pt_load->p_offset;
++		for (; DT_NULL != dynamic->d_tag; ++dynamic) {
++			if (dynamic->d_tag == DT_PLTGOT) {
++				goto found_got;
++			}
++		}
++		SEND_STDERR("missing global offset table\n");
++		_dl_exit(0);
++
++	  found_got:
++		got = (unsigned long *) (dynamic->d_un.d_val - tx_reloc +
++				(char *) header);
++	}
++#endif
++
++	/* Now, finally, fix up the location of the dynamic stuff */
++	dpnt = (Elf32_Dyn *) (*got + load_addr);
++#ifdef __SUPPORT_LD_DEBUG_EARLY__
++	SEND_STDERR("First Dynamic section entry=");
++	SEND_ADDRESS_STDERR(dpnt, 1);
++#endif
++
++
++	/* Call mmap to get a page of writable memory that can be used 
++	 * for _dl_malloc throughout the shared lib loader. */
++	mmap_zero = malloc_buffer = _dl_mmap((void *) 0, 4096, 
++			PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
++	if (_dl_mmap_check_error(mmap_zero)) {
++		SEND_STDERR("dl_boot: mmap of a spare page failed!\n");
++		_dl_exit(13);
++	}
++
++	tpnt = LD_MALLOC(sizeof(struct elf_resolve));
++	_dl_memset(tpnt, 0, sizeof(struct elf_resolve));
++	app_tpnt = LD_MALLOC(sizeof(struct elf_resolve));
++	_dl_memset(app_tpnt, 0, sizeof(struct elf_resolve));
++
++	/*
++	 * This is used by gdb to locate the chain of shared libraries that are currently loaded.
++	 */
++	debug_addr = LD_MALLOC(sizeof(struct r_debug));
++	_dl_memset(debug_addr, 0, sizeof(struct r_debug));
++
++	/* OK, that was easy.  Next scan the DYNAMIC section of the image.
++	   We are only doing ourself right now - we will have to do the rest later */
++#ifdef __SUPPORT_LD_DEBUG_EARLY__
++	SEND_STDERR("scanning DYNAMIC section\n");
++#endif
++	while (dpnt->d_tag) {
++#if defined(__mips__)
++		if (dpnt->d_tag == DT_MIPS_GOTSYM)
++			tpnt->mips_gotsym = (unsigned long) dpnt->d_un.d_val;
++		if (dpnt->d_tag == DT_MIPS_LOCAL_GOTNO)
++			tpnt->mips_local_gotno = (unsigned long) dpnt->d_un.d_val;
++		if (dpnt->d_tag == DT_MIPS_SYMTABNO)
++			tpnt->mips_symtabno = (unsigned long) dpnt->d_un.d_val;
++#endif
++		if (dpnt->d_tag < 24) {
++			tpnt->dynamic_info[dpnt->d_tag] = dpnt->d_un.d_val;
++			if (dpnt->d_tag == DT_TEXTREL) {
++				tpnt->dynamic_info[DT_TEXTREL] = 1;
++			}
++		}
++		dpnt++;
++	}
++
++	{
++		ElfW(Phdr) *ppnt;
++		int i;
++
++		ppnt = (ElfW(Phdr) *) auxvt[AT_PHDR].a_un.a_ptr;
++		for (i = 0; i < auxvt[AT_PHNUM].a_un.a_val; i++, ppnt++)
++			if (ppnt->p_type == PT_DYNAMIC) {
++				dpnt = (Elf32_Dyn *) ppnt->p_vaddr;
++				while (dpnt->d_tag) {
++#if defined(__mips__)
++					if (dpnt->d_tag == DT_MIPS_GOTSYM)
++						app_tpnt->mips_gotsym =
++							(unsigned long) dpnt->d_un.d_val;
++					if (dpnt->d_tag == DT_MIPS_LOCAL_GOTNO)
++						app_tpnt->mips_local_gotno =
++							(unsigned long) dpnt->d_un.d_val;
++					if (dpnt->d_tag == DT_MIPS_SYMTABNO)
++						app_tpnt->mips_symtabno =
++							(unsigned long) dpnt->d_un.d_val;
++					if (dpnt->d_tag > DT_JMPREL) {
++						dpnt++;
++						continue;
++					}
++					app_tpnt->dynamic_info[dpnt->d_tag] = dpnt->d_un.d_val;
++
++#warning "Debugging threads on mips won't work till someone fixes this..."
++#if 0
++					if (dpnt->d_tag == DT_DEBUG) {
++						dpnt->d_un.d_val = (unsigned long) debug_addr;
++					}
++#endif
++
++#else
++					if (dpnt->d_tag > DT_JMPREL) {
++						dpnt++;
++						continue;
++					}
++					app_tpnt->dynamic_info[dpnt->d_tag] = dpnt->d_un.d_val;
++					if (dpnt->d_tag == DT_DEBUG) {
++						dpnt->d_un.d_val = (unsigned long) debug_addr;
++					}
++#endif
++					if (dpnt->d_tag == DT_TEXTREL)
++						app_tpnt->dynamic_info[DT_TEXTREL] = 1;
++					dpnt++;
++				}
++			}
++	}
++
++#ifdef __SUPPORT_LD_DEBUG_EARLY__
++	SEND_STDERR("done scanning DYNAMIC section\n");
++#endif
++
++	/* Get some more of the information that we will need to dynamicly link
++	   this module to itself */
++
++	hash_addr = (unsigned long *) (tpnt->dynamic_info[DT_HASH] + load_addr);
++	tpnt->nbucket = *hash_addr++;
++	tpnt->nchain = *hash_addr++;
++	tpnt->elf_buckets = hash_addr;
++	hash_addr += tpnt->nbucket;
++
++#ifdef __SUPPORT_LD_DEBUG_EARLY__
++	SEND_STDERR("done grabbing link information\n");
++#endif
++
++#ifndef FORCE_SHAREABLE_TEXT_SEGMENTS
++	/* Ugly, ugly.  We need to call mprotect to change the protection of
++	   the text pages so that we can do the dynamic linking.  We can set the
++	   protection back again once we are done */
++
++	{
++		ElfW(Phdr) *ppnt;
++		int i;
++
++#ifdef __SUPPORT_LD_DEBUG_EARLY__
++		SEND_STDERR("calling mprotect on the shared library/dynamic linker\n");
++#endif
++
++		/* First cover the shared library/dynamic linker. */
++		if (tpnt->dynamic_info[DT_TEXTREL]) {
++			header = (ElfW(Ehdr) *) auxvt[AT_BASE].a_un.a_ptr;
++			ppnt = (ElfW(Phdr) *) ((int)auxvt[AT_BASE].a_un.a_ptr + 
++					header->e_phoff);
++			for (i = 0; i < header->e_phnum; i++, ppnt++) {
++				if (ppnt->p_type == PT_LOAD && !(ppnt->p_flags & PF_W)) {
++					_dl_mprotect((void *) (load_addr + (ppnt->p_vaddr & PAGE_ALIGN)), 
++							(ppnt->p_vaddr & ADDR_ALIGN) + (unsigned long) ppnt->p_filesz, 
++							PROT_READ | PROT_WRITE | PROT_EXEC);
++				}
++			}
++		}
++
++#ifdef __SUPPORT_LD_DEBUG_EARLY__
++		SEND_STDERR("calling mprotect on the application program\n");
++#endif
++		/* Now cover the application program. */
++		if (app_tpnt->dynamic_info[DT_TEXTREL]) {
++			ppnt = (ElfW(Phdr) *) auxvt[AT_PHDR].a_un.a_ptr;
++			for (i = 0; i < auxvt[AT_PHNUM].a_un.a_val; i++, ppnt++) {
++				if (ppnt->p_type == PT_LOAD && !(ppnt->p_flags & PF_W))
++					_dl_mprotect((void *) (ppnt->p_vaddr & PAGE_ALIGN),
++								 (ppnt->p_vaddr & ADDR_ALIGN) +
++								 (unsigned long) ppnt->p_filesz,
++								 PROT_READ | PROT_WRITE | PROT_EXEC);
++			}
++		}
++	}
++#endif
++	
++#if defined(__mips__)
++#ifdef __SUPPORT_LD_DEBUG_EARLY__
++	SEND_STDERR("About to do MIPS specific GOT bootstrap\n");
++#endif
++	/* For MIPS we have to do stuff to the GOT before we do relocations.  */
++	PERFORM_BOOTSTRAP_GOT(got);
++#endif
++
++	/* OK, now do the relocations.  We do not do a lazy binding here, so
++	   that once we are done, we have considerably more flexibility. */
++#ifdef __SUPPORT_LD_DEBUG_EARLY__
++	SEND_STDERR("About to do library loader relocations\n");
++#endif
++
++	goof = 0;
++	for (indx = 0; indx < 2; indx++) {
++		unsigned int i;
++		ELF_RELOC *rpnt;
++		unsigned long *reloc_addr;
++		unsigned long symbol_addr;
++		int symtab_index;
++		unsigned long rel_addr, rel_size;
++
++
++#ifdef ELF_USES_RELOCA
++		rel_addr = (indx ? tpnt->dynamic_info[DT_JMPREL] : tpnt->
++			 dynamic_info[DT_RELA]);
++		rel_size = (indx ? tpnt->dynamic_info[DT_PLTRELSZ] : tpnt->
++			 dynamic_info[DT_RELASZ]);
++#else
++		rel_addr = (indx ? tpnt->dynamic_info[DT_JMPREL] : tpnt->
++			 dynamic_info[DT_REL]);
++		rel_size = (indx ? tpnt->dynamic_info[DT_PLTRELSZ] : tpnt->
++			 dynamic_info[DT_RELSZ]);
++#endif
++
++		if (!rel_addr)
++			continue;
++
++		/* Now parse the relocation information */
++		rpnt = (ELF_RELOC *) (rel_addr + load_addr);
++		for (i = 0; i < rel_size; i += sizeof(ELF_RELOC), rpnt++) {
++			reloc_addr = (unsigned long *) (load_addr + (unsigned long) rpnt->r_offset);
++			symtab_index = ELF32_R_SYM(rpnt->r_info);
++			symbol_addr = 0;
++			if (symtab_index) {
++				char *strtab;
++				Elf32_Sym *symtab;
++
++				symtab = (Elf32_Sym *) (tpnt->dynamic_info[DT_SYMTAB] + load_addr);
++				strtab = (char *) (tpnt->dynamic_info[DT_STRTAB] + load_addr);
++
++				/* We only do a partial dynamic linking right now.  The user
++				   is not supposed to redefine any symbols that start with
++				   a '_', so we can do this with confidence. */
++				if (!_dl_symbol(strtab + symtab[symtab_index].st_name))
++					continue;
++				symbol_addr = load_addr + symtab[symtab_index].st_value;
++
++				if (!symbol_addr) {
++					/* This will segfault - you cannot call a function until
++					 * we have finished the relocations.
++					 */
++					SEND_STDERR("ELF dynamic loader - unable to self-bootstrap - symbol ");
++					SEND_STDERR(strtab + symtab[symtab_index].st_name);
++					SEND_STDERR(" undefined.\n");
++					goof++;
++				}
++#ifdef __SUPPORT_LD_DEBUG_EARLY__
++				SEND_STDERR("About to fixup symbol: ");
++				SEND_STDERR(strtab + symtab[symtab_index].st_name);
++				SEND_STDERR("\n");
++#endif  
++			}
++			/*
++			 * Use this machine-specific macro to perform the actual relocation.
++			 */
++			PERFORM_BOOTSTRAP_RELOC(rpnt, reloc_addr, symbol_addr, load_addr);
++		}
++	}
++
++	if (goof) {
++		_dl_exit(14);
++	}
++#ifdef __SUPPORT_LD_DEBUG_EARLY__
++	/* Wahoo!!! */
++	_dl_dprintf(_dl_debug_file, "Done relocating library loader, so we can now\n\tuse globals and make function calls!\n");
++#endif
++
++	if (argv[0]) {
++		_dl_progname = argv[0];
++	}
++
++	/* Start to build the tables of the modules that are required for
++	 * this beast to run.  We start with the basic executable, and then
++	 * go from there.  Eventually we will run across ourself, and we
++	 * will need to properly deal with that as well. */
++
++	/* Make it so _dl_malloc can use the page of memory we have already
++	 * allocated, so we shouldn't need to grab any more memory */
++	_dl_malloc_addr = malloc_buffer;
++	_dl_mmap_zero = mmap_zero;
++
++
++
++	/* Now we have done the mandatory linking of some things.  We are now
++	   free to start using global variables, since these things have all been
++	   fixed up by now.  Still no function calls outside of this library ,
++	   since the dynamic resolver is not yet ready. */
++	_dl_get_ready_to_run(tpnt, app_tpnt, load_addr, hash_addr, auxvt, envp, debug_addr);
++
++
++	/* Notify the debugger that all objects are now mapped in.  */
++	_dl_debug_addr->r_state = RT_CONSISTENT;
++	_dl_debug_state();
++
++
++	/* OK we are done here.  Turn out the lights, and lock up. */
++	_dl_elf_main = (int (*)(int, char **, char **)) auxvt[AT_ENTRY].a_un.a_fcn;
++
++	/*
++	 * Transfer control to the application.
++	 */
++	status = 0;					/* Used on x86, but not on other arches */
++#if defined (__SUPPORT_LD_DEBUG__)
++	if(_dl_debug) _dl_dprintf(_dl_debug_file,"\ntransfering control: %s\n\n", _dl_progname);	
++#endif    
++	START();
++}
++
++#if defined (__SUPPORT_LD_DEBUG__)
++static void debug_fini (int status, void *arg)
++{
++	(void)status;
++	_dl_dprintf(_dl_debug_file,"\ncalling fini: %s\n\n", (const char*)arg);
++}
++#endif    
++
++static void _dl_get_ready_to_run(struct elf_resolve *tpnt, struct elf_resolve *app_tpnt, 
++		unsigned long load_addr, unsigned long *hash_addr, Elf32_auxv_t auxvt[AT_EGID + 1], 
++		char **envp, struct r_debug *debug_addr)
++{
++	ElfW(Phdr) *ppnt;
++	char *lpntstr;
++	int i, _dl_secure, goof = 0;
++	struct dyn_elf *rpnt;
++	struct elf_resolve *tcurr;
++	struct elf_resolve *tpnt1;
++	unsigned long brk_addr, *lpnt;
++	int (*_dl_atexit) (void *);
++#if defined (__SUPPORT_LD_DEBUG__)
++	int (*_dl_on_exit) (void (*FUNCTION)(int STATUS, void *ARG),void*);
++#endif
++
++	/* Now we have done the mandatory linking of some things.  We are now
++	   free to start using global variables, since these things have all been
++	   fixed up by now.  Still no function calls outside of this library ,
++	   since the dynamic resolver is not yet ready. */
++	lpnt = (unsigned long *) (tpnt->dynamic_info[DT_PLTGOT] + load_addr);
++
++	tpnt->chains = hash_addr;
++	tpnt->next = 0;
++	tpnt->libname = 0;
++	tpnt->libtype = program_interpreter;
++	tpnt->loadaddr = (ElfW(Addr)) load_addr;
++
++#ifdef ALLOW_ZERO_PLTGOT
++	if (tpnt->dynamic_info[DT_PLTGOT])
++#endif
++	{
++		INIT_GOT(lpnt, tpnt);
++#ifdef __SUPPORT_LD_DEBUG_EARLY__
++		_dl_dprintf(_dl_debug_file, "GOT found at %x\n", lpnt);
++#endif
++	}
++
++	/* OK, this was a big step, now we need to scan all of the user images
++	   and load them properly. */
++
++	{
++		ElfW(Ehdr) *epnt;
++		ElfW(Phdr) *myppnt;
++		int j;
++
++		epnt = (ElfW(Ehdr) *) auxvt[AT_BASE].a_un.a_ptr;
++		tpnt->n_phent = epnt->e_phnum;
++		tpnt->ppnt = myppnt = (ElfW(Phdr) *) (load_addr + epnt->e_phoff);
++		for (j = 0; j < epnt->e_phnum; j++, myppnt++) {
++			if (myppnt->p_type == PT_DYNAMIC) {
++				tpnt->dynamic_addr = (ElfW(Dyn) *)myppnt->p_vaddr + load_addr;
++				tpnt->dynamic_size = myppnt->p_filesz;
++			}
++		}
++	}
++
++	brk_addr = 0;
++	rpnt = NULL;
++
++	/* At this point we are now free to examine the user application,
++	   and figure out which libraries are supposed to be called.  Until
++	   we have this list, we will not be completely ready for dynamic linking */
++
++	ppnt = (ElfW(Phdr) *) auxvt[AT_PHDR].a_un.a_ptr;
++	for (i = 0; i < auxvt[AT_PHNUM].a_un.a_val; i++, ppnt++) {
++		if (ppnt->p_type == PT_LOAD) {
++			if (ppnt->p_vaddr + ppnt->p_memsz > brk_addr)
++				brk_addr = ppnt->p_vaddr + ppnt->p_memsz;
++		}
++		if (ppnt->p_type == PT_DYNAMIC) {
++#ifndef ALLOW_ZERO_PLTGOT
++			/* make sure it's really there. */
++			if (app_tpnt->dynamic_info[DT_PLTGOT] == 0)
++				continue;
++#endif
++			/* OK, we have what we need - slip this one into the list. */
++			app_tpnt = _dl_add_elf_hash_table("", 0, 
++					app_tpnt->dynamic_info, ppnt->p_vaddr, ppnt->p_filesz);
++			_dl_loaded_modules->libtype = elf_executable;
++			_dl_loaded_modules->ppnt = (ElfW(Phdr) *) auxvt[AT_PHDR].a_un.a_ptr;
++			_dl_loaded_modules->n_phent = auxvt[AT_PHNUM].a_un.a_val;
++			_dl_symbol_tables = rpnt = (struct dyn_elf *) _dl_malloc(sizeof(struct dyn_elf));
++			_dl_memset(rpnt, 0, sizeof(struct dyn_elf));
++			rpnt->dyn = _dl_loaded_modules;
++			app_tpnt->usage_count++;
++			app_tpnt->symbol_scope = _dl_symbol_tables;
++			lpnt = (unsigned long *) (app_tpnt->dynamic_info[DT_PLTGOT]);
++#ifdef ALLOW_ZERO_PLTGOT
++			if (lpnt)
++#endif
++				INIT_GOT(lpnt, _dl_loaded_modules);
++		}
++
++		/* OK, fill this in - we did not have this before */
++		if (ppnt->p_type == PT_INTERP) {	
++			int readsize = 0;
++			char *pnt, *pnt1, buf[1024];
++			tpnt->libname = _dl_strdup((char *) ppnt->p_offset +
++					(auxvt[AT_PHDR].a_un.a_val & PAGE_ALIGN));
++			
++			/* Determine if the shared lib loader is a symlink */
++			_dl_memset(buf, 0, sizeof(buf));
++			readsize = _dl_readlink(tpnt->libname, buf, sizeof(buf));
++			if (readsize > 0 && readsize < (int)(sizeof(buf)-1)) {
++				pnt1 = _dl_strrchr(buf, '/');
++				if (pnt1 && buf != pnt1) {
++#ifdef __SUPPORT_LD_DEBUG_EARLY__
++					_dl_dprintf(_dl_debug_file, "changing tpnt->libname from '%s' to '%s'\n", tpnt->libname, buf);
++#endif
++					tpnt->libname = _dl_strdup(buf);
++				}
++			}
++
++			/* Store the path where the shared lib loader was found for 
++			 * later use */
++			pnt = _dl_strdup(tpnt->libname);
++			pnt1 = _dl_strrchr(pnt, '/');
++			if (pnt != pnt1) {
++				*pnt1 = '\0';
++				_dl_ldsopath = pnt;
++			} else {
++				_dl_ldsopath = tpnt->libname;
++			}
++#ifdef __SUPPORT_LD_DEBUG_EARLY__
++			_dl_dprintf(_dl_debug_file, "Lib Loader:\t(%x) %s\n", tpnt->loadaddr, tpnt->libname);
++#endif
++		}
++	}
++
++
++	/* Now we need to figure out what kind of options are selected.
++	   Note that for SUID programs we ignore the settings in LD_LIBRARY_PATH */
++	{
++		if (_dl_getenv("LD_BIND_NOW", envp))
++			_dl_be_lazy = 0;
++
++		if ((auxvt[AT_UID].a_un.a_val == -1 && _dl_suid_ok()) ||
++				(auxvt[AT_UID].a_un.a_val != -1 && 
++				 auxvt[AT_UID].a_un.a_val == auxvt[AT_EUID].a_un.a_val
++				 && auxvt[AT_GID].a_un.a_val== auxvt[AT_EGID].a_un.a_val)) {
++			_dl_secure = 0;
++			_dl_preload = _dl_getenv("LD_PRELOAD", envp);
++			_dl_library_path = _dl_getenv("LD_LIBRARY_PATH", envp);
++		} else {
++			_dl_secure = 1;
++			_dl_preload = _dl_getenv("LD_PRELOAD", envp);
++			_dl_unsetenv("LD_AOUT_PRELOAD", envp);
++			_dl_unsetenv("LD_LIBRARY_PATH", envp);
++			_dl_unsetenv("LD_AOUT_LIBRARY_PATH", envp);
++			_dl_library_path = NULL;
++		}
++	}
++
++#ifdef __SUPPORT_LD_DEBUG__
++	_dl_debug    = _dl_getenv("LD_DEBUG", envp);
++	if (_dl_debug)
++	{
++	  if (_dl_strstr(_dl_debug, "all")) {
++	  	_dl_debug_detail = _dl_debug_move = _dl_debug_symbols
++			= _dl_debug_reloc = _dl_debug_bindings = _dl_debug_nofixups = _dl_strstr(_dl_debug, "all");
++	  }
++	  else {
++	  	_dl_debug_detail   = _dl_strstr(_dl_debug, "detail");
++	  	_dl_debug_move     = _dl_strstr(_dl_debug, "move");
++	  	_dl_debug_symbols  = _dl_strstr(_dl_debug, "sym");
++	  	_dl_debug_reloc    = _dl_strstr(_dl_debug, "reloc");
++	  	_dl_debug_nofixups = _dl_strstr(_dl_debug, "nofix");
++	  	_dl_debug_bindings = _dl_strstr(_dl_debug, "bind");
++	  }
++	}
++	{
++	  const char *dl_debug_output;
++	  
++	  dl_debug_output = _dl_getenv("LD_DEBUG_OUTPUT", envp);
++
++	  if (dl_debug_output)
++	  {
++	    char tmp[22], *tmp1, *filename;
++	    int len1, len2;
++	    
++	    _dl_memset(tmp, 0, sizeof(tmp));
++	    tmp1=_dl_simple_ltoa( tmp, (unsigned long)_dl_getpid());
++
++	    len1 = _dl_strlen(dl_debug_output);
++	    len2 = _dl_strlen(tmp1);
++
++	    filename = _dl_malloc(len1+len2+2);
++
++	    if (filename)
++	    {
++	      _dl_strcpy (filename, dl_debug_output);
++	      filename[len1] = '.';
++	      _dl_strcpy (&filename[len1+1], tmp1);
++
++	      _dl_debug_file= _dl_open (filename, O_WRONLY|O_CREAT);
++	      if (_dl_debug_file<0)
++	      {
++		_dl_debug_file = 2;
++		_dl_dprintf (2, "can't open file: '%s'\n",filename);
++	      }
++	    }
++	  }
++	}
++	
++	
++#endif	
++	_dl_trace_loaded_objects = _dl_getenv("LD_TRACE_LOADED_OBJECTS", envp);
++#ifndef __LDSO_LDD_SUPPORT__
++	if (_dl_trace_loaded_objects) {
++		_dl_dprintf(_dl_debug_file, "Use the ldd provided by uClibc\n");
++		_dl_exit(1);
++	}
++#endif
++
++	/*
++	 * OK, fix one more thing - set up debug_addr so it will point
++	 * to our chain.  Later we may need to fill in more fields, but this
++	 * should be enough for now.
++	 */
++	debug_addr->r_map = (struct link_map *) _dl_loaded_modules;
++	debug_addr->r_version = 1;
++	debug_addr->r_ldbase = load_addr;
++	debug_addr->r_brk = (unsigned long) &_dl_debug_state;
++	_dl_debug_addr = debug_addr;
++
++	/* Notify the debugger we are in a consistant state */
++	_dl_debug_addr->r_state = RT_CONSISTENT;
++	_dl_debug_state();
++
++	/* OK, we now have the application in the list, and we have some
++	   basic stuff in place.  Now search through the list for other shared
++	   libraries that should be loaded, and insert them on the list in the
++	   correct order. */
++
++	_dl_map_cache();
++
++
++	if (_dl_preload) 
++	{
++		char c, *str, *str2;
++
++		str = _dl_preload;
++		while (*str == ':' || *str == ' ' || *str == '\t')
++			str++;
++		while (*str) 
++		{
++			str2 = str;
++			while (*str2 && *str2 != ':' && *str2 != ' ' && *str2 != '\t')
++				str2++;
++			c = *str2;
++			*str2 = '\0';
++			if (!_dl_secure || _dl_strchr(str, '/') == NULL) 
++			{
++				if ((tpnt1 = _dl_check_if_named_library_is_loaded(str))) 
++				{
++					continue;
++				}
++#if defined (__SUPPORT_LD_DEBUG__)
++				if(_dl_debug) _dl_dprintf(_dl_debug_file, "\tfile='%s';  needed by '%s'\n", 
++						str, _dl_progname);
++#endif
++				tpnt1 = _dl_load_shared_library(_dl_secure, &rpnt, NULL, str);
++				if (!tpnt1) {
++#ifdef __LDSO_LDD_SUPPORT__
++					if (_dl_trace_loaded_objects)
++						_dl_dprintf(1, "\t%s => not found\n", str);
++					else 
++#endif
++					{
++						_dl_dprintf(2, "%s: can't load " "library '%s'\n", _dl_progname, str);
++						_dl_exit(15);
++					}
++				} else {
++#ifdef __SUPPORT_LD_DEBUG_EARLY__
++					_dl_dprintf(_dl_debug_file, "Loading:\t(%x) %s\n", tpnt1->loadaddr, tpnt1->libname);
++#endif
++#ifdef __LDSO_LDD_SUPPORT__
++					if (_dl_trace_loaded_objects && tpnt1->usage_count==1) {
++						/* this is a real hack to make ldd not print 
++						 * the library itself when run on a library. */
++						if (_dl_strcmp(_dl_progname, str) != 0)
++							_dl_dprintf(1, "\t%s => %s (%x)\n", str, tpnt1->libname, 
++									(unsigned) tpnt1->loadaddr);
++					}
++#endif
++				}
++			}
++			*str2 = c;
++			str = str2;
++			while (*str == ':' || *str == ' ' || *str == '\t')
++				str++;
++		}
++	}
++
++#ifdef SUPPORT_LDSO_PRELOAD_FILE
++	{
++		int fd;
++		struct stat st;
++		char *preload;
++		if (!_dl_stat(LDSO_PRELOAD, &st) && st.st_size > 0) {
++			if ((fd = _dl_open(LDSO_PRELOAD, O_RDONLY)) < 0) {
++				_dl_dprintf(2, "%s: can't open file '%s'\n", 
++						_dl_progname, LDSO_PRELOAD);
++			} else {
++				preload = (caddr_t) _dl_mmap(0, st.st_size + 1, 
++						PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0);
++				_dl_close(fd);
++				if (preload == (caddr_t) - 1) {
++					_dl_dprintf(2, "%s: can't map file '%s'\n", 
++							_dl_progname, LDSO_PRELOAD);
++				} else {
++					char c, *cp, *cp2;
++
++					/* convert all separators and comments to spaces */
++					for (cp = preload; *cp; /*nada */ ) {
++						if (*cp == ':' || *cp == '\t' || *cp == '\n') {
++							*cp++ = ' ';
++						} else if (*cp == '#') {
++							do
++								*cp++ = ' ';
++							while (*cp != '\n' && *cp != '\0');
++						} else {
++							cp++;
++						}
++					}
++
++					/* find start of first library */
++					for (cp = preload; *cp && *cp == ' '; cp++)
++						/*nada */ ;
++
++					while (*cp) {
++						/* find end of library */
++						for (cp2 = cp; *cp && *cp != ' '; cp++)
++							/*nada */ ;
++						c = *cp;
++						*cp = '\0';
++
++						if ((tpnt1 = _dl_check_if_named_library_is_loaded(cp2))) 
++						{
++							continue;
++						}
++#if defined (__SUPPORT_LD_DEBUG__)
++						if(_dl_debug) _dl_dprintf(_dl_debug_file, "\tfile='%s';  needed by '%s'\n", 
++								cp2, _dl_progname);
++#endif
++						tpnt1 = _dl_load_shared_library(0, &rpnt, NULL, cp2);
++						if (!tpnt1) {
++#ifdef __LDSO_LDD_SUPPORT__
++							if (_dl_trace_loaded_objects)
++								_dl_dprintf(1, "\t%s => not found\n", cp2);
++							else 
++#endif
++							{
++								_dl_dprintf(2, "%s: can't load library '%s'\n", _dl_progname, cp2);
++								_dl_exit(15);
++							}
++						} else {
++#ifdef __SUPPORT_LD_DEBUG_EARLY__
++							_dl_dprintf(_dl_debug_file, "Loading:\t(%x) %s\n", tpnt1->loadaddr, tpnt1->libname);
++#endif
++#ifdef __LDSO_LDD_SUPPORT__
++							if (_dl_trace_loaded_objects && tpnt1->usage_count==1) {
++								_dl_dprintf(1, "\t%s => %s (%x)\n", cp2, 
++										tpnt1->libname, (unsigned) tpnt1->loadaddr);
++							}
++#endif
++						}
++
++						/* find start of next library */
++						*cp = c;
++						for ( /*nada */ ; *cp && *cp == ' '; cp++)
++							/*nada */ ;
++					}
++
++					_dl_munmap(preload, st.st_size + 1);
++				}
++			}
++		}
++	}
++#endif
++
++	for (tcurr = _dl_loaded_modules; tcurr; tcurr = tcurr->next) 
++	{
++		Elf32_Dyn *dpnt;
++		for (dpnt = (Elf32_Dyn *) tcurr->dynamic_addr; dpnt->d_tag; dpnt++) 
++		{
++			if (dpnt->d_tag == DT_NEEDED) 
++			{
++				char *name;
++				lpntstr = (char*) (tcurr->loadaddr + tcurr->dynamic_info[DT_STRTAB] + dpnt->d_un.d_val);
++				name = _dl_get_last_path_component(lpntstr);
++
++				if ((tpnt1 = _dl_check_if_named_library_is_loaded(name))) 
++				{
++					continue;
++				}
++#if defined (__SUPPORT_LD_DEBUG__)
++				if(_dl_debug) _dl_dprintf(_dl_debug_file, "\tfile='%s';  needed by '%s'\n", 
++						lpntstr, _dl_progname);
++#endif
++				if (!(tpnt1 = _dl_load_shared_library(0, &rpnt, tcurr, lpntstr)))
++				{
++#ifdef __LDSO_LDD_SUPPORT__
++					if (_dl_trace_loaded_objects) {
++						_dl_dprintf(1, "\t%s => not found\n", lpntstr);
++						continue;
++					} else 
++#endif
++					{
++						_dl_dprintf(2, "%s: can't load library '%s'\n", _dl_progname, lpntstr);
++						_dl_exit(16);
++					}
++				} else {
++#ifdef __SUPPORT_LD_DEBUG_EARLY__
++					_dl_dprintf(_dl_debug_file, "Loading:\t(%x) %s\n", tpnt1->loadaddr, tpnt1->libname);
++#endif
++#ifdef __LDSO_LDD_SUPPORT__
++					if (_dl_trace_loaded_objects && tpnt1->usage_count==1) {
++						_dl_dprintf(1, "\t%s => %s (%x)\n", lpntstr, tpnt1->libname, 
++								(unsigned) tpnt1->loadaddr);
++					}
++#endif
++				}
++			}
++		}
++	}
++
++
++	_dl_unmap_cache();
++
++	/*
++	 * If the program interpreter is not in the module chain, add it.  This will
++	 * be required for dlopen to be able to access the internal functions in the 
++	 * dynamic linker.
++	 */
++	if (tpnt) {
++		tcurr = _dl_loaded_modules;
++		if (tcurr)
++			while (tcurr->next)
++				tcurr = tcurr->next;
++		tpnt->next = NULL;
++		tpnt->usage_count++;
++
++		if (tcurr) {
++			tcurr->next = tpnt;
++			tpnt->prev = tcurr;
++		} else {
++			_dl_loaded_modules = tpnt;
++			tpnt->prev = NULL;
++		}
++		if (rpnt) {
++			rpnt->next = (struct dyn_elf *) _dl_malloc(sizeof(struct dyn_elf));
++			_dl_memset(rpnt->next, 0, sizeof(struct dyn_elf));
++			rpnt->next->prev = rpnt;
++			rpnt = rpnt->next;
++		} else {
++			rpnt = (struct dyn_elf *) _dl_malloc(sizeof(struct dyn_elf));
++			_dl_memset(rpnt, 0, sizeof(struct dyn_elf));
++		}
++		rpnt->dyn = tpnt;
++		tpnt = NULL;
++	}
++
++#ifdef __LDSO_LDD_SUPPORT__
++	/* End of the line for ldd.... */
++	if (_dl_trace_loaded_objects) {
++		_dl_dprintf(1, "\t%s => %s (%x)\n", rpnt->dyn->libname + (_dl_strlen(_dl_ldsopath)) + 1, 
++				rpnt->dyn->libname, rpnt->dyn->loadaddr);  
++		_dl_exit(0);
++	}
++#endif
++
++
++#ifdef __mips__
++	/*
++	 * Relocation of the GOT entries for MIPS have to be done
++	 * after all the libraries have been loaded.
++	 */
++	_dl_perform_mips_global_got_relocations(_dl_loaded_modules);
++#endif
++
++#ifdef __SUPPORT_LD_DEBUG_EARLY__
++	_dl_dprintf(_dl_debug_file, "Beginning relocation fixups\n");
++#endif
++	/*
++	 * OK, now all of the kids are tucked into bed in their proper addresses.
++	 * Now we go through and look for REL and RELA records that indicate fixups
++	 * to the GOT tables.  We need to do this in reverse order so that COPY
++	 * directives work correctly */
++	goof = _dl_loaded_modules ? _dl_fixup(_dl_loaded_modules, _dl_be_lazy) : 0;
++
++
++	/* Some flavors of SVr4 do not generate the R_*_COPY directive,
++	   and we have to manually search for entries that require fixups. 
++	   Solaris gets this one right, from what I understand.  */
++
++#ifdef __SUPPORT_LD_DEBUG_EARLY__
++	_dl_dprintf(_dl_debug_file, "Beginning copy fixups\n");
++#endif
++	if (_dl_symbol_tables)
++		goof += _dl_copy_fixups(_dl_symbol_tables);
++
++	/* OK, at this point things are pretty much ready to run.  Now we
++	   need to touch up a few items that are required, and then
++	   we can let the user application have at it.  Note that
++	   the dynamic linker itself is not guaranteed to be fully
++	   dynamicly linked if we are using ld.so.1, so we have to look
++	   up each symbol individually. */
++
++
++	_dl_brkp = (unsigned long *) (intptr_t) _dl_find_hash("___brk_addr", NULL, NULL, symbolrel);
++	
++	if (_dl_brkp) {
++		*_dl_brkp = brk_addr;
++	}
++	_dl_envp = (unsigned long *) (intptr_t) _dl_find_hash("__environ", NULL, NULL, symbolrel);
++
++	if (_dl_envp) {
++		*_dl_envp = (unsigned long) envp;
++	}
++
++#ifndef FORCE_SHAREABLE_TEXT_SEGMENTS
++	{
++		unsigned int j;
++		ElfW(Phdr) *myppnt;
++
++		/* We had to set the protections of all pages to R/W for dynamic linking.
++		   Set text pages back to R/O */
++		for (tpnt = _dl_loaded_modules; tpnt; tpnt = tpnt->next) {
++			for (myppnt = tpnt->ppnt, j = 0; j < tpnt->n_phent; j++, myppnt++) {
++				if (myppnt->p_type == PT_LOAD && !(myppnt->p_flags & PF_W) && tpnt->dynamic_info[DT_TEXTREL]) {
++					_dl_mprotect((void *) (tpnt->loadaddr + (myppnt->p_vaddr & PAGE_ALIGN)), 
++							(myppnt->p_vaddr & ADDR_ALIGN) + (unsigned long) myppnt->p_filesz, LXFLAGS(myppnt->p_flags));
++				}
++			}
++		}
++
++	}
++#endif
++	_dl_atexit = (int (*)(void *)) (intptr_t) _dl_find_hash("atexit", NULL, NULL, symbolrel);
++#if defined (__SUPPORT_LD_DEBUG__)
++	_dl_on_exit = (int (*)(void (*)(int, void *),void*)) 
++		(intptr_t) _dl_find_hash("on_exit", NULL, NULL, symbolrel);
++#endif
++
++	/* Notify the debugger we have added some objects. */
++	_dl_debug_addr->r_state = RT_ADD;
++	_dl_debug_state();
++
++	for (rpnt = _dl_symbol_tables; rpnt!=NULL&& rpnt->next!=NULL; rpnt=rpnt->next)
++	  ;
++	  
++	for (;rpnt!=NULL; rpnt=rpnt->prev)
++	{
++  	        tpnt = rpnt->dyn;
++
++	        if (tpnt->libtype == program_interpreter)
++			continue;
++
++		/* Apparently crt0/1 for the application is responsible for handling this.
++		 * We only need to run the init/fini for shared libraries
++		 */
++	        if (tpnt->libtype == elf_executable)
++			break;      /* at this point all shared libs are initialized !! */
++
++		if (tpnt->init_flag & INIT_FUNCS_CALLED)
++			continue;
++		tpnt->init_flag |= INIT_FUNCS_CALLED;
++
++		if (tpnt->dynamic_info[DT_INIT]) {
++			void (*dl_elf_func) (void);
++			dl_elf_func = (void (*)(void)) (intptr_t) (tpnt->loadaddr + tpnt->dynamic_info[DT_INIT]);
++#if defined (__SUPPORT_LD_DEBUG__)
++			if(_dl_debug) _dl_dprintf(_dl_debug_file,"\ncalling init: %s\n\n", tpnt->libname);	
++#endif    
++			(*dl_elf_func) ();
++		}
++		if (_dl_atexit && tpnt->dynamic_info[DT_FINI]) {
++			void (*dl_elf_func) (void);
++			dl_elf_func = (void (*)(void)) (intptr_t) (tpnt->loadaddr + tpnt->dynamic_info[DT_FINI]);
++			(*_dl_atexit) (dl_elf_func);
++#if defined (__SUPPORT_LD_DEBUG__)
++			if(_dl_debug && _dl_on_exit)
++			{
++				(*_dl_on_exit)(debug_fini, tpnt->libname);
++			}
++#endif
++		}
++#if defined (__SUPPORT_LD_DEBUG__)
++		else {
++			if (!_dl_atexit)
++				_dl_dprintf(_dl_debug_file, "%s: The address of atexit () is 0x0.\n", tpnt->libname);
++#if 0
++			if (!tpnt->dynamic_info[DT_FINI])
++				_dl_dprintf(_dl_debug_file, "%s: Invalid .fini section.\n", tpnt->libname);
++#endif
++		}
++#endif
++	}
++}
++
++/*
++ * This stub function is used by some debuggers.  The idea is that they
++ * can set an internal breakpoint on it, so that we are notified when the
++ * address mapping is changed in some way.
++ */
++void _dl_debug_state(void)
++{
++}
++
++char *_dl_getenv(const char *symbol, char **envp)
++{
++	char *pnt;
++	const char *pnt1;
++
++	while ((pnt = *envp++)) {
++		pnt1 = symbol;
++		while (*pnt && *pnt == *pnt1)
++			pnt1++, pnt++;
++		if (!*pnt || *pnt != '=' || *pnt1)
++			continue;
++		return pnt + 1;
++	}
++	return 0;
++}
++
++void _dl_unsetenv(const char *symbol, char **envp)
++{
++	char *pnt;
++	const char *pnt1;
++	char **newenvp = envp;
++
++	for (pnt = *envp; pnt; pnt = *++envp) {
++		pnt1 = symbol;
++		while (*pnt && *pnt == *pnt1)
++			pnt1++, pnt++;
++		if (!*pnt || *pnt != '=' || *pnt1)
++			*newenvp++ = *envp;
++	}
++	*newenvp++ = *envp;
++	return;
++}
++
++#include "hash.c"
++#include "readelflib1.c"
+diff -urN uClibc/ldso-0.9.24/ldso/m68k/boot1_arch.h uClibc.ldso.24/ldso-0.9.24/ldso/m68k/boot1_arch.h
+--- uClibc/ldso-0.9.24/ldso/m68k/boot1_arch.h	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/m68k/boot1_arch.h	2002-08-08 09:35:37.000000000 -0500
+@@ -0,0 +1,7 @@
++/* Any assmbly language/system dependent hacks needed to setup boot1.c so it
++ * will work as expected and cope with whatever platform specific wierdness is
++ * needed for this architecture.  See arm/boot1_arch.h for an example of what
++ * can be done.
++ */
++
++#define LD_BOOT(X)   void _dl_boot (X)
+diff -urN uClibc/ldso-0.9.24/ldso/m68k/elfinterp.c uClibc.ldso.24/ldso-0.9.24/ldso/m68k/elfinterp.c
+--- uClibc/ldso-0.9.24/ldso/m68k/elfinterp.c	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/m68k/elfinterp.c	2002-11-05 12:21:04.000000000 -0600
+@@ -0,0 +1,359 @@
++/* vi: set sw=4 ts=4: */
++/* m68k ELF shared library loader suppport
++ *
++ * Copyright (c) 1994-2000 Eric Youngdale, Peter MacDonald, 
++ *				David Engel, Hongjiu Lu and Mitch D'Souza
++ * Adapted to ELF/68k by Andreas Schwab.
++ *
++ * All rights reserved.
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions
++ * are met:
++ * 1. Redistributions of source code must retain the above copyright
++ *    notice, this list of conditions and the following disclaimer.
++ * 2. The name of the above contributors may not be
++ *    used to endorse or promote products derived from this software
++ *    without specific prior written permission.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND
++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ * ARE DISCLAIMED.  IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE
++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
++ * SUCH DAMAGE.
++ */
++
++#if defined (__SUPPORT_LD_DEBUG__)
++static const char *_dl_reltypes[] =
++{
++  "R_68K_NONE",
++  "R_68K_32", "R_68K_16", "R_68K_8",
++  "R_68K_PC32", "R_68K_PC16", "R_68K_PC8",
++  "R_68K_GOT32", "R_68K_GOT16", "R_68K_GOT8",
++  "R_68K_GOT32O", "R_68K_GOT16O", "R_68K_GOT8O",
++  "R_68K_PLT32", "R_68K_PLT16", "R_68K_PLT8",
++  "R_68K_PLT32O", "R_68K_PLT16O", "R_68K_PLT8O",
++  "R_68K_COPY", "R_68K_GLOB_DAT", "R_68K_JMP_SLOT", "R_68K_RELATIVE",
++  "R_68K_NUM"
++};
++#endif
++
++/* Program to load an ELF binary on a linux system, and run it.
++   References to symbols in sharable libraries can be resolved by either
++   an ELF sharable library or a linux style of shared library. */
++
++/* Disclaimer:  I have never seen any AT&T source code for SVr4, nor have
++   I ever taken any courses on internals.  This program was developed using
++   information available through the book "UNIX SYSTEM V RELEASE 4,
++   Programmers guide: Ansi C and Programming Support Tools", which did
++   a more than adequate job of explaining everything required to get this
++   working. */
++
++
++unsigned int _dl_linux_resolver (int dummy1, int dummy2, 
++	struct elf_resolve *tpnt, int reloc_entry)
++{
++  int reloc_type;
++  Elf32_Rela *this_reloc;
++  char *strtab;
++  Elf32_Sym *symtab;
++  char *rel_addr;
++  int symtab_index;
++  char *new_addr;
++  char **got_addr;
++  unsigned int instr_addr;
++
++  rel_addr = tpnt->loadaddr + tpnt->dynamic_info[DT_JMPREL];
++  this_reloc = (Elf32_Rela *) (rel_addr + reloc_entry);
++  reloc_type = ELF32_R_TYPE (this_reloc->r_info);
++  symtab_index = ELF32_R_SYM (this_reloc->r_info);
++
++  symtab = (Elf32_Sym *) (tpnt->dynamic_info[DT_SYMTAB]
++				 + tpnt->loadaddr);
++  strtab = (char *) (tpnt->dynamic_info[DT_STRTAB] + tpnt->loadaddr);
++
++
++  if (reloc_type != R_68K_JMP_SLOT)
++    {
++      _dl_dprintf (2, "%s: incorrect relocation type in jump relocations\n",
++		    _dl_progname);
++      _dl_exit (1);
++    }
++
++  /* Address of jump instruction to fix up.  */
++  instr_addr = (int) this_reloc->r_offset + (int) tpnt->loadaddr;
++  got_addr = (char **) instr_addr;
++
++#ifdef __SUPPORT_LD_DEBUG__
++  if (_dl_debug_symbols) {
++	  _dl_dprintf (2, "Resolving symbol %s\n", strtab + symtab[symtab_index].st_name);
++  }
++#endif
++
++  /* Get the address of the GOT entry.  */
++  new_addr = _dl_find_hash (strtab + symtab[symtab_index].st_name,
++			    tpnt->symbol_scope, tpnt, resolver);
++  if (!new_addr)
++    {
++      _dl_dprintf (2, "%s: can't resolve symbol '%s'\n",
++		    _dl_progname, strtab + symtab[symtab_index].st_name);
++      _dl_exit (1);
++    }
++#if defined (__SUPPORT_LD_DEBUG__)
++	if ((unsigned long) got_addr < 0x40000000)
++	{
++		if (_dl_debug_bindings)
++		{
++			_dl_dprintf(_dl_debug_file, "\nresolve function: %s",
++					strtab + symtab[symtab_index].st_name);
++			if(_dl_debug_detail) _dl_dprintf(_dl_debug_file, 
++					"\tpatch %x ==> %x @ %x", *got_addr, new_addr, got_addr);
++		}
++	}
++	if (!_dl_debug_nofixups) {
++		*got_addr = new_addr;
++	}
++#else
++	*got_addr = new_addr;
++#endif
++
++  return (unsigned int) new_addr;
++}
++
++void
++_dl_parse_lazy_relocation_information (struct elf_resolve *tpnt,
++                       unsigned long rel_addr, unsigned long rel_size, int type)
++{
++  int i;
++  char *strtab;
++  int reloc_type;
++  int symtab_index;
++  Elf32_Sym *symtab;
++  Elf32_Rela *rpnt;
++  unsigned int *reloc_addr;
++
++  /* Now parse the relocation information.  */
++  rpnt = (Elf32_Rela *) (rel_addr + tpnt->loadaddr);
++  rel_size = rel_size / sizeof (Elf32_Rela);
++
++  symtab = (Elf32_Sym *) (tpnt->dynamic_info[DT_SYMTAB]
++				 + tpnt->loadaddr);
++  strtab = (char *) (tpnt->dynamic_info[DT_STRTAB] + tpnt->loadaddr);
++
++  for (i = 0; i < rel_size; i++, rpnt++)
++    {
++      reloc_addr = (int *) (tpnt->loadaddr + (int) rpnt->r_offset);
++      reloc_type = ELF32_R_TYPE (rpnt->r_info);
++      symtab_index = ELF32_R_SYM (rpnt->r_info);
++
++      /* When the dynamic linker bootstrapped itself, it resolved some symbols.
++         Make sure we do not do them again.  */
++      if (tpnt->libtype == program_interpreter
++	  && (!symtab_index
++	      || _dl_symbol (strtab + symtab[symtab_index].st_name)))
++	continue;
++
++      switch (reloc_type)
++	{
++	case R_68K_NONE:
++	  break;
++	case R_68K_JMP_SLOT:
++	  *reloc_addr += (unsigned int) tpnt->loadaddr;
++	  break;
++	default:
++	  _dl_dprintf (2, "%s: (LAZY) can't handle reloc type ", _dl_progname);
++#if defined (__SUPPORT_LD_DEBUG__)
++	  _dl_dprintf (2, "%s ", _dl_reltypes[reloc_type]);
++#endif
++	  if (symtab_index)
++	    _dl_dprintf (2, "'%s'", strtab + symtab[symtab_index].st_name);
++	  _dl_dprintf (2, "\n");
++	  _dl_exit (1);
++	}
++    }
++}
++
++int 
++_dl_parse_relocation_information (struct elf_resolve *tpnt,
++                  unsigned long rel_addr, unsigned long rel_size, int type)
++{
++  int i;
++  char *strtab;
++  int reloc_type;
++  int goof = 0;
++  Elf32_Sym *symtab;
++  Elf32_Rela *rpnt;
++  unsigned int *reloc_addr;
++  unsigned int symbol_addr;
++  int symtab_index;
++  /* Now parse the relocation information */
++
++  rpnt = (Elf32_Rela *) (rel_addr + tpnt->loadaddr);
++  rel_size = rel_size / sizeof (Elf32_Rela);
++
++  symtab = (Elf32_Sym *) (tpnt->dynamic_info[DT_SYMTAB]
++				 + tpnt->loadaddr);
++  strtab = (char *) (tpnt->dynamic_info[DT_STRTAB] + tpnt->loadaddr);
++
++  for (i = 0; i < rel_size; i++, rpnt++)
++    {
++      reloc_addr = (int *) (tpnt->loadaddr + (int) rpnt->r_offset);
++      reloc_type = ELF32_R_TYPE (rpnt->r_info);
++      symtab_index = ELF32_R_SYM (rpnt->r_info);
++      symbol_addr = 0;
++
++      if (tpnt->libtype == program_interpreter
++	  && (!symtab_index
++	      || _dl_symbol (strtab + symtab[symtab_index].st_name)))
++	continue;
++
++      if (symtab_index)
++	{
++	  symbol_addr = (unsigned int)
++	    _dl_find_hash (strtab + symtab[symtab_index].st_name,
++			   tpnt->symbol_scope,
++			   reloc_type == R_68K_JMP_SLOT ? tpnt : NULL, symbolrel);
++
++	  /* We want to allow undefined references to weak symbols -
++	     this might have been intentional.  We should not be
++	     linking local symbols here, so all bases should be
++	     covered.  */
++	  if (!symbol_addr
++	      && ELF32_ST_BIND (symtab[symtab_index].st_info) == STB_GLOBAL)
++	    {
++	      _dl_dprintf (2, "%s: can't resolve symbol '%s'\n",
++			    _dl_progname, strtab + symtab[symtab_index].st_name);
++	      goof++;
++	    }
++	}
++      switch (reloc_type)
++	{
++	case R_68K_NONE:
++	  break;
++	case R_68K_8:
++	  *(char *) reloc_addr = symbol_addr + rpnt->r_addend;
++	  break;
++	case R_68K_16:
++	  *(short *) reloc_addr = symbol_addr + rpnt->r_addend;
++	  break;
++	case R_68K_32:
++	  *reloc_addr = symbol_addr + rpnt->r_addend;
++	  break;
++	case R_68K_PC8:
++	  *(char *) reloc_addr = (symbol_addr + rpnt->r_addend
++				  - (unsigned int) reloc_addr);
++	  break;
++	case R_68K_PC16:
++	  *(short *) reloc_addr = (symbol_addr + rpnt->r_addend
++				   - (unsigned int) reloc_addr);
++	  break;
++	case R_68K_PC32:
++	  *reloc_addr = (symbol_addr + rpnt->r_addend
++			 - (unsigned int) reloc_addr);
++	  break;
++	case R_68K_GLOB_DAT:
++	case R_68K_JMP_SLOT:
++	  *reloc_addr = symbol_addr;
++	  break;
++	case R_68K_RELATIVE:
++	  *reloc_addr = ((unsigned int) tpnt->loadaddr
++			 /* Compatibility kludge.  */
++			 + (rpnt->r_addend ? : *reloc_addr));
++	  break;
++	case R_68K_COPY:
++#if 0 /* Do this later.  */
++	  _dl_dprintf (2, "Doing copy");
++	  if (symtab_index)
++	    _dl_dprintf (2, " for symbol %s",
++			  strtab + symtab[symtab_index].st_name);
++	  _dl_dprintf (2, "\n");
++	  _dl_memcpy ((void *) symtab[symtab_index].st_value,
++		      (void *) symbol_addr,
++		      symtab[symtab_index].st_size);
++#endif
++	  break;
++	default:
++	  _dl_dprintf (2, "%s: can't handle reloc type ", _dl_progname);
++#if defined (__SUPPORT_LD_DEBUG__)
++	  _dl_dprintf (2, "%s ", _dl_reltypes[reloc_type]);
++#endif
++	  if (symtab_index)
++	    _dl_dprintf (2, "'%s'", strtab + symtab[symtab_index].st_name);
++	  _dl_dprintf (2, "\n");
++	  _dl_exit (1);
++	}
++
++    }
++  return goof;
++}
++
++/* This is done as a separate step, because there are cases where
++   information is first copied and later initialized.  This results in
++   the wrong information being copied.  Someone at Sun was complaining about
++   a bug in the handling of _COPY by SVr4, and this may in fact be what he
++   was talking about.  Sigh.  */
++
++/* No, there are cases where the SVr4 linker fails to emit COPY relocs
++   at all.  */
++
++int 
++_dl_parse_copy_information (struct dyn_elf *xpnt, unsigned long rel_addr,
++			    unsigned long rel_size, int type)
++{
++  int i;
++  char *strtab;
++  int reloc_type;
++  int goof = 0;
++  Elf32_Sym *symtab;
++  Elf32_Rela *rpnt;
++  unsigned int *reloc_addr;
++  unsigned int symbol_addr;
++  struct elf_resolve *tpnt;
++  int symtab_index;
++  /* Now parse the relocation information */
++
++  tpnt = xpnt->dyn;
++
++  rpnt = (Elf32_Rela *) (rel_addr + tpnt->loadaddr);
++  rel_size = rel_size / sizeof (Elf32_Rela);
++
++  symtab = (Elf32_Sym *) (tpnt->dynamic_info[DT_SYMTAB]
++				 + tpnt->loadaddr);
++  strtab = (char *) (tpnt->dynamic_info[DT_STRTAB] + tpnt->loadaddr);
++
++  for (i = 0; i < rel_size; i++, rpnt++)
++    {
++      reloc_addr = (int *) (tpnt->loadaddr + (int) rpnt->r_offset);
++      reloc_type = ELF32_R_TYPE (rpnt->r_info);
++      if (reloc_type != R_68K_COPY)
++	continue;
++      symtab_index = ELF32_R_SYM (rpnt->r_info);
++      symbol_addr = 0;
++      if (tpnt->libtype == program_interpreter
++	  && (!symtab_index
++	      || _dl_symbol (strtab + symtab[symtab_index].st_name)))
++	continue;
++      if (symtab_index)
++	{
++	  symbol_addr = (unsigned int)
++	    _dl_find_hash (strtab + symtab[symtab_index].st_name,
++			   xpnt->next, NULL, copyrel);
++	  if (!symbol_addr)
++	    {
++	      _dl_dprintf (2, "%s: can't resolve symbol '%s'\n",
++			    _dl_progname, strtab + symtab[symtab_index].st_name);
++	      goof++;
++	    }
++	}
++      if (!goof)
++      _dl_memcpy ((void *) symtab[symtab_index].st_value, (void *) symbol_addr,
++		  symtab[symtab_index].st_size);
++    }
++  return goof;
++}
+diff -urN uClibc/ldso-0.9.24/ldso/m68k/ld_syscalls.h uClibc.ldso.24/ldso-0.9.24/ldso/m68k/ld_syscalls.h
+--- uClibc/ldso-0.9.24/ldso/m68k/ld_syscalls.h	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/m68k/ld_syscalls.h	2002-03-19 04:43:32.000000000 -0600
+@@ -0,0 +1,174 @@
++/*
++ * This file contains the system call macros and syscall 
++ * numbers used by the shared library loader.
++ */
++
++#define __NR_exit		  1
++#define __NR_read		  3
++#define __NR_write		  4
++#define __NR_open		  5
++#define __NR_close		  6
++#define __NR_getuid		 24
++#define __NR_geteuid		 49
++#define __NR_getgid		 47
++#define __NR_getegid		 50
++#define __NR_readlink		 85
++#define __NR_mmap		 90
++#define __NR_munmap		 91
++#define __NR_stat		106
++#define __NR_mprotect		125
++
++
++/* Here are the macros which define how this platform makes
++ * system calls.  This particular variant does _not_ set 
++ * errno (note how it is disabled in __syscall_return) since
++ * these will get called before the errno symbol is dynamicly 
++ * linked. */
++
++
++#define __syscall_return(type, res) \
++do { \
++	if ((unsigned long)(res) >= (unsigned long)(-125)) { \
++	/* avoid using res which is declared to be in register d0; \
++	   errno might expand to a function call and clobber it.  */ \
++		/* int __err = -(res); \
++		errno = __err; */ \
++		res = -1; \
++	} \
++	return (type) (res); \
++} while (0)
++
++#define _syscall0(type, name)						\
++type name(void)								\
++{									\
++  long __res;								\
++  __asm__ __volatile__ ("movel	%1, %%d0\n\t"				\
++  			"trap	#0\n\t"					\
++  			"movel	%%d0, %0"				\
++			: "=g" (__res)					\
++			: "i" (__NR_##name)				\
++			: "cc", "%d0");					\
++  if ((unsigned long)(__res) >= (unsigned long)(-125)) {			\
++    /* errno = -__res; */							\
++    __res = -1;								\
++  }									\
++  return (type)__res;							\
++}
++
++#define _syscall1(type, name, atype, a)					\
++type name(atype a)							\
++{									\
++  long __res;								\
++  __asm__ __volatile__ ("movel	%2, %%d1\n\t"				\
++  			"movel	%1, %%d0\n\t"				\
++  			"trap	#0\n\t"					\
++  			"movel	%%d0, %0"				\
++			: "=g" (__res)					\
++			: "i" (__NR_##name),				\
++			  "g" ((long)a)					\
++			: "cc", "%d0", "%d1");				\
++  if ((unsigned long)(__res) >= (unsigned long)(-125)) {			\
++    /* errno = -__res; */							\
++    __res = -1;								\
++  }									\
++  return (type)__res;							\
++}
++
++#define _syscall2(type, name, atype, a, btype, b)			\
++type name(atype a, btype b)						\
++{									\
++  long __res;								\
++  __asm__ __volatile__ ("movel	%3, %%d2\n\t"				\
++  			"movel	%2, %%d1\n\t"				\
++			"movel	%1, %%d0\n\t"				\
++  			"trap	#0\n\t"					\
++  			"movel	%%d0, %0"				\
++			: "=g" (__res)					\
++			: "i" (__NR_##name),				\
++			  "a" ((long)a),				\
++			  "g" ((long)b)					\
++			: "cc", "%d0", "%d1", "%d2");			\
++  if ((unsigned long)(__res) >= (unsigned long)(-125)) {			\
++    /* errno = -__res; */							\
++    __res = -1;								\
++  }									\
++  return (type)__res;							\
++}
++
++#define _syscall3(type, name, atype, a, btype, b, ctype, c)		\
++type name(atype a, btype b, ctype c)					\
++{									\
++  long __res;								\
++  __asm__ __volatile__ ("movel	%4, %%d3\n\t"				\
++			"movel	%3, %%d2\n\t"				\
++  			"movel	%2, %%d1\n\t"				\
++			"movel	%1, %%d0\n\t"				\
++  			"trap	#0\n\t"					\
++  			"movel	%%d0, %0"				\
++			: "=g" (__res)					\
++			: "i" (__NR_##name),				\
++			  "a" ((long)a),				\
++			  "a" ((long)b),				\
++			  "g" ((long)c)					\
++			: "cc", "%d0", "%d1", "%d2", "%d3");		\
++  if ((unsigned long)(__res) >= (unsigned long)(-125)) {			\
++    /* errno = -__res; */							\
++    __res = -1;								\
++  }									\
++  return (type)__res;							\
++}
++
++#define _syscall4(type, name, atype, a, btype, b, ctype, c, dtype, d)	\
++type name(atype a, btype b, ctype c, dtype d)				\
++{									\
++  long __res;								\
++  __asm__ __volatile__ ("movel	%5, %%d4\n\t"				\
++			"movel	%4, %%d3\n\t"				\
++			"movel	%3, %%d2\n\t"				\
++  			"movel	%2, %%d1\n\t"				\
++			"movel	%1, %%d0\n\t"				\
++  			"trap	#0\n\t"					\
++  			"movel	%%d0, %0"				\
++			: "=g" (__res)					\
++			: "i" (__NR_##name),				\
++			  "a" ((long)a),				\
++			  "a" ((long)b),				\
++			  "a" ((long)c),				\
++			  "g" ((long)d)					\
++			: "cc", "%d0", "%d1", "%d2", "%d3",		\
++			  "%d4");					\
++  if ((unsigned long)(__res) >= (unsigned long)(-125)) {			\
++    /* errno = -__res; */							\
++    __res = -1;								\
++  }									\
++  return (type)__res;							\
++}
++
++#define _syscall5(type, name, atype, a, btype, b, ctype, c, dtype, d, etype, e)\
++type name(atype a, btype b, ctype c, dtype d, etype e)			\
++{									\
++  long __res;								\
++  __asm__ __volatile__ ("movel	%6, %%d5\n\t"				\
++			"movel	%5, %%d4\n\t"				\
++			"movel	%4, %%d3\n\t"				\
++			"movel	%3, %%d2\n\t"				\
++  			"movel	%2, %%d1\n\t"				\
++			"movel	%1, %%d0\n\t"				\
++  			"trap	#0\n\t"					\
++  			"movel	%%d0, %0"				\
++			: "=g" (__res)					\
++			: "i" (__NR_##name),				\
++			  "a" ((long)a),				\
++			  "a" ((long)b),				\
++			  "a" ((long)c),				\
++			  "a" ((long)d),				\
++			  "g" ((long)e)					\
++			: "cc", "%d0", "%d1", "%d2", "%d3",		\
++			  "%d4", "%d5");				\
++  if ((unsigned long)(__res) >= (unsigned long)(-125)) {			\
++    /* errno = -__res; */							\
++    __res = -1;								\
++  }									\
++  return (type)__res;							\
++}
++
+diff -urN uClibc/ldso-0.9.24/ldso/m68k/ld_sysdep.h uClibc.ldso.24/ldso-0.9.24/ldso/m68k/ld_sysdep.h
+--- uClibc/ldso-0.9.24/ldso/m68k/ld_sysdep.h	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/m68k/ld_sysdep.h	2002-05-28 16:33:34.000000000 -0500
+@@ -0,0 +1,88 @@
++
++/* Various assmbly language/system dependent hacks that are required
++   so that we can minimize the amount of platform specific code. */
++
++/* Define this if the system uses RELOCA.  */
++#define ELF_USES_RELOCA
++
++/* Get a pointer to the argv array.  On many platforms this can be
++   just the address if the first argument, on other platforms we need
++   to do something a little more subtle here.  */
++#define GET_ARGV(ARGVP, ARGS) ((ARGVP) = ((unsigned int *) &(ARGS)))
++
++/* Initialization sequence for a GOT.  */
++#define INIT_GOT(GOT_BASE,MODULE)		\
++{						\
++  GOT_BASE[2] = (int) _dl_linux_resolve;	\
++  GOT_BASE[1] = (int) (MODULE);			\
++}
++
++/* Here is a macro to perform a relocation.  This is only used when
++   bootstrapping the dynamic loader.  RELP is the relocation that we
++   are performing, REL is the pointer to the address we are
++   relocating.  SYMBOL is the symbol involved in the relocation, and
++   LOAD is the load address. */
++#define PERFORM_BOOTSTRAP_RELOC(RELP,REL,SYMBOL,LOAD)		\
++  switch (ELF32_R_TYPE ((RELP)->r_info))			\
++    {								\
++    case R_68K_8:						\
++      *(char *) (REL) = (SYMBOL) + (RELP)->r_addend;		\
++      break;							\
++    case R_68K_16:						\
++      *(short *) (REL) = (SYMBOL) + (RELP)->r_addend;		\
++      break;							\
++    case R_68K_32:						\
++      *(REL) = (SYMBOL) + (RELP)->r_addend;			\
++      break;							\
++    case R_68K_PC8:						\
++      *(char *) (REL) = ((SYMBOL) + (RELP)->r_addend		\
++			 - (unsigned int) (REL));		\
++      break;							\
++    case R_68K_PC16:						\
++      *(short *) (REL) = ((SYMBOL) + (RELP)->r_addend		\
++			  - (unsigned int) (REL));		\
++      break;							\
++    case R_68K_PC32:						\
++      *(REL) = ((SYMBOL) + (RELP)->r_addend			\
++		- (unsigned int) (REL));			\
++      break;							\
++    case R_68K_GLOB_DAT:					\
++    case R_68K_JMP_SLOT:					\
++      *(REL) = (SYMBOL);					\
++      break;							\
++    case R_68K_RELATIVE:		/* Compatibility kludge */ \
++      *(REL) = ((unsigned int) (LOAD) + ((RELP)->r_addend ? : *(REL))); \
++      break;							\
++    default:							\
++      _dl_exit (1);						\
++    }
++
++
++/* Transfer control to the user's application, once the dynamic loader
++   is done.  */
++
++#define START()					\
++  __asm__ volatile ("unlk %%a6\n\t"		\
++		    "jmp %0@"			\
++		    : : "a" (_dl_elf_main));
++
++
++
++/* Here we define the magic numbers that this dynamic loader should accept */
++
++#define MAGIC1 EM_68K
++#undef MAGIC2
++/* Used for error messages */
++#define ELF_TARGET "m68k"
++
++struct elf_resolve;
++extern unsigned int _dl_linux_resolver (int, int, struct elf_resolve *, int);
++
++/* Define this because we do not want to call .udiv in the library.
++   Not needed for m68k.  */
++#define do_rem(result, n, base)  ((result) = (n) % (base))
++
++/* 4096 bytes alignment */
++#define PAGE_ALIGN 0xfffff000
++#define ADDR_ALIGN 0xfff
++#define OFFS_ALIGN 0x7ffff000
+diff -urN uClibc/ldso-0.9.24/ldso/m68k/resolve.S uClibc.ldso.24/ldso-0.9.24/ldso/m68k/resolve.S
+--- uClibc/ldso-0.9.24/ldso/m68k/resolve.S	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/m68k/resolve.S	2001-04-27 12:23:26.000000000 -0500
+@@ -0,0 +1,21 @@
++/*
++ * These are various helper routines that are needed to run an ELF image.
++ */
++
++.text
++.even
++
++.globl _dl_linux_resolve
++	.type	_dl_linux_resolve,@function
++_dl_linux_resolve:
++	moveml	%a0/%a1,%sp@-
++#ifdef __PIC__
++	bsrl	_dl_linux_resolver@PLTPC
++#else
++	jbsr	_dl_linux_resolver
++#endif
++	moveml	%sp@+,%a0/%a1
++	addql 	#8,%sp
++	jmp	@(%d0)
++.LFE2:
++	.size _dl_linux_resolve,.LFE2-_dl_linux_resolve
+diff -urN uClibc/ldso-0.9.24/ldso/mips/README uClibc.ldso.24/ldso-0.9.24/ldso/mips/README
+--- uClibc/ldso-0.9.24/ldso/mips/README	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/mips/README	2002-07-25 16:15:59.000000000 -0500
+@@ -0,0 +1,52 @@
++Almost all of the code present in these source files was taken
++from GLIBC. In the descriptions below, all files mentioned are
++with respect to the top level GLIBC source directory accept for
++code taken from the Linux kernel.
++
++boot1_arch.h
++------------
++Contains code to fix up the stack pointer so that the dynamic
++linker can find argc, argv and Auxillary Vector Table (AVT).
++The code is taken from the function 'RTLD_START' in the file
++'sysdeps/mips/dl-machine.h'.
++
++elfinterp.c
++-----------
++Contains the runtime resolver code taken from the function
++'__dl_runtime_resolve' in 'sysdeps/mips/dl-machine.h'. Also
++contains the function to perform relocations for objects
++other than the linker itself. The code was taken from the
++function 'elf_machine_rel' in 'sysdeps/mips/dl-machine.h'.
++
++ld_syscalls.h
++-------------
++Used to contain all the macro functions for the system calls
++as well as the list of system calls supported. We now include
++<sys/syscall.h> but with the __set_errno macro defined empty
++so we can use the same file for the linker as well as userspace.
++Original code was taken from the Linux kernel source 2.4.17 and
++can be found in the file 'include/asm-mips/unistd.h'.
++
++ld_sysdep.h
++-----------
++Contains bootstrap code for the dynamic linker, magic numbers
++for detecting MIPS target types and some macros. The macro
++function 'PERFORM_BOOTSTRAP_GOT' is used to relocate the dynamic
++linker's GOT so that function calls can be made. The code is
++taken from the function 'ELF_MACHINE_BEFORE_RTLD_RELOC' in the
++file 'sysdeps/mips/dl-machine.h'. The other macro function
++'PERFORM_BOOTSTRAP_RELOC' is used to do the relocations for
++the dynamic loader. The code is taken from the function
++'elf_machine_rel' in the file 'sysdeps/mips/dl-machine.h'. The
++final macro function is 'INIT_GOT' which initializes the GOT
++for the application being dynamically linked and loaded. The
++code is taken from the functions 'elf_machine_runtime_setup'
++and 'elf_machine_got_rel' in 'sysdeps/mips/dl-machine.h'.
++
++resolve.S
++---------
++Contains the low-level assembly code for the dynamic runtime
++resolver. The code is taken from the assembly code function
++'_dl_runtime_resolve' in the file 'sysdeps/mips/dl-machine.h'.
++The code looks a bit different since we only need to pass the
++symbol index and the old GP register.
+diff -urN uClibc/ldso-0.9.24/ldso/mips/boot1_arch.h uClibc.ldso.24/ldso-0.9.24/ldso/mips/boot1_arch.h
+--- uClibc/ldso-0.9.24/ldso/mips/boot1_arch.h	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/mips/boot1_arch.h	2003-06-12 16:39:10.000000000 -0500
+@@ -0,0 +1,38 @@
++/* Any assmbly language/system dependent hacks needed to setup boot1.c so it
++ * will work as expected and cope with whatever platform specific wierdness is
++ * needed for this architecture.
++ */
++
++asm("" \
++"	.text\n"			\
++"	.globl	_dl_boot\n"		\
++"_dl_boot:\n"				\
++"	.set noreorder\n"		\
++"	bltzal $0, 0f\n"		\
++"	nop\n"				\
++"0:	.cpload $31\n"			\
++"	.set reorder\n"			\
++"	la $4, _DYNAMIC\n"		\
++"	sw $4, -0x7ff0($28)\n"	        \
++"	move $4, $29\n"			\
++"	la $8, coff\n"			\
++"	.set noreorder\n"		\
++"	bltzal $0, coff\n"		\
++"	nop\n"				\
++"coff:	subu $8, $31, $8\n"		\
++"	.set reorder\n"			\
++"	la $25, _dl_boot2\n"	        \
++"	addu $25, $8\n"			\
++"	jalr $25\n"			\
++"	lw $4, 0($29)\n"		\
++"	la $5, 4($29)\n"		\
++"	sll $6, $4, 2\n"		\
++"	addu $6, $6, $5\n"		\
++"	addu $6, $6, 4\n"		\
++"	la $7, _dl_elf_main\n"		\
++"	lw $25, 0($7)\n"		\
++"	jr $25\n"			\
++);
++
++#define _dl_boot _dl_boot2
++#define LD_BOOT(X)   static void __attribute__ ((unused)) _dl_boot (X)
+diff -urN uClibc/ldso-0.9.24/ldso/mips/elfinterp.c uClibc.ldso.24/ldso-0.9.24/ldso/mips/elfinterp.c
+--- uClibc/ldso-0.9.24/ldso/mips/elfinterp.c	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/mips/elfinterp.c	2003-08-22 02:04:16.000000000 -0500
+@@ -0,0 +1,301 @@
++/* vi: set sw=4 ts=4: */
++/* mips/mipsel ELF shared library loader suppport
++ *
++   Copyright (C) 2002, Steven J. Hill (sjhill@realitydiluted.com)
++ *
++ * All rights reserved.
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions
++ * are met:
++ * 1. Redistributions of source code must retain the above copyright
++ *    notice, this list of conditions and the following disclaimer.
++ * 2. The name of the above contributors may not be
++ *    used to endorse or promote products derived from this software
++ *    without specific prior written permission.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND
++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ * ARE DISCLAIMED.  IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE
++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
++ * SUCH DAMAGE.
++ */
++
++#if defined (__SUPPORT_LD_DEBUG__)
++static const char *_dl_reltypes_tab[] =
++{
++		[0]		"R_MIPS_NONE",	"R_MIPS_16",	"R_MIPS_32",
++		[3]		"R_MIPS_REL32",	"R_MIPS_26",	"R_MIPS_HI16",
++		[6]		"R_MIPS_LO16",	"R_MIPS_GPREL16",	"R_MIPS_LITERAL",
++		[9]		"R_MIPS_GOT16",	"R_MIPS_PC16",	"R_MIPS_CALL16",
++		[12]	"R_MIPS_GPREL32",
++		[16]	"R_MIPS_SHIFT5",	"R_MIPS_SHIFT6",	"R_MIPS_64",
++		[19]	"R_MIPS_GOT_DISP",	"R_MIPS_GOT_PAGE",	"R_MIPS_GOT_OFST",
++		[22]	"R_MIPS_GOT_HI16",	"R_MIPS_GOT_LO16",	"R_MIPS_SUB",
++		[25]	"R_MIPS_INSERT_A",	"R_MIPS_INSERT_B",	"R_MIPS_DELETE",
++		[28]	"R_MIPS_HIGHER",	"R_MIPS_HIGHEST",	"R_MIPS_CALL_HI16",
++		[31]	"R_MIPS_CALL_LO16",	"R_MIPS_SCN_DISP",	"R_MIPS_REL16",
++		[34]	"R_MIPS_ADD_IMMEDIATE",	"R_MIPS_PJUMP",	"R_MIPS_RELGOT",
++		[37]	"R_MIPS_JALR",
++};
++
++static const char *
++_dl_reltypes(int type)
++{
++  static char buf[22];  
++  const char *str;
++  
++  if (type >= (int)(sizeof (_dl_reltypes_tab)/sizeof(_dl_reltypes_tab[0])) ||
++      NULL == (str = _dl_reltypes_tab[type]))
++  {
++    str =_dl_simple_ltoa( buf, (unsigned long)(type));
++  }
++  return str;
++}
++
++static 
++void debug_sym(Elf32_Sym *symtab,char *strtab,int symtab_index)
++{
++  if(_dl_debug_symbols)
++  {
++    if(symtab_index){
++      _dl_dprintf(_dl_debug_file, "\n%s\n\tvalue=%x\tsize=%x\tinfo=%x\tother=%x\tshndx=%x",
++		  strtab + symtab[symtab_index].st_name,
++		  symtab[symtab_index].st_value,
++		  symtab[symtab_index].st_size,
++		  symtab[symtab_index].st_info,
++		  symtab[symtab_index].st_other,
++		  symtab[symtab_index].st_shndx);
++    }
++  }
++}
++
++static void debug_reloc(Elf32_Sym *symtab,char *strtab, ELF_RELOC *rpnt)
++{
++  if(_dl_debug_reloc)
++  {
++    int symtab_index;
++    const char *sym;
++    symtab_index = ELF32_R_SYM(rpnt->r_info);
++    sym = symtab_index ? strtab + symtab[symtab_index].st_name : "sym=0x0";
++    
++  if(_dl_debug_symbols)
++	  _dl_dprintf(_dl_debug_file, "\n\t");
++  else
++	  _dl_dprintf(_dl_debug_file, "\n%s\n\t", sym);
++#ifdef ELF_USES_RELOCA
++    _dl_dprintf(_dl_debug_file, "%s\toffset=%x\taddend=%x",
++		_dl_reltypes(ELF32_R_TYPE(rpnt->r_info)),
++		rpnt->r_offset,
++		rpnt->r_addend);
++#else
++    _dl_dprintf(_dl_debug_file, "%s\toffset=%x\n",
++		_dl_reltypes(ELF32_R_TYPE(rpnt->r_info)),
++		rpnt->r_offset);
++#endif
++  }
++}
++#endif
++
++extern int _dl_linux_resolve(void);
++
++#define OFFSET_GP_GOT 0x7ff0
++
++unsigned long _dl_linux_resolver(unsigned long sym_index,
++	unsigned long old_gpreg)
++{
++	unsigned long *got = (unsigned long *) (old_gpreg - OFFSET_GP_GOT);
++	struct elf_resolve *tpnt = (struct elf_resolve *) got[1];
++	Elf32_Sym *sym;
++	char *strtab;
++	unsigned long local_gotno;
++	unsigned long gotsym;
++	unsigned long new_addr;
++	unsigned long instr_addr;
++	char **got_addr;
++	char *symname;
++
++	gotsym = tpnt->mips_gotsym;
++	local_gotno = tpnt->mips_local_gotno;
++
++	sym = ((Elf32_Sym *) (tpnt->dynamic_info[DT_SYMTAB] + tpnt->loadaddr)) + sym_index;
++	strtab = (char *) (tpnt->dynamic_info[DT_STRTAB] + tpnt->loadaddr);
++	symname = strtab + sym->st_name;
++
++	new_addr = (unsigned long) _dl_find_hash(strtab + sym->st_name,
++		 tpnt->symbol_scope, tpnt, resolver);
++	 
++	/* Address of jump instruction to fix up */
++	instr_addr = (unsigned long) (got + local_gotno + sym_index - gotsym); 
++	got_addr = (char **) instr_addr;
++	 
++#if defined (__SUPPORT_LD_DEBUG__)
++	if (_dl_debug_bindings)
++	{
++		_dl_dprintf(_dl_debug_file, "\nresolve function: %s", symname);
++		if(_dl_debug_detail) _dl_dprintf(_dl_debug_file, 
++				"\n\tpatched %x ==> %x @ %x\n", *got_addr, new_addr, got_addr);
++	}
++	if (!_dl_debug_nofixups) {
++		*got_addr = (char*)new_addr;
++	}
++#else
++	*got_addr = (char*)new_addr;
++#endif
++
++	return new_addr;
++}
++
++void _dl_parse_lazy_relocation_information(struct elf_resolve *tpnt, 
++	unsigned long rel_addr, unsigned long rel_size, int type)
++{
++	/* Nothing to do */
++	return;
++}
++
++int _dl_parse_copy_information(struct dyn_elf *xpnt, unsigned long rel_addr, 
++	unsigned long rel_size, int type)
++{
++	/* Nothing to do */
++	return 0;
++}
++
++
++int _dl_parse_relocation_information(struct elf_resolve *tpnt, 
++	unsigned long rel_addr, unsigned long rel_size, int type)
++{
++	Elf32_Sym *symtab;
++	Elf32_Rel *rpnt;
++	char *strtab;
++	unsigned long *got;
++	unsigned long *reloc_addr=NULL, old_val=0;
++	unsigned long symbol_addr;
++	int i, reloc_type, symtab_index;
++
++	/* Now parse the relocation information */
++	rel_size = rel_size / sizeof(Elf32_Rel);
++	rpnt = (Elf32_Rel *) (rel_addr + tpnt->loadaddr);
++
++	symtab = (Elf32_Sym *) (tpnt->dynamic_info[DT_SYMTAB] + tpnt->loadaddr);
++	strtab = (char *) (tpnt->dynamic_info[DT_STRTAB] + tpnt->loadaddr);
++	got = (unsigned long *) (tpnt->dynamic_info[DT_PLTGOT] + tpnt->loadaddr);
++
++	for (i = 0; i < rel_size; i++, rpnt++) {
++		reloc_addr = (unsigned long *) (tpnt->loadaddr +
++			(unsigned long) rpnt->r_offset);
++		reloc_type = ELF32_R_TYPE(rpnt->r_info);
++		symtab_index = ELF32_R_SYM(rpnt->r_info);
++		symbol_addr = 0;
++
++		if (!symtab_index && tpnt->libtype == program_interpreter)
++			continue;
++
++#if defined (__SUPPORT_LD_DEBUG__)
++		debug_sym(symtab,strtab,symtab_index);
++		debug_reloc(symtab,strtab,rpnt);
++		old_val = *reloc_addr;
++#endif
++
++		switch (reloc_type) {
++		case R_MIPS_REL32:
++			if (symtab_index) {
++				if (symtab_index < tpnt->mips_gotsym)
++					*reloc_addr +=
++						symtab[symtab_index].st_value +
++						(unsigned long) tpnt->loadaddr;
++				else {
++					*reloc_addr += got[symtab_index + tpnt->mips_local_gotno -
++						tpnt->mips_gotsym];
++				}
++			}
++			else {
++				*reloc_addr += (unsigned long) tpnt->loadaddr;
++			}
++			break;
++		case R_MIPS_NONE:
++			break;
++		default:
++			{
++				int reloc_type = ELF32_R_TYPE(rpnt->r_info);
++				_dl_dprintf(2, "\n%s: ",_dl_progname);
++
++				if (symtab_index)
++					_dl_dprintf(2, "symbol '%s': ", strtab + symtab[symtab_index].st_name);
++
++#if defined (__SUPPORT_LD_DEBUG__)
++				_dl_dprintf(2, "can't handle reloc type %s\n ", _dl_reltypes(reloc_type));
++#else
++				_dl_dprintf(2, "can't handle reloc type %x\n", reloc_type);
++#endif			
++				_dl_exit(1);
++			}
++		};
++
++	};
++#if defined (__SUPPORT_LD_DEBUG__)
++	if(_dl_debug_reloc && _dl_debug_detail)
++		_dl_dprintf(_dl_debug_file, "\tpatched: %x ==> %x @ %x\n", old_val, *reloc_addr, reloc_addr);
++#endif
++
++	return 0;
++}
++
++void _dl_perform_mips_global_got_relocations(struct elf_resolve *tpnt)
++{
++	Elf32_Sym *sym;
++	char *strtab;
++	unsigned long i;
++	unsigned long *got_entry;
++
++	for (; tpnt ; tpnt = tpnt->next) {
++
++		/* We don't touch the dynamic linker */
++		if (tpnt->libtype == program_interpreter)
++			continue;
++
++		/* Setup the loop variables */
++		got_entry = (unsigned long *) (tpnt->loadaddr +
++			tpnt->dynamic_info[DT_PLTGOT]) + tpnt->mips_local_gotno;
++		sym = (Elf32_Sym *) (tpnt->dynamic_info[DT_SYMTAB] +
++			(unsigned long) tpnt->loadaddr) + tpnt->mips_gotsym;
++		strtab = (char *) (tpnt->dynamic_info[DT_STRTAB] +
++			(unsigned long) tpnt->loadaddr);
++		i = tpnt->mips_symtabno - tpnt->mips_gotsym;
++
++		/* Relocate the global GOT entries for the object */
++		while(i--) {
++			if (sym->st_shndx == SHN_UNDEF) {
++				if (ELF32_ST_TYPE(sym->st_info) == STT_FUNC && sym->st_value)
++					*got_entry = sym->st_value + (unsigned long) tpnt->loadaddr;
++				else {
++					*got_entry = (unsigned long) _dl_find_hash(strtab +
++						sym->st_name, tpnt->symbol_scope, NULL, copyrel);
++				}
++			}
++			else if (sym->st_shndx == SHN_COMMON) {
++				*got_entry = (unsigned long) _dl_find_hash(strtab +
++					sym->st_name, tpnt->symbol_scope, NULL, copyrel);
++			}
++			else if (ELF32_ST_TYPE(sym->st_info) == STT_FUNC &&
++				*got_entry != sym->st_value)
++				*got_entry += (unsigned long) tpnt->loadaddr;
++			else if (ELF32_ST_TYPE(sym->st_info) == STT_SECTION) {
++				if (sym->st_other == 0)
++					*got_entry += (unsigned long) tpnt->loadaddr;
++			}
++			else {
++				*got_entry = (unsigned long) _dl_find_hash(strtab +
++					sym->st_name, tpnt->symbol_scope, NULL, copyrel);
++			}
++
++			got_entry++;
++			sym++;
++		}
++	}
++}
+diff -urN uClibc/ldso-0.9.24/ldso/mips/ld_syscalls.h uClibc.ldso.24/ldso-0.9.24/ldso/mips/ld_syscalls.h
+--- uClibc/ldso-0.9.24/ldso/mips/ld_syscalls.h	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/mips/ld_syscalls.h	2002-08-09 07:20:20.000000000 -0500
+@@ -0,0 +1,7 @@
++/* Define the __set_errno macro as nothing so that we don't bother
++ * setting errno, which is important since we make system calls
++ * before the errno symbol is dynamicly linked. */
++
++#define __set_errno(X) {(void)(X);}
++#include "sys/syscall.h"
++
+diff -urN uClibc/ldso-0.9.24/ldso/mips/ld_sysdep.h uClibc.ldso.24/ldso-0.9.24/ldso/mips/ld_sysdep.h
+--- uClibc/ldso-0.9.24/ldso/mips/ld_sysdep.h	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/mips/ld_sysdep.h	2002-05-28 16:33:36.000000000 -0500
+@@ -0,0 +1,136 @@
++/* vi: set sw=4 ts=4: */
++
++/*
++ * Various assmbly language/system dependent hacks that are required
++ * so that we can minimize the amount of platform specific code.
++ */
++
++/* 
++ * Define this if the system uses RELOCA.
++ */
++#undef ELF_USES_RELOCA
++
++
++/*
++ * Get a pointer to the argv array.  On many platforms this can be just
++ * the address if the first argument, on other platforms we need to
++ * do something a little more subtle here.
++ */
++#define GET_ARGV(ARGVP, ARGS) ARGVP = ((unsigned long *) ARGS)
++
++
++/*
++ * Initialization sequence for the application/library GOT.
++ */
++#define INIT_GOT(GOT_BASE,MODULE)										\
++do {																	\
++	unsigned long i;													\
++																		\
++	/* Check if this is the dynamic linker itself */					\
++	if (MODULE->libtype == program_interpreter)							\
++		continue;														\
++																		\
++	/* Fill in first two GOT entries according to the ABI */			\
++	GOT_BASE[0] = (unsigned long) _dl_linux_resolve;					\
++	GOT_BASE[1] = (unsigned long) MODULE;								\
++																		\
++	/* Add load address displacement to all local GOT entries */		\
++	i = 2;																\
++	while (i < MODULE->mips_local_gotno)								\
++		GOT_BASE[i++] += (unsigned long) MODULE->loadaddr;				\
++																		\
++} while (0)
++
++
++/*
++ * Here is a macro to perform the GOT relocation. This is only
++ * used when bootstrapping the dynamic loader.
++ */
++#define PERFORM_BOOTSTRAP_GOT(got)										\
++do {																	\
++	Elf32_Sym *sym;														\
++	unsigned long i;													\
++																		\
++	/* Add load address displacement to all local GOT entries */		\
++	i = 2;																\
++	while (i < tpnt->mips_local_gotno)									\
++		got[i++] += load_addr;											\
++																		\
++	/* Handle global GOT entries */										\
++	got += tpnt->mips_local_gotno;										\
++	sym = (Elf32_Sym *) (tpnt->dynamic_info[DT_SYMTAB] +				\
++		 load_addr) + tpnt->mips_gotsym;								\
++	i = tpnt->mips_symtabno - tpnt->mips_gotsym;						\
++																		\
++	while (i--) {														\
++		if (sym->st_shndx == SHN_UNDEF ||								\
++			sym->st_shndx == SHN_COMMON)								\
++			*got = load_addr + sym->st_value;							\
++		else if (ELF32_ST_TYPE(sym->st_info) == STT_FUNC &&				\
++			*got != sym->st_value)										\
++			*got += load_addr;											\
++		else if (ELF32_ST_TYPE(sym->st_info) == STT_SECTION) {			\
++			if (sym->st_other == 0)										\
++				*got += load_addr;										\
++		}																\
++		else															\
++			*got = load_addr + sym->st_value;							\
++																		\
++		got++;															\
++		sym++;															\
++	}																	\
++} while (0)
++
++
++/*
++ * Here is a macro to perform a relocation.  This is only used when
++ * bootstrapping the dynamic loader.
++ */
++#define PERFORM_BOOTSTRAP_RELOC(RELP,REL,SYMBOL,LOAD)					\
++	switch(ELF32_R_TYPE((RELP)->r_info)) {								\
++	case R_MIPS_REL32:													\
++		if (symtab_index) {												\
++			if (symtab_index < tpnt->mips_gotsym)						\
++				*REL += SYMBOL;											\
++		}																\
++		else {															\
++			*REL += LOAD;												\
++		}																\
++		break;															\
++	case R_MIPS_NONE:													\
++		break;															\
++	default:															\
++		SEND_STDERR("Aiieeee!");										\
++		_dl_exit(1);													\
++	}
++
++
++/*
++ * Transfer control to the user's application, once the dynamic loader
++ * is done.  This routine has to exit the current function, then 
++ * call the _dl_elf_main function. For MIPS, we do it in assembly
++ * because the stack doesn't get properly restored otherwise. Got look
++ * at boot1_arch.h
++ */
++#define START()
++
++
++/* Here we define the magic numbers that this dynamic loader should accept */
++#define MAGIC1 EM_MIPS
++#define MAGIC2 EM_MIPS_RS3_LE
++
++
++/* Used for error messages */
++#define ELF_TARGET "MIPS"
++
++
++unsigned long _dl_linux_resolver(unsigned long sym_index,
++	unsigned long old_gpreg);
++
++
++#define do_rem(result, n, base)  result = (n % base)
++
++/* 4096 bytes alignment */
++#define PAGE_ALIGN 0xfffff000
++#define ADDR_ALIGN 0xfff
++#define OFFS_ALIGN 0x7ffff000
+diff -urN uClibc/ldso-0.9.24/ldso/mips/resolve.S uClibc.ldso.24/ldso-0.9.24/ldso/mips/resolve.S
+--- uClibc/ldso-0.9.24/ldso/mips/resolve.S	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/mips/resolve.S	2003-01-30 10:40:26.000000000 -0600
+@@ -0,0 +1,45 @@
++	/*
++ * Linux dynamic resolving code for MIPS. Fixes up the GOT entry as
++ * indicated in register t8 and jumps to the resolved address. Shamelessly
++ * ripped from 'sysdeps/mips/dl-machine.h' in glibc-2.2.5.
++ *
++ * This file is subject to the terms and conditions of the GNU Lesser General
++ * Public License.  See the file "COPYING.LIB" in the main directory of this
++ * archive for more details.
++ *
++ * Copyright (C) 1996-2001 Kazumoto Kojima <kkojima@info.kanagawa-u.ac.jp>
++ * Copyright (C) 2002 Steven J. Hill <sjhill@realitydiluted.com>
++ *
++ */
++.text
++.align	2
++.globl	_dl_linux_resolve
++.type	_dl_linux_resolve,@function
++.ent	_dl_linux_resolve
++_dl_linux_resolve:
++	.frame	$29, 40, $31
++	.set noreorder
++	move	$3, $28		# Save GP
++	addu	$25, 8		# t9 ($25) now points at .cpload instruction
++	.cpload	$25		# Compute GP
++	.set reorder
++	subu	$29, 40
++	.cprestore 32
++	sw	$15, 36($29)
++	sw	$4, 16($29)
++	sw	$5, 20($29)
++	sw	$6, 24($29)
++	sw	$7, 28($29)
++	move	$4, $24
++	move	$5, $3
++	jal     _dl_linux_resolver
++	lw	$31, 36($29)
++	lw	$4, 16($29)
++	lw	$5, 20($29)
++	lw	$6, 24($29)
++	lw	$7, 28($29)
++	addu	$29, 40
++	move	$25, $2
++	jr	$25
++.size _dl_linux_resolve,.-_dl_linux_resolve
++.end _dl_linux_resolve
+diff -urN uClibc/ldso-0.9.24/ldso/powerpc/boot1_arch.h uClibc.ldso.24/ldso-0.9.24/ldso/powerpc/boot1_arch.h
+--- uClibc/ldso-0.9.24/ldso/powerpc/boot1_arch.h	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/powerpc/boot1_arch.h	2003-02-15 19:22:41.000000000 -0600
+@@ -0,0 +1,20 @@
++/* Any assmbly language/system dependent hacks needed to setup boot1.c so it
++ * will work as expected and cope with whatever platform specific wierdness is
++ * needed for this architecture.  */
++
++/* Overrive the default _dl_boot function, and replace it with a bit of asm.
++ * Then call the real _dl_boot function, which is now named _dl_boot2. */
++
++asm("" \
++"	.text\n"			\
++"	.globl	_dl_boot\n"		\
++"_dl_boot:\n"				\
++"	mr	3,1\n"			\
++"	addi	1,1,-16\n"		\
++"	bl      _dl_boot2\n"		\
++".previous\n"				\
++);
++
++#define _dl_boot _dl_boot2
++#define LD_BOOT(X)   static void *  __attribute__ ((unused)) _dl_boot (X)
++
+diff -urN uClibc/ldso-0.9.24/ldso/powerpc/elfinterp.c uClibc.ldso.24/ldso-0.9.24/ldso/powerpc/elfinterp.c
+--- uClibc/ldso-0.9.24/ldso/powerpc/elfinterp.c	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/powerpc/elfinterp.c	2003-12-03 17:28:33.000000000 -0600
+@@ -0,0 +1,621 @@
++/* vi: set sw=4 ts=4: */
++/* powerpc shared library loader suppport
++ *
++ * Copyright (C) 2001-2002,  David A. Schleef
++ * Copyright (C) 2003, Erik Andersen
++ *
++ * All rights reserved.
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions
++ * are met:
++ * 1. Redistributions of source code must retain the above copyright
++ *    notice, this list of conditions and the following disclaimer.
++ * 2. The name of the above contributors may not be
++ *    used to endorse or promote products derived from this software
++ *    without specific prior written permission.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND
++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ * ARE DISCLAIMED.  IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE
++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
++ * SUCH DAMAGE.
++ */
++
++#if defined (__SUPPORT_LD_DEBUG__)
++static const char *_dl_reltypes_tab[] =
++	{ "R_PPC_NONE", "R_PPC_ADDR32", "R_PPC_ADDR24", "R_PPC_ADDR16",
++	"R_PPC_ADDR16_LO", "R_PPC_ADDR16_HI", "R_PPC_ADDR16_HA",
++	"R_PPC_ADDR14", "R_PPC_ADDR14_BRTAKEN", "R_PPC_ADDR14_BRNTAKEN",
++	"R_PPC_REL24", "R_PPC_REL14", "R_PPC_REL14_BRTAKEN",
++	"R_PPC_REL14_BRNTAKEN", "R_PPC_GOT16", "R_PPC_GOT16_LO",
++	"R_PPC_GOT16_HI", "R_PPC_GOT16_HA", "R_PPC_PLTREL24",
++	"R_PPC_COPY", "R_PPC_GLOB_DAT", "R_PPC_JMP_SLOT", "R_PPC_RELATIVE",
++	"R_PPC_LOCAL24PC", "R_PPC_UADDR32", "R_PPC_UADDR16", "R_PPC_REL32",
++	"R_PPC_PLT32", "R_PPC_PLTREL32", "R_PPC_PLT16_LO", "R_PPC_PLT16_HI",
++	"R_PPC_PLT16_HA", "R_PPC_SDAREL16", "R_PPC_SECTOFF",
++	"R_PPC_SECTOFF_LO", "R_PPC_SECTOFF_HI", "R_PPC_SECTOFF_HA",
++};
++
++static const char *
++_dl_reltypes(int type)
++{
++  static char buf[22];  
++  const char *str;
++  
++  if (type >= (int)(sizeof (_dl_reltypes_tab)/sizeof(_dl_reltypes_tab[0])) ||
++      NULL == (str = _dl_reltypes_tab[type]))
++  {
++    str =_dl_simple_ltoa( buf, (unsigned long)(type));
++  }
++  return str;
++}
++
++static 
++void debug_sym(Elf32_Sym *symtab,char *strtab,int symtab_index)
++{
++  if(_dl_debug_symbols)
++  {
++    if(symtab_index){
++      _dl_dprintf(_dl_debug_file, "\n%s\n\tvalue=%x\tsize=%x\tinfo=%x\tother=%x\tshndx=%x",
++		  strtab + symtab[symtab_index].st_name,
++		  symtab[symtab_index].st_value,
++		  symtab[symtab_index].st_size,
++		  symtab[symtab_index].st_info,
++		  symtab[symtab_index].st_other,
++		  symtab[symtab_index].st_shndx);
++    }
++  }
++}
++
++static 
++void debug_reloc(Elf32_Sym *symtab,char *strtab, ELF_RELOC *rpnt)
++{
++  if(_dl_debug_reloc)
++  {
++    int symtab_index;
++    const char *sym;
++    symtab_index = ELF32_R_SYM(rpnt->r_info);
++    sym = symtab_index ? strtab + symtab[symtab_index].st_name : "sym=0x0";
++    
++  if(_dl_debug_symbols)
++	  _dl_dprintf(_dl_debug_file, "\n\t");
++  else
++	  _dl_dprintf(_dl_debug_file, "\n%s\n\t", sym);
++#ifdef ELF_USES_RELOCA
++    _dl_dprintf(_dl_debug_file, "%s\toffset=%x\taddend=%x",
++		_dl_reltypes(ELF32_R_TYPE(rpnt->r_info)),
++		rpnt->r_offset,
++		rpnt->r_addend);
++#else
++    _dl_dprintf(_dl_debug_file, "%s\toffset=%x\n",
++		_dl_reltypes(ELF32_R_TYPE(rpnt->r_info)),
++		rpnt->r_offset);
++#endif
++  }
++}
++#endif
++
++extern int _dl_linux_resolve(void);
++
++void _dl_init_got(unsigned long *plt,struct elf_resolve *tpnt)
++{
++	unsigned long target_addr = (unsigned long)_dl_linux_resolve;
++	unsigned int n_plt_entries;
++	unsigned long *tramp;
++	unsigned long data_words;
++	unsigned int rel_offset_words;
++
++	//DPRINTF("init_got plt=%x, tpnt=%x\n", (unsigned long)plt,(unsigned long)tpnt);
++
++	n_plt_entries = tpnt->dynamic_info[DT_PLTRELSZ] / sizeof(ELF_RELOC);
++	//DPRINTF("n_plt_entries %d\n",n_plt_entries);
++
++	rel_offset_words = PLT_DATA_START_WORDS(n_plt_entries);
++	//DPRINTF("rel_offset_words %x\n",rel_offset_words);
++	data_words = (unsigned long)(plt + rel_offset_words);
++	//DPRINTF("data_words %x\n",data_words);
++
++	tpnt->data_words = data_words;
++
++	plt[PLT_LONGBRANCH_ENTRY_WORDS] = OPCODE_ADDIS_HI(11, 11, data_words);
++	plt[PLT_LONGBRANCH_ENTRY_WORDS+1] = OPCODE_LWZ(11,data_words,11);
++
++	plt[PLT_LONGBRANCH_ENTRY_WORDS+2] = OPCODE_MTCTR(11);
++	plt[PLT_LONGBRANCH_ENTRY_WORDS+3] = OPCODE_BCTR();
++
++	/* [4] */
++	/* [5] */
++
++	tramp = plt + PLT_TRAMPOLINE_ENTRY_WORDS;
++	tramp[0] = OPCODE_ADDIS_HI(11,11,-data_words);
++	tramp[1] = OPCODE_ADDI(11,11,-data_words);
++	tramp[2] = OPCODE_SLWI(12,11,1);
++	tramp[3] = OPCODE_ADD(11,12,11);
++	tramp[4] = OPCODE_LI(12,target_addr);
++	tramp[5] = OPCODE_ADDIS_HI(12,12,target_addr);
++	tramp[6] = OPCODE_MTCTR(12);
++	tramp[7] = OPCODE_LI(12,(unsigned long)tpnt);
++	tramp[8] = OPCODE_ADDIS_HI(12,12,(unsigned long)tpnt);
++	tramp[9] = OPCODE_BCTR();
++
++	/* [16] unused */
++	/* [17] unused */
++
++	/* instructions were modified */
++	PPC_DCBST(plt);
++	PPC_DCBST(plt+4);
++	PPC_DCBST(plt+8);
++	PPC_DCBST(plt+12);
++	PPC_DCBST(plt+16-1);
++	PPC_SYNC;
++	PPC_ICBI(plt);
++	PPC_ICBI(plt+4); /* glibc thinks this is not needed */
++	PPC_ICBI(plt+8); /* glibc thinks this is not needed */
++	PPC_ICBI(plt+12); /* glibc thinks this is not needed */
++	PPC_ICBI(plt+16-1);
++	PPC_ISYNC;
++}
++
++unsigned long _dl_linux_resolver(struct elf_resolve *tpnt, int reloc_entry)
++{
++	int reloc_type;
++	ELF_RELOC *this_reloc;
++	char *strtab;
++	Elf32_Sym *symtab;
++	ELF_RELOC *rel_addr;
++	int symtab_index;
++	char *symname;
++	unsigned long insn_addr;
++	unsigned long *insns;
++	unsigned long new_addr;
++	unsigned long delta;
++
++	rel_addr = (ELF_RELOC *) (tpnt->dynamic_info[DT_JMPREL] + tpnt->loadaddr);
++
++	this_reloc = (void *)rel_addr + reloc_entry;
++	reloc_type = ELF32_R_TYPE(this_reloc->r_info);
++	symtab_index = ELF32_R_SYM(this_reloc->r_info);
++
++	symtab = (Elf32_Sym *) (tpnt->dynamic_info[DT_SYMTAB] + tpnt->loadaddr);
++	strtab = (char *) (tpnt->dynamic_info[DT_STRTAB] + tpnt->loadaddr);
++	symname      = strtab + symtab[symtab_index].st_name;
++
++#if defined (__SUPPORT_LD_DEBUG__)
++	debug_sym(symtab,strtab,symtab_index);
++	debug_reloc(symtab,strtab,this_reloc);
++#endif
++
++	if (reloc_type != R_PPC_JMP_SLOT) {
++		_dl_dprintf(2, "%s: Incorrect relocation type in jump relocation\n", _dl_progname);
++		_dl_exit(1);
++	};
++
++	/* Address of dump instruction to fix up */
++	insn_addr = (unsigned long) tpnt->loadaddr +
++		(unsigned long) this_reloc->r_offset;
++
++#if defined (__SUPPORT_LD_DEBUG__)
++	if(_dl_debug_reloc && _dl_debug_detail)
++		_dl_dprintf(_dl_debug_file, "\n\tResolving symbol %s %x --> ", symname, insn_addr);
++#endif
++
++	/* Get the address of the GOT entry */
++	new_addr = (unsigned long) _dl_find_hash(
++		strtab + symtab[symtab_index].st_name, 
++		tpnt->symbol_scope, tpnt, resolver);
++	if (!new_addr) {
++		_dl_dprintf(2, "%s: can't resolve symbol '%s'\n", 
++			_dl_progname, symname);
++		_dl_exit(1);
++	};
++
++#if defined (__SUPPORT_LD_DEBUG__)
++	if(_dl_debug_reloc && _dl_debug_detail)
++		_dl_dprintf(_dl_debug_file, "%x\n", new_addr);
++#endif
++
++	insns = (unsigned long *)insn_addr;
++	delta = new_addr - insn_addr;
++
++	if(delta<<6>>6 == delta){
++		insns[0] = OPCODE_B(delta);
++	}else if (new_addr <= 0x01fffffc || new_addr >= 0xfe000000){
++		insns[0] = OPCODE_BA (new_addr);
++	}else{
++		/* Warning: we don't handle double-sized PLT entries */
++		unsigned long plt_addr;
++		unsigned long *ptr;
++		int index;
++
++		plt_addr = (unsigned long)tpnt->dynamic_info[DT_PLTGOT] + 
++			(unsigned long)tpnt->loadaddr;
++
++		delta = PLT_LONGBRANCH_ENTRY_WORDS*4 - (insn_addr-plt_addr+4);
++
++		index = (insn_addr - plt_addr - PLT_INITIAL_ENTRY_WORDS*4)/8;
++
++		ptr = (unsigned long *)tpnt->data_words;
++		//DPRINTF("plt_addr=%x delta=%x index=%x ptr=%x\n", plt_addr, delta, index, ptr);
++		insns += 1;
++
++		ptr[index] = new_addr;
++		PPC_SYNC;
++		/* icache sync is not necessary, since this will be a data load */
++		//PPC_DCBST(ptr+index);
++		//PPC_SYNC;
++		//PPC_ICBI(ptr+index);
++		//PPC_ISYNC;
++
++		insns[0] = OPCODE_B(delta);
++
++	}
++
++	/* instructions were modified */
++	PPC_DCBST(insns);
++	PPC_SYNC;
++	PPC_ICBI(insns);
++	PPC_ISYNC;
++
++	return new_addr;
++}
++
++static int
++_dl_parse(struct elf_resolve *tpnt, struct dyn_elf *scope,
++	  unsigned long rel_addr, unsigned long rel_size,
++	  int (*reloc_fnc) (struct elf_resolve *tpnt, struct dyn_elf *scope,
++			    ELF_RELOC *rpnt, Elf32_Sym *symtab, char *strtab))
++{
++	unsigned int i;
++	char *strtab;
++	Elf32_Sym *symtab;
++	ELF_RELOC *rpnt;
++	int symtab_index;
++
++	/* Now parse the relocation information */
++	rpnt = (ELF_RELOC *)(intptr_t) (rel_addr + tpnt->loadaddr);
++	rel_size = rel_size / sizeof(ELF_RELOC);
++
++	symtab = (Elf32_Sym *)(intptr_t) (tpnt->dynamic_info[DT_SYMTAB] + tpnt->loadaddr);
++	strtab = (char *) (tpnt->dynamic_info[DT_STRTAB] + tpnt->loadaddr);
++
++	  for (i = 0; i < rel_size; i++, rpnt++) {
++	        int res;
++	    
++		symtab_index = ELF32_R_SYM(rpnt->r_info);
++		
++		/* When the dynamic linker bootstrapped itself, it resolved some symbols.
++		   Make sure we do not do them again */
++		if (!symtab_index && tpnt->libtype == program_interpreter)
++			continue;
++		if (symtab_index && tpnt->libtype == program_interpreter &&
++		    _dl_symbol(strtab + symtab[symtab_index].st_name))
++			continue;
++
++#if defined (__SUPPORT_LD_DEBUG__)
++		debug_sym(symtab,strtab,symtab_index);
++		debug_reloc(symtab,strtab,rpnt);
++#endif
++
++		res = reloc_fnc (tpnt, scope, rpnt, symtab, strtab);
++
++		if (res==0) continue;
++
++		_dl_dprintf(2, "\n%s: ",_dl_progname);
++		
++		if (symtab_index)
++		  _dl_dprintf(2, "symbol '%s': ", strtab + symtab[symtab_index].st_name);
++		  
++		if (res <0)
++		{
++		        int reloc_type = ELF32_R_TYPE(rpnt->r_info);
++#if defined (__SUPPORT_LD_DEBUG__)
++			_dl_dprintf(2, "can't handle reloc type %s\n ", _dl_reltypes(reloc_type));
++#else
++			_dl_dprintf(2, "can't handle reloc type %x\n", reloc_type);
++#endif			
++			_dl_exit(-res);
++		}
++		else if (res >0)
++		{
++			_dl_dprintf(2, "can't resolve symbol\n");
++			return res;
++		}
++	  }
++	  return 0;
++}
++
++static int
++_dl_do_lazy_reloc (struct elf_resolve *tpnt, struct dyn_elf *scope,
++		   ELF_RELOC *rpnt, Elf32_Sym *symtab, char *strtab)
++{
++	int reloc_type;
++	unsigned long reloc_addr;
++#if defined (__SUPPORT_LD_DEBUG__)
++	unsigned long old_val;
++#endif
++	(void)scope;
++	(void)symtab;
++	(void)strtab;
++
++	reloc_addr = (unsigned long)tpnt->loadaddr + (unsigned long) rpnt->r_offset;
++	reloc_type = ELF32_R_TYPE(rpnt->r_info);
++
++#if defined (__SUPPORT_LD_DEBUG__)
++	old_val = reloc_addr;
++#endif
++
++	switch (reloc_type) {
++		case R_PPC_NONE:
++			return 0;
++			break;
++		case R_PPC_JMP_SLOT:
++			{
++				int index;
++				unsigned long delta;
++				unsigned long *plt;
++				unsigned long *insns;
++
++				plt = (unsigned long *)(tpnt->dynamic_info[DT_PLTGOT] + tpnt->loadaddr);
++
++				delta = (unsigned long)(plt+PLT_TRAMPOLINE_ENTRY_WORDS+2) - (reloc_addr+4);
++
++				index = (reloc_addr - (unsigned long)(plt+PLT_INITIAL_ENTRY_WORDS)) 
++						/sizeof(unsigned long);
++				index /= 2;
++				//DPRINTF("        index %x delta %x\n",index,delta);
++				insns = (unsigned long *)reloc_addr;
++				insns[0] = OPCODE_LI(11,index*4);
++				insns[1] = OPCODE_B(delta);
++				break;
++			}
++		default:
++#if 0
++			_dl_dprintf(2, "%s: (LAZY) can't handle reloc type ", 
++					_dl_progname);
++#if defined (__SUPPORT_LD_DEBUG__)
++			_dl_dprintf(2, "%s ", _dl_reltypes[reloc_type]);
++#endif
++			if (symtab_index)
++				_dl_dprintf(2, "'%s'\n", strtab + symtab[symtab_index].st_name);
++#endif
++			//_dl_exit(1);
++			return -1;
++	};
++
++	/* instructions were modified */
++	PPC_DCBST(reloc_addr);
++	PPC_DCBST(reloc_addr+4);
++	PPC_SYNC;
++	PPC_ICBI(reloc_addr);
++	PPC_ICBI(reloc_addr+4);
++	PPC_ISYNC;
++
++#if defined (__SUPPORT_LD_DEBUG__)
++	if(_dl_debug_reloc && _dl_debug_detail)
++		_dl_dprintf(_dl_debug_file, "\tpatched: %x ==> %x", old_val, reloc_addr);
++#endif
++	return 0;
++
++}
++
++static int
++_dl_do_reloc (struct elf_resolve *tpnt,struct dyn_elf *scope,
++	      ELF_RELOC *rpnt, Elf32_Sym *symtab, char *strtab)
++{
++	int reloc_type;
++	int symtab_index;
++	char *symname;
++	unsigned long *reloc_addr;
++	unsigned long symbol_addr;
++#if defined (__SUPPORT_LD_DEBUG__)
++	unsigned long old_val;
++#endif
++
++	reloc_addr   = (unsigned long *)(intptr_t) (tpnt->loadaddr + (unsigned long) rpnt->r_offset);
++	reloc_type   = ELF32_R_TYPE(rpnt->r_info);
++	symtab_index = ELF32_R_SYM(rpnt->r_info);
++	symbol_addr  = 0;
++	symname      = strtab + symtab[symtab_index].st_name;
++
++	if (symtab_index) {
++
++		symbol_addr = (unsigned long) _dl_find_hash(symname, scope, 
++				(reloc_type == R_PPC_JMP_SLOT ? tpnt : NULL), symbolrel);
++
++		/*
++		 * We want to allow undefined references to weak symbols - this might
++		 * have been intentional.  We should not be linking local symbols
++		 * here, so all bases should be covered.
++		 */
++
++		if (!symbol_addr && ELF32_ST_BIND(symtab[symtab_index].st_info) == STB_GLOBAL) {
++#if defined (__SUPPORT_LD_DEBUG__)
++			_dl_dprintf(2, "\tglobal symbol '%s' already defined in '%s'\n",
++					symname, tpnt->libname);
++#endif
++			return 0;
++		}
++	}
++
++#if defined (__SUPPORT_LD_DEBUG__)
++	old_val = *reloc_addr;
++#endif
++		switch (reloc_type) {
++			case R_PPC_NONE:
++				return 0;
++				break;
++			case R_PPC_REL24:
++#if 0
++				{
++					unsigned long delta = symbol_addr - (unsigned long)reloc_addr;
++					if(delta<<6>>6 != delta){
++						_dl_dprintf(2,"R_PPC_REL24: Reloc out of range\n");
++						_dl_exit(1);
++					}
++					*reloc_addr &= 0xfc000003;
++					*reloc_addr |= delta&0x03fffffc;
++				}
++				break;
++#else
++				_dl_dprintf(2, "%s: symbol '%s' is type R_PPC_REL24\n\tCompile shared libraries with -fPIC!\n",
++						_dl_progname, symname);
++				_dl_exit(1);
++#endif
++			case R_PPC_RELATIVE:
++				*reloc_addr = (unsigned long)tpnt->loadaddr + (unsigned long)rpnt->r_addend;
++				break;
++			case R_PPC_ADDR32:
++				*reloc_addr += symbol_addr;
++				break;
++			case R_PPC_ADDR16_HA:
++				/* XXX is this correct? */
++				*(short *)reloc_addr += (symbol_addr+0x8000)>>16;
++				break;
++			case R_PPC_ADDR16_HI:
++				*(short *)reloc_addr += symbol_addr>>16;
++				break;
++			case R_PPC_ADDR16_LO:
++				*(short *)reloc_addr += symbol_addr;
++				break;
++			case R_PPC_JMP_SLOT:
++				{
++					unsigned long targ_addr = (unsigned long)*reloc_addr;
++					unsigned long delta = targ_addr - (unsigned long)reloc_addr;
++					if(delta<<6>>6 == delta){
++						*reloc_addr = OPCODE_B(delta);
++					}else if (targ_addr <= 0x01fffffc || targ_addr >= 0xfe000000){
++						*reloc_addr = OPCODE_BA (targ_addr);
++					}else{
++						{
++							int index;
++							unsigned long delta2;
++							unsigned long *plt, *ptr;
++							plt = (unsigned long *)(tpnt->dynamic_info[DT_PLTGOT] + tpnt->loadaddr);
++
++							delta2 = (unsigned long)(plt+PLT_LONGBRANCH_ENTRY_WORDS)
++								- (unsigned long)(reloc_addr+1);
++
++							index = ((unsigned long)reloc_addr -
++									(unsigned long)(plt+PLT_INITIAL_ENTRY_WORDS))
++								/sizeof(unsigned long);
++							index /= 2;
++							//DPRINTF("        index %x delta %x\n",index,delta2);
++							ptr = (unsigned long *)tpnt->data_words;
++							ptr[index] = targ_addr;
++							reloc_addr[0] = OPCODE_LI(11,index*4);
++							reloc_addr[1] = OPCODE_B(delta2);
++
++							/* instructions were modified */
++							PPC_DCBST(reloc_addr+1);
++							PPC_SYNC;
++							PPC_ICBI(reloc_addr+1);
++						}
++					}
++					break;
++				}
++			case R_PPC_GLOB_DAT:
++				*reloc_addr += symbol_addr;
++				break;
++			case R_PPC_COPY:
++				// handled later
++				return 0;
++				break;
++			default:
++#if 0
++				_dl_dprintf(2, "%s: can't handle reloc type ", _dl_progname);
++#if defined (__SUPPORT_LD_DEBUG__)
++				_dl_dprintf(2, "%s ", _dl_reltypes[reloc_type]);
++#endif
++				if (symtab_index)
++					_dl_dprintf(2, "'%s'\n", strtab + symtab[symtab_index].st_name);
++#endif
++				//_dl_exit(1);
++				return -1;
++		};
++
++		/* instructions were modified */
++		PPC_DCBST(reloc_addr);
++		PPC_SYNC;
++		PPC_ICBI(reloc_addr);
++		PPC_ISYNC;
++
++#if defined (__SUPPORT_LD_DEBUG__)
++	if(_dl_debug_reloc && _dl_debug_detail)
++		_dl_dprintf(_dl_debug_file, "\tpatched: %x ==> %x @ %x", old_val, *reloc_addr, reloc_addr);
++#endif
++
++	return 0;
++}
++
++
++/* This is done as a separate step, because there are cases where
++   information is first copied and later initialized.  This results in
++   the wrong information being copied.  Someone at Sun was complaining about
++   a bug in the handling of _COPY by SVr4, and this may in fact be what he
++   was talking about.  Sigh. */
++static int
++_dl_do_copy (struct elf_resolve *tpnt, struct dyn_elf *scope,
++	     ELF_RELOC *rpnt, Elf32_Sym *symtab, char *strtab)
++{
++	int reloc_type;
++	int symtab_index;
++	unsigned long *reloc_addr;
++	unsigned long symbol_addr;
++	int goof = 0;
++	char *symname;
++	  
++	reloc_addr = (unsigned long *)(intptr_t) (tpnt->loadaddr + (unsigned long) rpnt->r_offset);
++	reloc_type = ELF32_R_TYPE(rpnt->r_info);
++	if (reloc_type != R_PPC_COPY) 
++		return 0;
++	symtab_index = ELF32_R_SYM(rpnt->r_info);
++	symbol_addr = 0;
++	symname      = strtab + symtab[symtab_index].st_name;
++		
++	if (symtab_index) {
++		symbol_addr = (unsigned long) _dl_find_hash(symname, scope, NULL, copyrel);
++		if (!symbol_addr) goof++;
++	}
++	if (!goof) {
++#if defined (__SUPPORT_LD_DEBUG__)
++	        if(_dl_debug_move)
++		  _dl_dprintf(_dl_debug_file,"\n%s move %x bytes from %x to %x",
++			     symname, symtab[symtab_index].st_size,
++			     symbol_addr, symtab[symtab_index].st_value);
++#endif
++			_dl_memcpy((char *) reloc_addr,
++					(char *) symbol_addr, symtab[symtab_index].st_size);
++	}
++
++	return goof;
++}
++
++void _dl_parse_lazy_relocation_information(struct elf_resolve *tpnt, 
++	unsigned long rel_addr, unsigned long rel_size, int type)
++{
++	(void) type;
++	(void)_dl_parse(tpnt, NULL, rel_addr, rel_size, _dl_do_lazy_reloc);
++}
++
++int _dl_parse_relocation_information(struct elf_resolve *tpnt, 
++	unsigned long rel_addr, unsigned long rel_size, int type)
++{
++	(void) type;
++	return _dl_parse(tpnt, tpnt->symbol_scope, rel_addr, rel_size, _dl_do_reloc);
++}
++
++int _dl_parse_copy_information(struct dyn_elf *xpnt, unsigned long rel_addr, 
++	unsigned long rel_size, int type)
++{
++	(void) type;
++	return _dl_parse(xpnt->dyn, xpnt->next, rel_addr, rel_size, _dl_do_copy);
++}
++
++
+diff -urN uClibc/ldso-0.9.24/ldso/powerpc/ld_syscalls.h uClibc.ldso.24/ldso-0.9.24/ldso/powerpc/ld_syscalls.h
+--- uClibc/ldso-0.9.24/ldso/powerpc/ld_syscalls.h	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/powerpc/ld_syscalls.h	2003-06-14 20:08:43.000000000 -0500
+@@ -0,0 +1,244 @@
++/*
++ * This file contains the system call macros and syscall 
++ * numbers used by the shared library loader.
++ */
++
++#define __NR_exit		  1
++#define __NR_read		  3
++#define __NR_write		  4
++#define __NR_open		  5
++#define __NR_close		  6
++#define __NR_getpid		 20
++#define __NR_getuid		 24
++#define __NR_geteuid		 49
++#define __NR_getgid		 47
++#define __NR_getegid		 50
++#define __NR_readlink		 85
++#define __NR_mmap		 90
++#define __NR_munmap		 91
++#define __NR_stat		106
++#define __NR_mprotect		125
++
++/* Here are the macros which define how this platform makes
++ * system calls.  This particular variant does _not_ set 
++ * errno (note how it is disabled in __syscall_return) since
++ * these will get called before the errno symbol is dynamicly 
++ * linked. */
++
++#undef __syscall_return
++#define __syscall_return(type) \
++	return (__sc_err & 0x10000000 ? /*errno = __sc_ret,*/ __sc_ret = -1 : 0), \
++	       (type) __sc_ret
++
++#undef __syscall_clobbers
++#define __syscall_clobbers \
++	"r9", "r10", "r11", "r12"
++	//"r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12"
++
++#undef _syscall0
++#define _syscall0(type,name)						\
++type name(void)								\
++{									\
++	unsigned long __sc_ret, __sc_err;				\
++	{								\
++		register unsigned long __sc_0 __asm__ ("r0");		\
++		register unsigned long __sc_3 __asm__ ("r3");		\
++									\
++		__sc_0 = __NR_##name;					\
++		__asm__ __volatile__					\
++			("sc           \n\t"				\
++			 "mfcr %1      "				\
++			: "=&r" (__sc_3), "=&r" (__sc_0)		\
++			: "0"   (__sc_3), "1"   (__sc_0)		\
++			: "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12" ); \
++		__sc_ret = __sc_3;					\
++		__sc_err = __sc_0;					\
++	}								\
++	__syscall_return (type);					\
++}
++
++#undef _syscall1
++#define _syscall1(type,name,type1,arg1)					\
++type name(type1 arg1)							\
++{									\
++	unsigned long __sc_ret, __sc_err;				\
++	{								\
++		register unsigned long __sc_0 __asm__ ("r0");		\
++		register unsigned long __sc_3 __asm__ ("r3");		\
++									\
++		__sc_3 = (unsigned long) (arg1);			\
++		__sc_0 = __NR_##name;					\
++		__asm__ __volatile__					\
++			("sc           \n\t"				\
++			 "mfcr %1      "				\
++			: "=&r" (__sc_3), "=&r" (__sc_0)		\
++			: "0"   (__sc_3), "1"   (__sc_0)		\
++			: "r4", "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12" ); \
++		__sc_ret = __sc_3;					\
++		__sc_err = __sc_0;					\
++	}								\
++	__syscall_return (type);					\
++}
++
++#undef _syscall2
++#define _syscall2(type,name,type1,arg1,type2,arg2)			\
++type name(type1 arg1, type2 arg2)					\
++{									\
++	unsigned long __sc_ret, __sc_err;				\
++	{								\
++		register unsigned long __sc_0 __asm__ ("r0");		\
++		register unsigned long __sc_3 __asm__ ("r3");		\
++		register unsigned long __sc_4 __asm__ ("r4");		\
++									\
++		__sc_3 = (unsigned long) (arg1);			\
++		__sc_4 = (unsigned long) (arg2);			\
++		__sc_0 = __NR_##name;					\
++		__asm__ __volatile__					\
++			("sc           \n\t"				\
++			 "mfcr %1      "				\
++			: "=&r" (__sc_3), "=&r" (__sc_0)		\
++			: "0"   (__sc_3), "1"   (__sc_0),		\
++			  "r"   (__sc_4)				\
++			: "r5", "r6", "r7", "r8", "r9", "r10", "r11", "r12" ); \
++		__sc_ret = __sc_3;					\
++		__sc_err = __sc_0;					\
++	}								\
++	__syscall_return (type);					\
++}
++
++#undef _syscall3
++#define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3)		\
++type name(type1 arg1, type2 arg2, type3 arg3)				\
++{									\
++	unsigned long __sc_ret, __sc_err;				\
++	{								\
++		register unsigned long __sc_0 __asm__ ("r0");		\
++		register unsigned long __sc_3 __asm__ ("r3");		\
++		register unsigned long __sc_4 __asm__ ("r4");		\
++		register unsigned long __sc_5 __asm__ ("r5");		\
++									\
++		__sc_3 = (unsigned long) (arg1);			\
++		__sc_4 = (unsigned long) (arg2);			\
++		__sc_5 = (unsigned long) (arg3);			\
++		__sc_0 = __NR_##name;					\
++		__asm__ __volatile__					\
++			("sc           \n\t"				\
++			 "mfcr %1      "				\
++			: "=&r" (__sc_3), "=&r" (__sc_0)		\
++			: "0"   (__sc_3), "1"   (__sc_0),		\
++			  "r"   (__sc_4),				\
++			  "r"   (__sc_5)				\
++			: "r6", "r7", "r8", "r9", "r10", "r11", "r12" ); \
++		__sc_ret = __sc_3;					\
++		__sc_err = __sc_0;					\
++	}								\
++	__syscall_return (type);					\
++}
++
++#undef _syscall4
++#define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \
++type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4)		\
++{									\
++	unsigned long __sc_ret, __sc_err;				\
++	{								\
++		register unsigned long __sc_0 __asm__ ("r0");		\
++		register unsigned long __sc_3 __asm__ ("r3");		\
++		register unsigned long __sc_4 __asm__ ("r4");		\
++		register unsigned long __sc_5 __asm__ ("r5");		\
++		register unsigned long __sc_6 __asm__ ("r6");		\
++									\
++		__sc_3 = (unsigned long) (arg1);			\
++		__sc_4 = (unsigned long) (arg2);			\
++		__sc_5 = (unsigned long) (arg3);			\
++		__sc_6 = (unsigned long) (arg4);			\
++		__sc_0 = __NR_##name;					\
++		__asm__ __volatile__					\
++			("sc           \n\t"				\
++			 "mfcr %1      "				\
++			: "=&r" (__sc_3), "=&r" (__sc_0)		\
++			: "0"   (__sc_3), "1"   (__sc_0),		\
++			  "r"   (__sc_4),				\
++			  "r"   (__sc_5),				\
++			  "r"   (__sc_6)				\
++			: "r7", "r8", "r9", "r10", "r11", "r12" );	\
++		__sc_ret = __sc_3;					\
++		__sc_err = __sc_0;					\
++	}								\
++	__syscall_return (type);					\
++}
++
++#undef _syscall5
++#define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4,type5,arg5) \
++type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, type5 arg5)	\
++{									\
++	unsigned long __sc_ret, __sc_err;				\
++	{								\
++		register unsigned long __sc_0 __asm__ ("r0");		\
++		register unsigned long __sc_3 __asm__ ("r3");		\
++		register unsigned long __sc_4 __asm__ ("r4");		\
++		register unsigned long __sc_5 __asm__ ("r5");		\
++		register unsigned long __sc_6 __asm__ ("r6");		\
++		register unsigned long __sc_7 __asm__ ("r7");		\
++									\
++		__sc_3 = (unsigned long) (arg1);			\
++		__sc_4 = (unsigned long) (arg2);			\
++		__sc_5 = (unsigned long) (arg3);			\
++		__sc_6 = (unsigned long) (arg4);			\
++		__sc_7 = (unsigned long) (arg5);			\
++		__sc_0 = __NR_##name;					\
++		__asm__ __volatile__					\
++			("sc           \n\t"				\
++			 "mfcr %1      "				\
++			: "=&r" (__sc_3), "=&r" (__sc_0)		\
++			: "0"   (__sc_3), "1"   (__sc_0),		\
++			  "r"   (__sc_4),				\
++			  "r"   (__sc_5),				\
++			  "r"   (__sc_6),				\
++			  "r"   (__sc_7)				\
++			: "r8", "r9", "r10", "r11", "r12" );		\
++		__sc_ret = __sc_3;					\
++		__sc_err = __sc_0;					\
++	}								\
++	__syscall_return (type);					\
++}
++
++
++#undef _syscall6
++#define _syscall6(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4,type5,arg5,type6,arg6) \
++type name(type1 arg1, type2 arg2, type3 arg3, type4 arg4, type5 arg5, type6 arg6)	\
++{									\
++	unsigned long __sc_ret, __sc_err;				\
++	{								\
++		register unsigned long __sc_0 __asm__ ("r0");		\
++		register unsigned long __sc_3 __asm__ ("r3");		\
++		register unsigned long __sc_4 __asm__ ("r4");		\
++		register unsigned long __sc_5 __asm__ ("r5");		\
++		register unsigned long __sc_6 __asm__ ("r6");		\
++		register unsigned long __sc_7 __asm__ ("r7");		\
++		register unsigned long __sc_8 __asm__ ("r8");		\
++									\
++		__sc_3 = (unsigned long) (arg1);			\
++		__sc_4 = (unsigned long) (arg2);			\
++		__sc_5 = (unsigned long) (arg3);			\
++		__sc_6 = (unsigned long) (arg4);			\
++		__sc_7 = (unsigned long) (arg5);			\
++		__sc_8 = (unsigned long) (arg6);			\
++		__sc_0 = __NR_##name;					\
++		__asm__ __volatile__					\
++			("sc           \n\t"				\
++			 "mfcr %1      "				\
++			: "=&r" (__sc_3), "=&r" (__sc_0)		\
++			: "0"   (__sc_3), "1"   (__sc_0),		\
++			  "r"   (__sc_4),				\
++			  "r"   (__sc_5),				\
++			  "r"   (__sc_6),				\
++			  "r"   (__sc_7),				\
++			  "r"   (__sc_8)				\
++			: "r9", "r10", "r11", "r12" );			\
++		__sc_ret = __sc_3;					\
++		__sc_err = __sc_0;					\
++	}								\
++	__syscall_return (type);					\
++}
++
++
+diff -urN uClibc/ldso-0.9.24/ldso/powerpc/ld_sysdep.h uClibc.ldso.24/ldso-0.9.24/ldso/powerpc/ld_sysdep.h
+--- uClibc/ldso-0.9.24/ldso/powerpc/ld_sysdep.h	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/powerpc/ld_sysdep.h	2003-12-03 17:38:43.000000000 -0600
+@@ -0,0 +1,136 @@
++/*
++ * Various assmbly language/system dependent  hacks that are required
++ * so that we can minimize the amount of platform specific code.
++ */
++
++/*
++ * Define this if the system uses RELOCA.
++ */
++#define ELF_USES_RELOCA
++
++/*
++ * Get a pointer to the argv array.  On many platforms this can be just
++ * the address if the first argument, on other platforms we need to
++ * do something a little more subtle here.
++ */
++#define GET_ARGV(ARGVP, ARGS) ARGVP = (((unsigned long*) ARGS)+1)
++
++/*
++ * Initialization sequence for a GOT.
++ */
++#define INIT_GOT(GOT_BASE,MODULE)  _dl_init_got(GOT_BASE,MODULE)
++
++/* Stuff for the PLT.  */
++#define PLT_INITIAL_ENTRY_WORDS 18
++#define PLT_LONGBRANCH_ENTRY_WORDS 0
++#define PLT_TRAMPOLINE_ENTRY_WORDS 6
++#define PLT_DOUBLE_SIZE (1<<13)
++#define PLT_ENTRY_START_WORDS(entry_number) \
++  (PLT_INITIAL_ENTRY_WORDS + (entry_number)*2				\
++   + ((entry_number) > PLT_DOUBLE_SIZE					\
++      ? ((entry_number) - PLT_DOUBLE_SIZE)*2				\
++      : 0))
++#define PLT_DATA_START_WORDS(num_entries) PLT_ENTRY_START_WORDS(num_entries)
++
++/* Macros to build PowerPC opcode words.  */
++#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_LWZU(rd,d,ra) \
++  (0x84000000 | (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_ADDIS_HI(rd,ra,value) \
++  OPCODE_ADDIS(rd,ra,((value) + 0x8000) >> 16)
++#define OPCODE_LIS_HI(rd,value) OPCODE_ADDIS_HI(rd,0,value)
++#define OPCODE_SLWI(ra,rs,sh) OPCODE_RLWINM(ra,rs,sh,0,31-sh)
++
++
++#define PPC_DCBST(where) asm volatile ("dcbst 0,%0" : : "r"(where) : "memory")
++#define PPC_SYNC asm volatile ("sync" : : : "memory")
++#define PPC_ISYNC asm volatile ("sync; isync" : : : "memory")
++#define PPC_ICBI(where) asm volatile ("icbi 0,%0" : : "r"(where) : "memory")
++#define PPC_DIE asm volatile ("tweq 0,0")
++
++/*
++ * Here is a macro to perform a relocation.  This is only used when
++ * bootstrapping the dynamic loader.  RELP is the relocation that we
++ * are performing, REL is the pointer to the address we are relocating.
++ * SYMBOL is the symbol involved in the relocation, and LOAD is the
++ * load address.
++ */
++// finaladdr = LOAD ?
++#define PERFORM_BOOTSTRAP_RELOC(RELP,REL,SYMBOL,LOAD) \
++	{int type=ELF32_R_TYPE((RELP)->r_info);		\
++	if(type==R_PPC_NONE){				\
++	}else if(type==R_PPC_ADDR32){			\
++		*REL += (SYMBOL);			\
++	}else if(type==R_PPC_RELATIVE){			\
++		*REL = (Elf32_Word)(LOAD) + (RELP)->r_addend;		\
++	}else if(type==R_PPC_REL24){			\
++		Elf32_Sword delta = (Elf32_Word)(SYMBOL) - (Elf32_Word)(REL);	\
++		*REL &= 0xfc000003;			\
++		*REL |= (delta & 0x03fffffc);		\
++	}else if(type==R_PPC_JMP_SLOT){			\
++		Elf32_Sword delta = (Elf32_Word)(SYMBOL) - (Elf32_Word)(REL);	\
++		/*if (delta << 6 >> 6 != delta)_dl_exit(99);*/	\
++		*REL = OPCODE_B(delta);			\
++	}else{						\
++	  _dl_exit(100+ELF32_R_TYPE((RELP)->r_info));	\
++	}						\
++	if(type!=R_PPC_NONE){				\
++		PPC_DCBST(REL); PPC_SYNC; PPC_ICBI(REL);\
++	}						\
++	}
++
++/*
++ * Transfer control to the user's application, once the dynamic loader
++ * is done.  This routine has to exit the current function, then 
++ * call the _dl_elf_main function.
++ */
++
++/* hgb@ifi.uio.no:
++ * Adding a clobber list consisting of r0 for %1.  addi on PowerPC
++ * takes a register as the second argument, but if the register is
++ * r0, the value 0 is used instead.  If r0 is used here, the stack
++ * pointer (r1) will be zeroed, and the dynamically linked
++ * application will seg.fault immediatly when receiving control.
++ */
++#define START()		\
++	__asm__ volatile ( \
++		    "addi 1,%1,0\n\t" \
++		    "mtlr %0\n\t" \
++		    "blrl\n\t"	\
++		    : : "r" (_dl_elf_main), "r" (args) \
++		    : "r0")
++
++
++/* Here we define the magic numbers that this dynamic loader should accept */
++
++#define MAGIC1 EM_PPC
++#undef  MAGIC2
++/* Used for error messages */
++#define ELF_TARGET "powerpc"
++
++struct elf_resolve;
++extern unsigned long _dl_linux_resolver(struct elf_resolve * tpnt, int reloc_entry);
++void _dl_init_got(unsigned long *lpnt,struct elf_resolve *tpnt);
++
++
++#define do_rem(result, n, base)  result = (n % base)
++
++/* 4096 bytes alignment */
++#define PAGE_ALIGN 0xfffff000
++#define ADDR_ALIGN 0xfff
++#define OFFS_ALIGN 0x7ffff000
+diff -urN uClibc/ldso-0.9.24/ldso/powerpc/resolve.S uClibc.ldso.24/ldso-0.9.24/ldso/powerpc/resolve.S
+--- uClibc/ldso-0.9.24/ldso/powerpc/resolve.S	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/powerpc/resolve.S	2001-07-12 05:14:09.000000000 -0500
+@@ -0,0 +1,82 @@
++/*
++ * Stolen from glibc-2.2.2 by David Schleef <ds@schleef.org>
++ */
++
++.text
++.align 4
++
++.globl _dl_linux_resolver
++
++.globl _dl_linux_resolve
++.type	_dl_linux_resolve,@function
++
++_dl_linux_resolve:
++// We need to save the registers used to pass parameters, and register 0,
++// which is used by _mcount; the registers are saved in a stack frame.
++	stwu 1,-64(1)
++	stw 0,12(1)
++	stw 3,16(1)
++	stw 4,20(1)
++// The code that calls this has put parameters for 'fixup' in r12 and r11.
++	mr 3,12
++	stw 5,24(1)
++	mr 4,11
++	stw 6,28(1)
++	mflr 0
++// We also need to save some of the condition register fields.
++	stw 7,32(1)
++	stw 0,48(1)
++	stw 8,36(1)
++	mfcr 0
++	stw 9,40(1)
++	stw 10,44(1)
++	stw 0,8(1)
++	bl _dl_linux_resolver@local
++// 'fixup' returns the address we want to branch to.
++	mtctr 3
++// Put the registers back...
++	lwz 0,48(1)
++	lwz 10,44(1)
++	lwz 9,40(1)
++	mtlr 0
++	lwz 8,36(1)
++	lwz 0,8(1)
++	lwz 7,32(1)
++	lwz 6,28(1)
++	mtcrf 0xFF,0
++	lwz 5,24(1)
++	lwz 4,20(1)
++	lwz 3,16(1)
++	lwz 0,12(1)
++// ...unwind the stack frame, and jump to the PLT entry we updated.
++	addi 1,1,64
++	bctr
++
++.LFE2:
++	.size _dl_linux_resolve,.LFE2-_dl_linux_resolve
++
++#if 0
++
++	pusha				/* preserve all regs */
++	lea	0x20(%esp),%eax		/* eax = tpnt and reloc_entry params */
++	pushl	4(%eax)			/* push copy of reloc_entry param */
++	pushl	(%eax)			/* push copy of tpnt param */
++					 
++#ifdef __PIC__
++	call	.L24
++.L24:
++	popl	%ebx
++	addl	$_GLOBAL_OFFSET_TABLE_+[.-.L24],%ebx
++	movl _dl_linux_resolver@GOT(%ebx),%ebx	/* eax = resolved func */
++	call *%ebx
++#else
++	call _dl_linux_resolver
++#endif
++	movl	%eax,0x28(%esp)		/* store func addr over original
++					 * tpnt param */
++	addl	$0x8,%esp		/* remove copy parameters */
++	popa				/* restore regs */
++	ret	$4			/* jump to func removing original
++					 * reloc_entry param from stack */
++#endif
++
+diff -urN uClibc/ldso-0.9.24/ldso/readelflib1.c uClibc.ldso.24/ldso-0.9.24/ldso/readelflib1.c
+--- uClibc/ldso-0.9.24/ldso/readelflib1.c	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/readelflib1.c	2003-12-05 14:24:26.000000000 -0600
+@@ -0,0 +1,971 @@
++/* vi: set sw=4 ts=4: */
++/* Program to load an ELF binary on a linux system, and run it
++ * after resolving ELF shared library symbols
++ *
++ * Copyright (c) 1994-2000 Eric Youngdale, Peter MacDonald, 
++ *				David Engel, Hongjiu Lu and Mitch D'Souza
++ * Copyright (C) 2001-2003, Erik Andersen
++ *
++ * All rights reserved.
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions
++ * are met:
++ * 1. Redistributions of source code must retain the above copyright
++ *    notice, this list of conditions and the following disclaimer.
++ * 2. The name of the above contributors may not be
++ *    used to endorse or promote products derived from this software
++ *    without specific prior written permission.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND
++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ * ARE DISCLAIMED.  IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE
++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
++ * SUCH DAMAGE.
++ */
++
++
++/* This file contains the helper routines to load an ELF sharable
++   library into memory and add the symbol table info to the chain. */
++
++#ifdef USE_CACHE
++
++static caddr_t _dl_cache_addr = NULL;
++static size_t _dl_cache_size = 0;
++
++int _dl_map_cache(void)
++{
++	int fd;
++	struct stat st;
++	header_t *header;
++	libentry_t *libent;
++	int i, strtabsize;
++
++	if (_dl_cache_addr == (caddr_t) - 1)
++		return -1;
++	else if (_dl_cache_addr != NULL)
++		return 0;
++
++	if (_dl_stat(LDSO_CACHE, &st)
++		|| (fd = _dl_open(LDSO_CACHE, O_RDONLY)) < 0) {
++		_dl_dprintf(2, "%s: can't open cache '%s'\n", _dl_progname, LDSO_CACHE);
++		_dl_cache_addr = (caddr_t) - 1;	/* so we won't try again */
++		return -1;
++	}
++
++	_dl_cache_size = st.st_size;
++	_dl_cache_addr = (caddr_t) _dl_mmap(0, _dl_cache_size, PROT_READ, MAP_SHARED, fd, 0);
++	_dl_close(fd);
++	if (_dl_mmap_check_error(_dl_cache_addr)) {
++		_dl_dprintf(2, "%s: can't map cache '%s'\n", 
++			_dl_progname, LDSO_CACHE);
++		return -1;
++	}
++
++	header = (header_t *) _dl_cache_addr;
++
++	if (_dl_cache_size < sizeof(header_t) ||
++		_dl_memcmp(header->magic, LDSO_CACHE_MAGIC, LDSO_CACHE_MAGIC_LEN)
++		|| _dl_memcmp(header->version, LDSO_CACHE_VER, LDSO_CACHE_VER_LEN)
++		|| _dl_cache_size <
++		(sizeof(header_t) + header->nlibs * sizeof(libentry_t))
++		|| _dl_cache_addr[_dl_cache_size - 1] != '\0') 
++	{
++		_dl_dprintf(2, "%s: cache '%s' is corrupt\n", _dl_progname, 
++			LDSO_CACHE);
++		goto fail;
++	}
++
++	strtabsize = _dl_cache_size - sizeof(header_t) -
++		header->nlibs * sizeof(libentry_t);
++	libent = (libentry_t *) & header[1];
++
++	for (i = 0; i < header->nlibs; i++) {
++		if (libent[i].sooffset >= strtabsize || 
++			libent[i].liboffset >= strtabsize) 
++		{
++			_dl_dprintf(2, "%s: cache '%s' is corrupt\n", _dl_progname, LDSO_CACHE);
++			goto fail;
++		}
++	}
++
++	return 0;
++
++  fail:
++	_dl_munmap(_dl_cache_addr, _dl_cache_size);
++	_dl_cache_addr = (caddr_t) - 1;
++	return -1;
++}
++
++int _dl_unmap_cache(void)
++{
++	if (_dl_cache_addr == NULL || _dl_cache_addr == (caddr_t) - 1)
++		return -1;
++
++#if 1
++	_dl_munmap(_dl_cache_addr, _dl_cache_size);
++	_dl_cache_addr = NULL;
++#endif
++
++	return 0;
++}
++
++#endif
++
++/* This function's behavior must exactly match that 
++ * in uClibc/ldso/util/ldd.c */
++static struct elf_resolve * 
++search_for_named_library(const char *name, int secure, const char *path_list,
++	struct dyn_elf **rpnt)
++{
++	int i, count = 1;
++	char *path, *path_n;
++	char mylibname[2050];
++	struct elf_resolve *tpnt1;
++	
++	if (path_list==NULL)
++		return NULL;
++
++	/* We need a writable copy of this string */
++	path = _dl_strdup(path_list);
++	if (!path) {
++		_dl_dprintf(2, "Out of memory!\n");
++		_dl_exit(0);
++	}
++	
++
++	/* Unlike ldd.c, don't bother to eliminate double //s */
++
++
++	/* Replace colons with zeros in path_list and count them */
++	for(i=_dl_strlen(path); i > 0; i--) {
++		if (path[i]==':') {
++			path[i]=0;
++			count++;
++		}
++	}
++
++	path_n = path;
++	for (i = 0; i < count; i++) {
++		_dl_strcpy(mylibname, path_n); 
++		_dl_strcat(mylibname, "/"); 
++		_dl_strcat(mylibname, name);
++		if ((tpnt1 = _dl_load_elf_shared_library(secure, rpnt, mylibname)) != NULL)
++		{
++			return tpnt1;
++		}
++		path_n += (_dl_strlen(path_n) + 1);
++	}
++	return NULL;
++}
++
++/* Check if the named library is already loaded... */
++struct elf_resolve *_dl_check_if_named_library_is_loaded(const char *full_libname)
++{
++	const char *pnt, *pnt1;
++	struct elf_resolve *tpnt1;
++	const char *libname, *libname2;
++	static const char *libc = "libc.so.";
++	static const char *aborted_wrong_lib = "%s: aborted attempt to load %s!\n";
++
++	pnt = libname = full_libname;
++
++#if defined (__SUPPORT_LD_DEBUG__)
++	if(_dl_debug) 
++		_dl_dprintf(_dl_debug_file, "Checking if '%s' is already loaded\n", full_libname);
++#endif
++	/* quick hack to ensure mylibname buffer doesn't overflow.  don't 
++	   allow full_libname or any directory to be longer than 1024. */
++	if (_dl_strlen(full_libname) > 1024)
++		return NULL;
++
++	/* Skip over any initial initial './' and '/' stuff to 
++	 * get the short form libname with no path garbage */ 
++	pnt1 = _dl_strrchr(pnt, '/');
++	if (pnt1) {
++		libname = pnt1 + 1;
++	}
++
++	/* Make sure they are not trying to load the wrong C library!
++	 * This sometimes happens esp with shared libraries when the
++	 * library path is somehow wrong! */
++#define isdigit(c)  (c >= '0' && c <= '9')
++	if ((_dl_strncmp(libname, libc, 8) == 0) &&  _dl_strlen(libname) >=8 &&
++			isdigit(libname[8]))
++	{
++		/* Abort attempts to load glibc, libc5, etc */
++		if ( libname[8]!='0') {
++			if (!_dl_trace_loaded_objects) {
++				_dl_dprintf(2, aborted_wrong_lib, libname, _dl_progname);
++				_dl_exit(1);
++			}
++			return NULL;
++		}
++	}
++
++	/* Critical step!  Weed out duplicates early to avoid
++	 * function aliasing, which wastes memory, and causes
++	 * really bad things to happen with weaks and globals. */
++	for (tpnt1 = _dl_loaded_modules; tpnt1; tpnt1 = tpnt1->next) {
++
++		/* Skip over any initial initial './' and '/' stuff to 
++		 * get the short form libname with no path garbage */ 
++		libname2 = tpnt1->libname;
++		pnt1 = _dl_strrchr(libname2, '/');
++		if (pnt1) {
++			libname2 = pnt1 + 1;
++		}
++
++		if (_dl_strcmp(libname2, libname) == 0) {
++			/* Well, that was certainly easy */
++			return tpnt1;
++		}
++	}
++
++	return NULL;
++}
++	
++
++
++/*
++ * Used to return error codes back to dlopen et. al.
++ */
++
++unsigned long _dl_error_number;
++unsigned long _dl_internal_error_number;
++extern char *_dl_ldsopath;
++
++struct elf_resolve *_dl_load_shared_library(int secure, struct dyn_elf **rpnt,
++	struct elf_resolve *tpnt, char *full_libname)
++{
++	char *pnt, *pnt1;
++	struct elf_resolve *tpnt1;
++	char *libname;
++
++	_dl_internal_error_number = 0;
++	libname = full_libname;
++
++	/* quick hack to ensure mylibname buffer doesn't overflow.  don't 
++	   allow full_libname or any directory to be longer than 1024. */
++	if (_dl_strlen(full_libname) > 1024)
++		goto goof;
++
++	/* Skip over any initial initial './' and '/' stuff to 
++	 * get the short form libname with no path garbage */ 
++	pnt1 = _dl_strrchr(libname, '/');
++	if (pnt1) {
++		libname = pnt1 + 1;
++	}
++
++	/* Critical step!  Weed out duplicates early to avoid
++	 * function aliasing, which wastes memory, and causes
++	 * really bad things to happen with weaks and globals. */
++	if ((tpnt1=_dl_check_if_named_library_is_loaded(libname))!=NULL)
++		return tpnt1;
++
++#if defined (__SUPPORT_LD_DEBUG__)
++	if(_dl_debug) _dl_dprintf(_dl_debug_file, "\tfind library='%s'; searching\n", libname);
++#endif
++	/* If the filename has any '/', try it straight and leave it at that.
++	   For IBCS2 compatibility under linux, we substitute the string 
++	   /usr/i486-sysv4/lib for /usr/lib in library names. */
++
++	if (libname != full_libname) {
++#if defined (__SUPPORT_LD_DEBUG__)
++		if(_dl_debug) _dl_dprintf(_dl_debug_file, "\ttrying file='%s'\n", full_libname);
++#endif
++		tpnt1 = _dl_load_elf_shared_library(secure, rpnt, full_libname);
++		if (tpnt1) {
++			return tpnt1;
++		}
++		//goto goof;
++	}
++
++	/*
++	 * The ABI specifies that RPATH is searched before LD_*_PATH or
++	 * the default path of /usr/lib.  Check in rpath directories.
++	 */
++	for (tpnt = _dl_loaded_modules; tpnt; tpnt = tpnt->next) {
++		if (tpnt->libtype == elf_executable) {
++			pnt = (char *) tpnt->dynamic_info[DT_RPATH];
++			if (pnt) {
++				pnt += (unsigned long) tpnt->loadaddr + tpnt->dynamic_info[DT_STRTAB];
++#if defined (__SUPPORT_LD_DEBUG__)
++				if(_dl_debug) _dl_dprintf(_dl_debug_file, "\tsearching RPATH='%s'\n", pnt);
++#endif
++				if ((tpnt1 = search_for_named_library(libname, secure, pnt, rpnt)) != NULL) 
++				{
++				    return tpnt1;
++				}
++			}
++		}
++	}
++
++	/* Check in LD_{ELF_}LIBRARY_PATH, if specified and allowed */
++	if (_dl_library_path) {
++#if defined (__SUPPORT_LD_DEBUG__)
++		if(_dl_debug) _dl_dprintf(_dl_debug_file, "\tsearching LD_LIBRARY_PATH='%s'\n", _dl_library_path);
++#endif
++	    if ((tpnt1 = search_for_named_library(libname, secure, _dl_library_path, rpnt)) != NULL) 
++	    {
++		return tpnt1;
++	    }
++	}
++
++	/*
++	 * Where should the cache be searched?  There is no such concept in the
++	 * ABI, so we have some flexibility here.  For now, search it before
++	 * the hard coded paths that follow (i.e before /lib and /usr/lib).
++	 */
++#ifdef USE_CACHE
++	if (_dl_cache_addr != NULL && _dl_cache_addr != (caddr_t) - 1) {
++		int i;
++		header_t *header = (header_t *) _dl_cache_addr;
++		libentry_t *libent = (libentry_t *) & header[1];
++		char *strs = (char *) &libent[header->nlibs];
++
++#if defined (__SUPPORT_LD_DEBUG__)
++		if(_dl_debug) _dl_dprintf(_dl_debug_file, "\tsearching cache='%s'\n", LDSO_CACHE);
++#endif
++		for (i = 0; i < header->nlibs; i++) {
++			if ((libent[i].flags == LIB_ELF ||
++				 libent[i].flags == LIB_ELF_LIBC5) &&
++				_dl_strcmp(libname, strs + libent[i].sooffset) == 0 &&
++				(tpnt1 = _dl_load_elf_shared_library(secure, 
++				     rpnt, strs + libent[i].liboffset)))
++				return tpnt1;
++		}
++	}
++#endif
++
++	/* Look for libraries wherever the shared library loader
++	 * was installed */
++#if defined (__SUPPORT_LD_DEBUG__)
++		if(_dl_debug) _dl_dprintf(_dl_debug_file, "\tsearching ldso dir='%s'\n", _dl_ldsopath);
++#endif
++	if ((tpnt1 = search_for_named_library(libname, secure, _dl_ldsopath, rpnt)) != NULL) 
++	{
++	    return tpnt1;
++	}
++
++
++	/* Lastly, search the standard list of paths for the library.
++	   This list must exactly match the list in uClibc/ldso/util/ldd.c */
++#if defined (__SUPPORT_LD_DEBUG__)
++	if(_dl_debug) _dl_dprintf(_dl_debug_file, "\tsearching full lib path list\n");
++#endif
++	if ((tpnt1 = search_for_named_library(libname, secure, 
++			UCLIBC_RUNTIME_PREFIX "usr/X11R6/lib:"
++			UCLIBC_RUNTIME_PREFIX "usr/lib:"
++			UCLIBC_RUNTIME_PREFIX "lib:"
++			"/usr/lib:"
++			"/lib", rpnt)
++		    ) != NULL) 
++	{
++	    return tpnt1;
++	}
++
++goof:
++	/* Well, we shot our wad on that one.  All we can do now is punt */
++	if (_dl_internal_error_number)
++		_dl_error_number = _dl_internal_error_number;
++	else
++		_dl_error_number = LD_ERROR_NOFILE;
++#if defined (__SUPPORT_LD_DEBUG__)
++	if(_dl_debug) _dl_dprintf(2, "Bummer: could not find '%s'!\n", libname);
++#endif
++	return NULL;
++}
++
++
++/*
++ * Read one ELF library into memory, mmap it into the correct locations and
++ * add the symbol info to the symbol chain.  Perform any relocations that
++ * are required.
++ */
++
++struct elf_resolve *_dl_load_elf_shared_library(int secure,
++	struct dyn_elf **rpnt, char *libname)
++{
++	ElfW(Ehdr) *epnt;
++	unsigned long dynamic_addr = 0;
++	unsigned long dynamic_size = 0;
++	Elf32_Dyn *dpnt;
++	struct elf_resolve *tpnt;
++	ElfW(Phdr) *ppnt;
++	char *status, *header;
++	unsigned long dynamic_info[24];
++	unsigned long *lpnt;
++	unsigned long libaddr;
++	unsigned long minvma = 0xffffffff, maxvma = 0;
++	int i, flags, piclib, infile;
++
++	/* If this file is already loaded, skip this step */
++	tpnt = _dl_check_hashed_files(libname);
++	if (tpnt) {
++		if (*rpnt) {
++			(*rpnt)->next = (struct dyn_elf *) _dl_malloc(sizeof(struct dyn_elf));
++			_dl_memset((*rpnt)->next, 0, sizeof(struct dyn_elf));
++			(*rpnt)->next->prev = (*rpnt);
++			*rpnt = (*rpnt)->next;
++			(*rpnt)->dyn = tpnt;
++			tpnt->symbol_scope = _dl_symbol_tables;
++		}
++		tpnt->usage_count++;
++		tpnt->libtype = elf_lib;
++#if defined (__SUPPORT_LD_DEBUG__)
++		if(_dl_debug) _dl_dprintf(2, "file='%s';  already loaded\n", libname);
++#endif
++		return tpnt;
++	}
++
++	/* If we are in secure mode (i.e. a setu/gid binary using LD_PRELOAD),
++	   we don't load the library if it isn't setuid. */
++
++	if (secure) {
++		struct stat st;
++
++		if (_dl_stat(libname, &st) || !(st.st_mode & S_ISUID))
++			return NULL;
++	}
++
++	libaddr = 0;
++	infile = _dl_open(libname, O_RDONLY);
++	if (infile < 0) {
++#if 0
++		/*
++		 * NO!  When we open shared libraries we may search several paths.
++		 * it is inappropriate to generate an error here.
++		 */
++		_dl_dprintf(2, "%s: can't open '%s'\n", _dl_progname, libname);
++#endif
++		_dl_internal_error_number = LD_ERROR_NOFILE;
++		return NULL;
++	}
++
++	 header = _dl_mmap((void *) 0, 4096, PROT_READ | PROT_WRITE,
++	 	MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
++	if (_dl_mmap_check_error(header)) {
++		_dl_dprintf(2, "%s: can't map '%s'\n", _dl_progname, libname);
++		_dl_internal_error_number = LD_ERROR_MMAP_FAILED;
++		_dl_close(infile);
++		return NULL;
++	};
++        
++	_dl_read(infile, header, 4096);
++	epnt = (ElfW(Ehdr) *) (intptr_t) header;
++	if (epnt->e_ident[0] != 0x7f ||
++		epnt->e_ident[1] != 'E' || 
++		epnt->e_ident[2] != 'L' || 
++		epnt->e_ident[3] != 'F') 
++	{
++		_dl_dprintf(2, "%s: '%s' is not an ELF file\n", _dl_progname,
++					 libname);
++		_dl_internal_error_number = LD_ERROR_NOTELF;
++		_dl_close(infile);
++		_dl_munmap(header, 4096);
++		return NULL;
++	};
++
++	if ((epnt->e_type != ET_DYN) || (epnt->e_machine != MAGIC1 
++#ifdef MAGIC2
++		    && epnt->e_machine != MAGIC2
++#endif
++		)) 
++	{
++		_dl_internal_error_number = 
++		    (epnt->e_type != ET_DYN ? LD_ERROR_NOTDYN : LD_ERROR_NOTMAGIC);
++		_dl_dprintf(2, "%s: '%s' is not an ELF executable for " ELF_TARGET 
++			"\n", _dl_progname, libname);
++		_dl_close(infile);
++		_dl_munmap(header, 4096);
++		return NULL;
++	};
++
++	ppnt = (ElfW(Phdr) *)(intptr_t) & header[epnt->e_phoff];
++
++	piclib = 1;
++	for (i = 0; i < epnt->e_phnum; i++) {
++
++		if (ppnt->p_type == PT_DYNAMIC) {
++			if (dynamic_addr)
++				_dl_dprintf(2, "%s: '%s' has more than one dynamic section\n", 
++					_dl_progname, libname);
++			dynamic_addr = ppnt->p_vaddr;
++			dynamic_size = ppnt->p_filesz;
++		};
++
++		if (ppnt->p_type == PT_LOAD) {
++			/* See if this is a PIC library. */
++			if (i == 0 && ppnt->p_vaddr > 0x1000000) {
++				piclib = 0;
++				minvma = ppnt->p_vaddr;
++			}
++			if (piclib && ppnt->p_vaddr < minvma) {
++				minvma = ppnt->p_vaddr;
++			}
++			if (((unsigned long) ppnt->p_vaddr + ppnt->p_memsz) > maxvma) {
++				maxvma = ppnt->p_vaddr + ppnt->p_memsz;
++			}
++		}
++		ppnt++;
++	};
++
++	maxvma = (maxvma + ADDR_ALIGN) & ~ADDR_ALIGN;
++	minvma = minvma & ~0xffffU;
++
++	flags = MAP_PRIVATE /*| MAP_DENYWRITE */ ;
++	if (!piclib)
++		flags |= MAP_FIXED;
++
++	status = (char *) _dl_mmap((char *) (piclib ? 0 : minvma), 
++		maxvma - minvma, PROT_NONE, flags | MAP_ANONYMOUS, -1, 0);
++	if (_dl_mmap_check_error(status)) {
++		_dl_dprintf(2, "%s: can't map %s\n", _dl_progname, libname);
++		_dl_internal_error_number = LD_ERROR_MMAP_FAILED;
++		_dl_close(infile);
++		_dl_munmap(header, 4096);
++		return NULL;
++	};
++	libaddr = (unsigned long) status;
++	flags |= MAP_FIXED;
++
++	/* Get the memory to store the library */
++	ppnt = (ElfW(Phdr) *)(intptr_t) & header[epnt->e_phoff];
++
++	for (i = 0; i < epnt->e_phnum; i++) {
++		if (ppnt->p_type == PT_LOAD) {
++
++			/* See if this is a PIC library. */
++			if (i == 0 && ppnt->p_vaddr > 0x1000000) {
++				piclib = 0;
++				/* flags |= MAP_FIXED; */
++			}
++
++
++
++			if (ppnt->p_flags & PF_W) {
++				unsigned long map_size;
++				char *cpnt;
++
++				status = (char *) _dl_mmap((char *) ((piclib ? libaddr : 0) + 
++					(ppnt->p_vaddr & PAGE_ALIGN)), (ppnt->p_vaddr & ADDR_ALIGN) 
++					+ ppnt->p_filesz, LXFLAGS(ppnt->p_flags), flags, infile, 
++					ppnt->p_offset & OFFS_ALIGN);
++
++				if (_dl_mmap_check_error(status)) {
++					_dl_dprintf(2, "%s: can't map '%s'\n", 
++						_dl_progname, libname);
++					_dl_internal_error_number = LD_ERROR_MMAP_FAILED;
++					_dl_munmap((char *) libaddr, maxvma - minvma);
++					_dl_close(infile);
++					_dl_munmap(header, 4096);
++					return NULL;
++				};
++
++				/* Pad the last page with zeroes. */
++				cpnt = (char *) (status + (ppnt->p_vaddr & ADDR_ALIGN) +
++							  ppnt->p_filesz);
++				while (((unsigned long) cpnt) & ADDR_ALIGN)
++					*cpnt++ = 0;
++
++				/* I am not quite sure if this is completely
++				 * correct to do or not, but the basic way that
++				 * we handle bss segments is that we mmap
++				 * /dev/zero if there are any pages left over
++				 * that are not mapped as part of the file */
++
++				map_size = (ppnt->p_vaddr + ppnt->p_filesz + ADDR_ALIGN) & PAGE_ALIGN;
++
++				if (map_size < ppnt->p_vaddr + ppnt->p_memsz)
++					status = (char *) _dl_mmap((char *) map_size + 
++						(piclib ? libaddr : 0), 
++						ppnt->p_vaddr + ppnt->p_memsz - map_size, 
++						LXFLAGS(ppnt->p_flags), flags | MAP_ANONYMOUS, -1, 0);
++			} else
++				status = (char *) _dl_mmap((char *) (ppnt->p_vaddr & PAGE_ALIGN) 
++					+ (piclib ? libaddr : 0), (ppnt->p_vaddr & ADDR_ALIGN) + 
++					ppnt->p_filesz, LXFLAGS(ppnt->p_flags), flags, 
++					infile, ppnt->p_offset & OFFS_ALIGN);
++			if (_dl_mmap_check_error(status)) {
++				_dl_dprintf(2, "%s: can't map '%s'\n", _dl_progname, libname);
++				_dl_internal_error_number = LD_ERROR_MMAP_FAILED;
++				_dl_munmap((char *) libaddr, maxvma - minvma);
++				_dl_close(infile);
++				_dl_munmap(header, 4096);
++				return NULL;
++			};
++
++			/* if(libaddr == 0 && piclib) {
++			   libaddr = (unsigned long) status;
++			   flags |= MAP_FIXED;
++			   }; */
++		};
++		ppnt++;
++	};
++	_dl_close(infile);
++
++	/* For a non-PIC library, the addresses are all absolute */
++	if (piclib) {
++		dynamic_addr += (unsigned long) libaddr;
++	}
++
++	/* 
++	 * OK, the ELF library is now loaded into VM in the correct locations
++	 * The next step is to go through and do the dynamic linking (if needed).
++	 */
++
++	/* Start by scanning the dynamic section to get all of the pointers */
++
++	if (!dynamic_addr) {
++		_dl_internal_error_number = LD_ERROR_NODYNAMIC;
++		_dl_dprintf(2, "%s: '%s' is missing a dynamic section\n", 
++			_dl_progname, libname);
++			_dl_munmap(header, 4096);
++		return NULL;
++	}
++
++	dpnt = (Elf32_Dyn *) dynamic_addr;
++
++	dynamic_size = dynamic_size / sizeof(Elf32_Dyn);
++	_dl_memset(dynamic_info, 0, sizeof(dynamic_info));
++
++#if defined(__mips__)
++	{
++		
++		int indx = 1;
++		Elf32_Dyn *dpnt = (Elf32_Dyn *) dynamic_addr;
++
++		while(dpnt->d_tag) {
++			dpnt++;
++			indx++;
++		}
++		dynamic_size = indx;
++	}
++#endif
++
++	{
++		unsigned long indx;
++
++		for (indx = 0; indx < dynamic_size; indx++) 
++		{
++			if (dpnt->d_tag > DT_JMPREL) {
++				dpnt++;
++				continue;
++			}
++			dynamic_info[dpnt->d_tag] = dpnt->d_un.d_val;
++			if (dpnt->d_tag == DT_TEXTREL)
++				dynamic_info[DT_TEXTREL] = 1;
++			dpnt++;
++		};
++	}
++
++	/* If the TEXTREL is set, this means that we need to make the pages
++	   writable before we perform relocations.  Do this now. They get set
++	   back again later. */
++
++	if (dynamic_info[DT_TEXTREL]) {
++#ifndef FORCE_SHAREABLE_TEXT_SEGMENTS
++		ppnt = (ElfW(Phdr) *)(intptr_t) & header[epnt->e_phoff];
++		for (i = 0; i < epnt->e_phnum; i++, ppnt++) {
++			if (ppnt->p_type == PT_LOAD && !(ppnt->p_flags & PF_W))
++				_dl_mprotect((void *) ((piclib ? libaddr : 0) + 
++					    (ppnt->p_vaddr & PAGE_ALIGN)), 
++					(ppnt->p_vaddr & ADDR_ALIGN) + (unsigned long) ppnt->p_filesz, 
++					PROT_READ | PROT_WRITE | PROT_EXEC);
++		}
++#else
++		_dl_dprintf(_dl_debug_file, "Can't modify %s's text section. Use GCC option -fPIC for shared objects, please.\n",libname);
++		_dl_exit(1);
++#endif		
++	}
++
++	tpnt = _dl_add_elf_hash_table(libname, (char *) libaddr, dynamic_info, 
++		dynamic_addr, dynamic_size);
++
++	tpnt->ppnt = (ElfW(Phdr) *)(intptr_t) (tpnt->loadaddr + epnt->e_phoff);
++	tpnt->n_phent = epnt->e_phnum;
++
++	/*
++	 * Add this object into the symbol chain
++	 */
++	if (*rpnt) {
++		(*rpnt)->next = (struct dyn_elf *) _dl_malloc(sizeof(struct dyn_elf));
++		_dl_memset((*rpnt)->next, 0, sizeof(struct dyn_elf));
++		(*rpnt)->next->prev = (*rpnt);
++		*rpnt = (*rpnt)->next;
++		(*rpnt)->dyn = tpnt;
++		tpnt->symbol_scope = _dl_symbol_tables;
++	}
++	tpnt->usage_count++;
++	tpnt->libtype = elf_lib;
++
++	/*
++	 * OK, the next thing we need to do is to insert the dynamic linker into
++	 * the proper entry in the GOT so that the PLT symbols can be properly
++	 * resolved. 
++	 */
++
++	lpnt = (unsigned long *) dynamic_info[DT_PLTGOT];
++
++	if (lpnt) {
++		lpnt = (unsigned long *) (dynamic_info[DT_PLTGOT] +
++			((int) libaddr));
++		INIT_GOT(lpnt, tpnt);
++	};
++
++#if defined (__SUPPORT_LD_DEBUG__)
++	if(_dl_debug) {
++		_dl_dprintf(2, "\n\tfile='%s';  generating link map\n", libname);
++		_dl_dprintf(2, "\t\tdynamic: %x  base: %x   size: %x\n", 
++				dynamic_addr, libaddr, dynamic_size);
++		_dl_dprintf(2, "\t\t  entry: %x  phdr: %x  phnum: %d\n\n", 
++				epnt->e_entry + libaddr, tpnt->ppnt, tpnt->n_phent);
++
++	}
++#endif
++	_dl_munmap(header, 4096);
++
++	return tpnt;
++}
++
++/* Ugly, ugly.  Some versions of the SVr4 linker fail to generate COPY
++   relocations for global variables that are present both in the image and
++   the shared library.  Go through and do it manually.  If the images
++   are guaranteed to be generated by a trustworthy linker, then this
++   step can be skipped. */
++
++int _dl_copy_fixups(struct dyn_elf *rpnt)
++{
++	int goof = 0;
++	struct elf_resolve *tpnt;
++
++	if (rpnt->next)
++		goof += _dl_copy_fixups(rpnt->next);
++	else
++		return 0;
++
++	tpnt = rpnt->dyn;
++
++	if (tpnt->init_flag & COPY_RELOCS_DONE)
++		return goof;
++	tpnt->init_flag |= COPY_RELOCS_DONE;
++
++#if defined (__SUPPORT_LD_DEBUG__)
++	if(_dl_debug) _dl_dprintf(_dl_debug_file,"\nrelocation copy fixups: %s", tpnt->libname);	
++#endif    
++
++#ifdef ELF_USES_RELOCA
++	goof += _dl_parse_copy_information(rpnt, 
++		tpnt->dynamic_info[DT_RELA], tpnt->dynamic_info[DT_RELASZ], 0);
++
++#else
++	goof += _dl_parse_copy_information(rpnt, tpnt->dynamic_info[DT_REL], 
++		tpnt->dynamic_info[DT_RELSZ], 0);
++
++#endif
++#if defined (__SUPPORT_LD_DEBUG__)
++	if(_dl_debug) _dl_dprintf(_dl_debug_file,"\nrelocation copy fixups: %s; finished\n\n", tpnt->libname);	
++#endif    
++	return goof;
++}
++
++/* Minimal printf which handles only %s, %d, and %x */
++void _dl_dprintf(int fd, const char *fmt, ...)
++{
++	int num;
++	va_list args;
++	char *start, *ptr, *string;
++	static char *buf;
++
++	buf = _dl_mmap((void *) 0, 4096, PROT_READ | PROT_WRITE,
++		MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
++	if (_dl_mmap_check_error(buf)) {
++			_dl_dprintf(2, "%s: mmap of a spare page failed!\n", _dl_progname);
++			_dl_exit(20);
++	}
++
++	start = ptr = buf;
++
++	if (!fmt)
++		return;
++
++	if (_dl_strlen(fmt) >= (sizeof(buf) - 1))
++		_dl_write(fd, "(overflow)\n", 10);
++
++	_dl_strcpy(buf, fmt);
++	va_start(args, fmt);
++
++	while (start) {
++		while (*ptr != '%' && *ptr) {
++			ptr++;
++		}
++
++		if (*ptr == '%') {
++			*ptr++ = '\0';
++			_dl_write(fd, start, _dl_strlen(start));
++
++			switch (*ptr++) {
++			case 's':
++				string = va_arg(args, char *);
++
++				if (!string)
++					_dl_write(fd, "(null)", 6);
++				else
++					_dl_write(fd, string, _dl_strlen(string));
++				break;
++
++			case 'i':
++			case 'd':
++			{
++				char tmp[22];
++				num = va_arg(args, int);
++
++				string = _dl_simple_ltoa(tmp, num);
++				_dl_write(fd, string, _dl_strlen(string));
++				break;
++			}
++			case 'x':
++			case 'X':
++			{
++				char tmp[22];
++				num = va_arg(args, int);
++
++				string = _dl_simple_ltoahex(tmp, num);
++				_dl_write(fd, string, _dl_strlen(string));
++				break;
++			}
++			default:
++				_dl_write(fd, "(null)", 6);
++				break;
++			}
++
++			start = ptr;
++		} else {
++			_dl_write(fd, start, _dl_strlen(start));
++			start = NULL;
++		}
++	}
++	_dl_munmap(buf, 4096);
++	return;
++}
++
++char *_dl_strdup(const char *string)
++{
++	char *retval;
++	int len;
++
++	len = _dl_strlen(string);
++	retval = _dl_malloc(len + 1);
++	_dl_strcpy(retval, string);
++	return retval;
++}
++
++void *(*_dl_malloc_function) (size_t size) = NULL;
++void *_dl_malloc(int size)
++{
++	void *retval;
++
++#if 0
++#ifdef __SUPPORT_LD_DEBUG_EARLY__
++	_dl_dprintf(2, "malloc: request for %d bytes\n", size);
++#endif
++#endif
++
++	if (_dl_malloc_function)
++		return (*_dl_malloc_function) (size);
++
++	if (_dl_malloc_addr - _dl_mmap_zero + size > 4096) {
++#ifdef __SUPPORT_LD_DEBUG_EARLY__
++		_dl_dprintf(2, "malloc: mmapping more memory\n");
++#endif
++		_dl_mmap_zero = _dl_malloc_addr = _dl_mmap((void *) 0, size, 
++				PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, 0, 0);
++		if (_dl_mmap_check_error(_dl_mmap_zero)) {
++			_dl_dprintf(2, "%s: mmap of a spare page failed!\n", _dl_progname);
++			_dl_exit(20);
++		}
++	}
++	retval = _dl_malloc_addr;
++	_dl_malloc_addr += size;
++
++	/*
++	 * Align memory to 4 byte boundary.  Some platforms require this, others
++	 * simply get better performance.
++	 */
++	_dl_malloc_addr = (char *) (((unsigned long) _dl_malloc_addr + 3) & ~(3));
++	return retval;
++}
++
++int _dl_fixup(struct elf_resolve *tpnt, int flag)
++{
++	int goof = 0;
++
++	if (tpnt->next)
++		goof += _dl_fixup(tpnt->next, flag);
++#if defined (__SUPPORT_LD_DEBUG__)
++	if(_dl_debug) _dl_dprintf(_dl_debug_file,"\nrelocation processing: %s", tpnt->libname);	
++#endif    
++	
++	if (tpnt->dynamic_info[DT_REL]) {
++#ifdef ELF_USES_RELOCA
++#if defined (__SUPPORT_LD_DEBUG__)
++		if(_dl_debug) _dl_dprintf(2, "%s: can't handle REL relocation records\n", _dl_progname);
++#endif    
++		goof++;
++		return goof;
++#else
++		if (tpnt->init_flag & RELOCS_DONE)
++			return goof;
++		tpnt->init_flag |= RELOCS_DONE;
++		goof += _dl_parse_relocation_information(tpnt, 
++				tpnt->dynamic_info[DT_REL], 
++				tpnt->dynamic_info[DT_RELSZ], 0);
++#endif
++	}
++	if (tpnt->dynamic_info[DT_RELA]) {
++#ifndef ELF_USES_RELOCA
++#if defined (__SUPPORT_LD_DEBUG__)
++		if(_dl_debug) _dl_dprintf(2, "%s: can't handle RELA relocation records\n", _dl_progname);
++#endif    
++		goof++;
++		return goof;
++#else
++		if (tpnt->init_flag & RELOCS_DONE)
++			return goof;
++		tpnt->init_flag |= RELOCS_DONE;
++		goof += _dl_parse_relocation_information(tpnt, 
++				tpnt->dynamic_info[DT_RELA], 
++				tpnt->dynamic_info[DT_RELASZ], 0);
++#endif
++	}
++	if (tpnt->dynamic_info[DT_JMPREL]) {
++		if (tpnt->init_flag & JMP_RELOCS_DONE)
++			return goof;
++		tpnt->init_flag |= JMP_RELOCS_DONE;
++		if (flag & RTLD_LAZY) {
++			_dl_parse_lazy_relocation_information(tpnt, 
++					tpnt->dynamic_info[DT_JMPREL], 
++					tpnt->dynamic_info [DT_PLTRELSZ], 0);
++		} else {
++			goof += _dl_parse_relocation_information(tpnt, 
++					tpnt->dynamic_info[DT_JMPREL], 
++					tpnt->dynamic_info[DT_PLTRELSZ], 0);
++		}
++	}
++#if defined (__SUPPORT_LD_DEBUG__)
++	if(_dl_debug) {
++		_dl_dprintf(_dl_debug_file,"\nrelocation processing: %s", tpnt->libname);     
++		_dl_dprintf(_dl_debug_file,"; finished\n\n");
++	}
++#endif    
++	return goof;
++}
++
++
+diff -urN uClibc/ldso-0.9.24/ldso/sh/boot1_arch.h uClibc.ldso.24/ldso-0.9.24/ldso/sh/boot1_arch.h
+--- uClibc/ldso-0.9.24/ldso/sh/boot1_arch.h	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/sh/boot1_arch.h	2002-11-03 08:12:29.000000000 -0600
+@@ -0,0 +1,22 @@
++/* Any assmbly language/system dependent hacks needed to setup boot1.c so it
++ * will work as expected and cope with whatever platform specific wierdness is
++ * needed for this architecture.  */
++
++asm("" \
++"	.text\n"			\
++"	.globl	_dl_boot\n"		\
++"_dl_boot:\n"				\
++"	mov	r15, r4\n"		\
++"	mov.l   .L_dl_boot2, r0\n"	\
++"	bsrf    r0\n"			\
++"	add	#4, r4\n"		\
++".jmp_loc:\n"				\
++"	jmp	@r0\n"			\
++"	 mov    #0, r4 	!call _start with arg == 0\n" \
++".L_dl_boot2:\n"			\
++"	.long   _dl_boot2-.jmp_loc\n"	\
++"	.previous\n"			\
++);
++
++#define _dl_boot _dl_boot2
++#define LD_BOOT(X)   static void *  __attribute__ ((unused)) _dl_boot (X)
+diff -urN uClibc/ldso-0.9.24/ldso/sh/elfinterp.c uClibc.ldso.24/ldso-0.9.24/ldso/sh/elfinterp.c
+--- uClibc/ldso-0.9.24/ldso/sh/elfinterp.c	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/sh/elfinterp.c	2003-09-11 05:26:16.000000000 -0500
+@@ -0,0 +1,427 @@
++/* vi: set sw=4 ts=4: */
++/* SuperH ELF shared library loader suppport
++ *
++ * Copyright (C) 2002, Stefan Allius <allius@atecom.com> and 
++ *                     Eddie C. Dost <ecd@atecom.com>
++ *
++ * All rights reserved.
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions
++ * are met:
++ * 1. Redistributions of source code must retain the above copyright
++ *    notice, this list of conditions and the following disclaimer.
++ * 2. The name of the above contributors may not be
++ *    used to endorse or promote products derived from this software
++ *    without specific prior written permission.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND
++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ * ARE DISCLAIMED.  IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE
++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
++ * SUCH DAMAGE.
++ */
++
++#if defined (__SUPPORT_LD_DEBUG__)
++static const char *_dl_reltypes_tab[] =
++{
++  [0]	"R_SH_NONE",	"R_SH_DIR32",	"R_SH_REL32",	"R_SH_DIR8WPN",
++  [4]	"R_SH_IND12W",	"R_SH_DIR8WPL",	"R_SH_DIR8WPZ",	"R_SH_DIR8BP",
++  [8]	"R_SH_DIR8W",	"R_SH_DIR8L",
++ [25]	"R_SH_SWITCH16","R_SH_SWITCH32","R_SH_USES",
++ [28]	"R_SH_COUNT",	"R_SH_ALIGN",	"R_SH_CODE",	"R_SH_DATA",
++ [32]	"R_SH_LABEL",	"R_SH_SWITCH8",	"R_SH_GNU_VTINHERIT","R_SH_GNU_VTENTRY",
++[160]	"R_SH_GOT32",	"R_SH_PLT32",	"R_SH_COPY",	"R_SH_GLOB_DAT",
++[164]	"R_SH_JMP_SLOT","R_SH_RELATIVE","R_SH_GOTOFF",	"R_SH_GOTPC",
++};
++
++static const char *
++_dl_reltypes(int type)
++{
++  static char buf[22];  
++  const char *str;
++  
++  if (type >= (int)(sizeof (_dl_reltypes_tab)/sizeof(_dl_reltypes_tab[0])) ||
++      NULL == (str = _dl_reltypes_tab[type]))
++  {
++    str =_dl_simple_ltoa( buf, (unsigned long)(type));
++  }
++  return str;
++}
++
++static 
++void debug_sym(Elf32_Sym *symtab,char *strtab,int symtab_index)
++{
++  if(_dl_debug_symbols)
++  {
++    if(symtab_index){
++      _dl_dprintf(_dl_debug_file, "\n%s\tvalue=%x\tsize=%x\tinfo=%x\tother=%x\tshndx=%x",
++		  strtab + symtab[symtab_index].st_name,
++		  symtab[symtab_index].st_value,
++		  symtab[symtab_index].st_size,
++		  symtab[symtab_index].st_info,
++		  symtab[symtab_index].st_other,
++		  symtab[symtab_index].st_shndx);
++    }
++  }
++}
++
++static void debug_reloc(Elf32_Sym *symtab,char *strtab, ELF_RELOC *rpnt)
++{
++  if(_dl_debug_reloc)
++  {
++    int symtab_index;
++    const char *sym;
++    symtab_index = ELF32_R_SYM(rpnt->r_info);
++    sym = symtab_index ? strtab + symtab[symtab_index].st_name : "sym=0x0";
++    
++  if(_dl_debug_symbols)
++	  _dl_dprintf(_dl_debug_file, "\n\t");
++  else
++	  _dl_dprintf(_dl_debug_file, "\n%s\n\t", sym);
++    
++#ifdef ELF_USES_RELOCA
++    _dl_dprintf(_dl_debug_file, "%s\toffset=%x\taddend=%x",
++		_dl_reltypes(ELF32_R_TYPE(rpnt->r_info)),
++		rpnt->r_offset,
++		rpnt->r_addend);
++#else
++    _dl_dprintf(_dl_debug_file, "%s\toffset=%x\n",
++		_dl_reltypes(ELF32_R_TYPE(rpnt->r_info)),
++		rpnt->r_offset);
++#endif
++  }
++}
++#endif
++
++/* Program to load an ELF binary on a linux system, and run it.
++   References to symbols in sharable libraries can be resolved by either
++   an ELF sharable library or a linux style of shared library. */
++
++/* Disclaimer:  I have never seen any AT&T source code for SVr4, nor have
++   I ever taken any courses on internals.  This program was developed using
++   information available through the book "UNIX SYSTEM V RELEASE 4,
++   Programmers guide: Ansi C and Programming Support Tools", which did
++   a more than adequate job of explaining everything required to get this
++   working. */
++
++extern int _dl_linux_resolve(void);
++
++unsigned long _dl_linux_resolver(struct elf_resolve *tpnt, int reloc_entry)
++{
++	int reloc_type;
++	ELF_RELOC *this_reloc;
++	char *strtab;
++	Elf32_Sym *symtab;
++	int symtab_index;
++	char *rel_addr;
++	char *new_addr;
++	char **got_addr;
++	unsigned long instr_addr;
++	char *symname;
++
++	rel_addr = (char *) (tpnt->dynamic_info[DT_JMPREL] + tpnt->loadaddr);
++
++	this_reloc = (ELF_RELOC *)(intptr_t)(rel_addr + reloc_entry);
++	reloc_type = ELF32_R_TYPE(this_reloc->r_info);
++	symtab_index = ELF32_R_SYM(this_reloc->r_info);
++
++	symtab = (Elf32_Sym *)(intptr_t) (tpnt->dynamic_info[DT_SYMTAB] + tpnt->loadaddr);
++	strtab = (char *) (tpnt->dynamic_info[DT_STRTAB] + tpnt->loadaddr);
++	symname = strtab + symtab[symtab_index].st_name;
++
++	if (reloc_type != R_SH_JMP_SLOT) {
++	  _dl_dprintf(2, "%s: Incorrect relocation type in jump relocations\n", 
++		       _dl_progname);
++	  _dl_exit(1);
++	}
++	
++	/* Address of jump instruction to fix up */
++	instr_addr = ((unsigned long) this_reloc->r_offset + 
++			(unsigned long) tpnt->loadaddr);
++	got_addr = (char **) instr_addr;
++
++
++	/* Get the address of the GOT entry */
++	new_addr = _dl_find_hash(symname, tpnt->symbol_scope, tpnt, resolver);
++	if (!new_addr) {
++		new_addr = _dl_find_hash(symname, NULL, NULL, resolver);
++		if (new_addr) {
++			return (unsigned long) new_addr;
++		}
++		
++		_dl_dprintf(2, "%s: can't resolve symbol '%s'\n", _dl_progname, symname);
++		_dl_exit(1);
++	}
++
++#if defined (__SUPPORT_LD_DEBUG__)
++	if ((unsigned long) got_addr < 0x20000000)
++	{
++		if (_dl_debug_bindings)
++		{
++			_dl_dprintf(_dl_debug_file, "\nresolve function: %s", symname);
++			if(_dl_debug_detail) _dl_dprintf(_dl_debug_file, 
++					"\n\tpatched %x ==> %x @ %x\n", *got_addr, new_addr, got_addr);
++		}
++	}
++	if (!_dl_debug_nofixups) {
++		*got_addr = new_addr;
++	}
++#else
++	*got_addr = new_addr;
++#endif
++
++	return (unsigned long) new_addr;
++}
++
++
++static int
++_dl_parse(struct elf_resolve *tpnt, struct dyn_elf *scope,
++	  unsigned long rel_addr, unsigned long rel_size,
++	  int (*reloc_fnc) (struct elf_resolve *tpnt, struct dyn_elf *scope,
++			    ELF_RELOC *rpnt, Elf32_Sym *symtab, char *strtab))
++{
++	unsigned int i;
++	char *strtab;
++	Elf32_Sym *symtab;
++	ELF_RELOC *rpnt;
++	int symtab_index;
++	/* Now parse the relocation information */
++
++	rpnt = (ELF_RELOC *)(intptr_t) (rel_addr + tpnt->loadaddr);
++	rel_size = rel_size / sizeof(ELF_RELOC);
++
++	symtab = (Elf32_Sym *)(intptr_t) (tpnt->dynamic_info[DT_SYMTAB] + tpnt->loadaddr);
++	strtab = (char *) (tpnt->dynamic_info[DT_STRTAB] + tpnt->loadaddr);
++
++	  for (i = 0; i < rel_size; i++, rpnt++) {
++	        int res;
++	    
++		symtab_index = ELF32_R_SYM(rpnt->r_info);
++		
++		/* When the dynamic linker bootstrapped itself, it resolved some symbols.
++		   Make sure we do not do them again */
++		if (!symtab_index && tpnt->libtype == program_interpreter)
++			continue;
++		if (symtab_index && tpnt->libtype == program_interpreter &&
++		    _dl_symbol(strtab + symtab[symtab_index].st_name))
++			continue;
++
++#if defined (__SUPPORT_LD_DEBUG__)
++		debug_sym(symtab,strtab,symtab_index);
++		debug_reloc(symtab,strtab,rpnt);
++#endif
++
++		res = reloc_fnc (tpnt, scope, rpnt, symtab, strtab);
++
++		if (res==0) continue;
++
++		_dl_dprintf(2, "\n%s: ",_dl_progname);
++		
++		if (symtab_index)
++		  _dl_dprintf(2, "symbol '%s': ", strtab + symtab[symtab_index].st_name);
++		  
++		if (res <0)
++		{
++		        int reloc_type = ELF32_R_TYPE(rpnt->r_info);
++#if defined (__SUPPORT_LD_DEBUG__)
++			_dl_dprintf(2, "can't handle reloc type %s\n ", _dl_reltypes(reloc_type));
++#else
++			_dl_dprintf(2, "can't handle reloc type %x\n", reloc_type);
++#endif			
++			_dl_exit(-res);
++		}
++		else if (res >0)
++		{
++			_dl_dprintf(2, "can't resolve symbol\n");
++			return res;
++		}
++	  }
++	  return 0;
++}
++
++
++static int
++_dl_do_reloc (struct elf_resolve *tpnt,struct dyn_elf *scope,
++	      ELF_RELOC *rpnt, Elf32_Sym *symtab, char *strtab)
++{
++        int reloc_type;
++	int symtab_index;
++	char *symname;
++	unsigned long *reloc_addr;
++	unsigned long symbol_addr;
++#if defined (__SUPPORT_LD_DEBUG__)
++	unsigned long old_val;
++#endif
++  
++	reloc_addr = (unsigned long *)(intptr_t) (tpnt->loadaddr + (unsigned long) rpnt->r_offset);
++	reloc_type = ELF32_R_TYPE(rpnt->r_info);
++	symtab_index = ELF32_R_SYM(rpnt->r_info);
++	symbol_addr = 0;
++	symname      = strtab + symtab[symtab_index].st_name;
++
++	if (symtab_index) {
++
++
++		symbol_addr = (unsigned long) _dl_find_hash(symname, scope, 
++				(reloc_type == R_SH_JMP_SLOT ? tpnt : NULL), symbolrel);
++
++		/*
++		 * We want to allow undefined references to weak symbols - this might
++		 * have been intentional.  We should not be linking local symbols
++		 * here, so all bases should be covered.
++		 */
++		if (!symbol_addr && ELF32_ST_BIND(symtab[symtab_index].st_info) == STB_GLOBAL) {
++#if defined (__SUPPORT_LD_DEBUG__)
++			_dl_dprintf(2, "\tglobal symbol '%s' already defined in '%s'\n",
++					symname, tpnt->libname);
++#endif
++			return 0;
++		}
++	}
++
++
++#if defined (__SUPPORT_LD_DEBUG__)
++	old_val = *reloc_addr;
++#endif
++	    switch (reloc_type) {
++		case R_SH_NONE:
++			break;
++		case R_SH_COPY:
++			/* handled later on */
++			break;
++		case R_SH_DIR32:
++		case R_SH_GLOB_DAT:
++		case R_SH_JMP_SLOT:
++			*reloc_addr = symbol_addr + rpnt->r_addend;
++			break;
++		case R_SH_REL32:
++			*reloc_addr = symbol_addr + rpnt->r_addend -
++					(unsigned long) reloc_addr;
++			break;
++		case R_SH_RELATIVE:
++			*reloc_addr = (unsigned long) tpnt->loadaddr + rpnt->r_addend;
++			break;
++		default:
++			return -1; /*call _dl_exit(1) */
++	    }
++#if defined (__SUPPORT_LD_DEBUG__)
++	    if(_dl_debug_reloc && _dl_debug_detail)
++		_dl_dprintf(_dl_debug_file, "\tpatched: %x ==> %x @ %x", old_val, *reloc_addr, reloc_addr);
++#endif
++
++	return 0;
++}
++ 
++	  
++static int
++_dl_do_lazy_reloc (struct elf_resolve *tpnt, struct dyn_elf *scope,
++		   ELF_RELOC *rpnt, Elf32_Sym *symtab, char *strtab)
++{
++	int reloc_type;
++	unsigned long *reloc_addr;
++#if defined (__SUPPORT_LD_DEBUG__)
++	unsigned long old_val;
++#endif
++	(void)scope;
++	(void)symtab;
++	(void)strtab;
++
++	reloc_addr = (unsigned long *)(intptr_t) (tpnt->loadaddr + (unsigned long) rpnt->r_offset);
++	reloc_type = ELF32_R_TYPE(rpnt->r_info);
++  
++#if defined (__SUPPORT_LD_DEBUG__)
++	old_val = *reloc_addr;
++#endif
++	    switch (reloc_type) {
++	      case R_SH_NONE:
++		break;
++	      case R_SH_JMP_SLOT:
++		*reloc_addr += (unsigned long) tpnt->loadaddr;
++		break;
++	      default:
++	        return -1; /*call _dl_exit(1) */
++	    }
++#if defined (__SUPPORT_LD_DEBUG__)
++	    if(_dl_debug_reloc && _dl_debug_detail)
++		_dl_dprintf(_dl_debug_file, "\tpatched: %x ==> %x @ %x", old_val, *reloc_addr, reloc_addr);
++#endif
++	return 0;
++	
++}
++
++/* This is done as a separate step, because there are cases where
++   information is first copied and later initialized.  This results in
++   the wrong information being copied.  Someone at Sun was complaining about
++   a bug in the handling of _COPY by SVr4, and this may in fact be what he
++   was talking about.  Sigh. */
++
++/* No, there are cases where the SVr4 linker fails to emit COPY relocs
++   at all */
++static int
++_dl_do_copy (struct elf_resolve *tpnt, struct dyn_elf *scope,
++	     ELF_RELOC *rpnt, Elf32_Sym *symtab, char *strtab)
++{
++        int reloc_type;
++	int symtab_index;
++	unsigned long *reloc_addr;
++	unsigned long symbol_addr;
++	int goof = 0;
++	char*symname;
++	  
++	reloc_addr = (unsigned long *)(intptr_t) (tpnt->loadaddr + (unsigned long) rpnt->r_offset);
++	reloc_type = ELF32_R_TYPE(rpnt->r_info);
++	if (reloc_type != R_SH_COPY) 
++	    return 0;
++	symtab_index = ELF32_R_SYM(rpnt->r_info);
++	symbol_addr = 0;
++	symname      = strtab + symtab[symtab_index].st_name;
++		
++	if (symtab_index) {
++
++		symbol_addr = (unsigned long) _dl_find_hash(symname, scope, NULL, copyrel);
++		if (!symbol_addr) goof++;
++	}
++	if (!goof) {
++#if defined (__SUPPORT_LD_DEBUG__)
++	        if(_dl_debug_move)
++		  _dl_dprintf(_dl_debug_file,"\n%s move %x bytes from %x to %x",
++			     symname, symtab[symtab_index].st_size,
++			     symbol_addr, symtab[symtab_index].st_value);
++#endif
++		_dl_memcpy((char *) symtab[symtab_index].st_value, 
++			(char *) symbol_addr, symtab[symtab_index].st_size);
++	}
++
++	return goof;
++}
++
++
++void _dl_parse_lazy_relocation_information(struct elf_resolve *tpnt, 
++	unsigned long rel_addr, unsigned long rel_size, int type)
++{
++	(void) type;
++	(void)_dl_parse(tpnt, NULL, rel_addr, rel_size, _dl_do_lazy_reloc);
++}
++
++int _dl_parse_relocation_information(struct elf_resolve *tpnt, 
++	unsigned long rel_addr, unsigned long rel_size, int type)
++{
++	(void) type;
++	return _dl_parse(tpnt, tpnt->symbol_scope, rel_addr, rel_size, _dl_do_reloc);
++}
++
++int _dl_parse_copy_information(struct dyn_elf *xpnt, unsigned long rel_addr, 
++	unsigned long rel_size, int type)
++{
++	(void) type;
++	return _dl_parse(xpnt->dyn, xpnt->next, rel_addr, rel_size, _dl_do_copy);
++}
++
++
+diff -urN uClibc/ldso-0.9.24/ldso/sh/ld_syscalls.h uClibc.ldso.24/ldso-0.9.24/ldso/sh/ld_syscalls.h
+--- uClibc/ldso-0.9.24/ldso/sh/ld_syscalls.h	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/sh/ld_syscalls.h	2002-08-09 07:20:19.000000000 -0500
+@@ -0,0 +1,7 @@
++/* Define the __set_errno macro as nothing so that we don't bother
++ * setting errno, which is important since we make system calls
++ * before the errno symbol is dynamicly linked. */
++
++#define __set_errno(X) {(void)(X);}
++#include "sys/syscall.h"
++
+diff -urN uClibc/ldso-0.9.24/ldso/sh/ld_sysdep.h uClibc.ldso.24/ldso-0.9.24/ldso/sh/ld_sysdep.h
+--- uClibc/ldso-0.9.24/ldso/sh/ld_sysdep.h	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/sh/ld_sysdep.h	2002-11-07 20:18:16.000000000 -0600
+@@ -0,0 +1,144 @@
++/*
++ * Various assmbly language/system dependent  hacks that are required
++ * so that we can minimize the amount of platform specific code.
++ */
++
++/* 
++ * Define this if the system uses RELOCA.
++ */
++#define ELF_USES_RELOCA
++
++/*
++ * Get a pointer to the argv array.  On many platforms this can be just
++ * the address if the first argument, on other platforms we need to
++ * do something a little more subtle here.
++ */
++#define GET_ARGV(ARGVP, ARGS) ARGVP = ((unsigned long*)   ARGS)
++
++/*
++ * Initialization sequence for a GOT.
++ */
++#define INIT_GOT(GOT_BASE,MODULE) \
++{				\
++  GOT_BASE[2] = (unsigned long) _dl_linux_resolve; \
++  GOT_BASE[1] = (unsigned long) (MODULE); \
++}
++
++/*
++ * Here is a macro to perform a relocation.  This is only used when
++ * bootstrapping the dynamic loader.  RELP is the relocation that we
++ * are performing, REL is the pointer to the address we are relocating.
++ * SYMBOL is the symbol involved in the relocation, and LOAD is the
++ * load address.
++ */
++#define PERFORM_BOOTSTRAP_RELOC(RELP,REL,SYMBOL,LOAD)		\
++	switch(ELF32_R_TYPE((RELP)->r_info)){			\
++	case R_SH_REL32:					\
++		*(REL)  = (SYMBOL) + (RELP)->r_addend		\
++			    - (unsigned long)(REL);		\
++		break;						\
++	case R_SH_DIR32:					\
++	case R_SH_GLOB_DAT:					\
++	case R_SH_JMP_SLOT:					\
++		*(REL)  = (SYMBOL) + (RELP)->r_addend;		\
++		break;						\
++	case R_SH_RELATIVE:					\
++		*(REL)  = (LOAD) + (RELP)->r_addend;		\
++		break;						\
++	case R_SH_NONE:						\
++		break;						\
++	default:						\
++		SEND_STDERR("BOOTSTRAP_RELOC: unhandled reloc type "); \
++		SEND_NUMBER_STDERR(ELF32_R_TYPE((RELP)->r_info), 1); \
++		SEND_STDERR("REL, SYMBOL, LOAD: ");		\
++		SEND_ADDRESS_STDERR(REL, 0);			\
++		SEND_STDERR(", ");				\
++		SEND_ADDRESS_STDERR(SYMBOL, 0);			\
++		SEND_STDERR(", ");				\
++		SEND_ADDRESS_STDERR(LOAD, 1);			\
++		_dl_exit(1);					\
++	}
++
++
++/*
++ * Transfer control to the user's application, once the dynamic loader
++ * is done.  This routine has to exit the current function, then 
++ * call the _dl_elf_main function.
++ */
++
++#define START()   return _dl_elf_main;
++
++
++
++/* Here we define the magic numbers that this dynamic loader should accept */
++
++#define MAGIC1 EM_SH
++#undef  MAGIC2
++/* Used for error messages */
++#define ELF_TARGET "sh"
++
++struct elf_resolve;
++extern unsigned long _dl_linux_resolver(struct elf_resolve * tpnt, int reloc_entry);
++
++static __inline__ unsigned int
++_dl_urem(unsigned int n, unsigned int base)
++{
++  int res;
++  
++	__asm__ (""\
++		"mov	#0, r0\n\t" \
++		"div0u\n\t" \
++		"" \
++		"! get one bit from the msb of the numerator into the T\n\t" \
++		"! bit and divide it by whats in %2.  Put the answer bit\n\t" \
++		"! into the T bit so it can come out again at the bottom\n\t" \
++		""				\
++		"rotcl	%1 ; div1 %2, r0\n\t"	\
++		"rotcl	%1 ; div1 %2, r0\n\t"	\
++		"rotcl	%1 ; div1 %2, r0\n\t"	\
++		"rotcl	%1 ; div1 %2, r0\n\t"	\
++		"rotcl	%1 ; div1 %2, r0\n\t"	\
++		"rotcl	%1 ; div1 %2, r0\n\t"	\
++		"rotcl	%1 ; div1 %2, r0\n\t"	\
++		"rotcl	%1 ; div1 %2, r0\n\t"	\
++		""				\
++		"rotcl	%1 ; div1 %2, r0\n\t"	\
++		"rotcl	%1 ; div1 %2, r0\n\t"	\
++		"rotcl	%1 ; div1 %2, r0\n\t"	\
++		"rotcl	%1 ; div1 %2, r0\n\t"	\
++		"rotcl	%1 ; div1 %2, r0\n\t"	\
++		"rotcl	%1 ; div1 %2, r0\n\t"	\
++		"rotcl	%1 ; div1 %2, r0\n\t"	\
++		"rotcl	%1 ; div1 %2, r0\n\t"	\
++		""				\
++		"rotcl	%1 ; div1 %2, r0\n\t"	\
++		"rotcl	%1 ; div1 %2, r0\n\t"	\
++		"rotcl	%1 ; div1 %2, r0\n\t"	\
++		"rotcl	%1 ; div1 %2, r0\n\t"	\
++		"rotcl	%1 ; div1 %2, r0\n\t"	\
++		"rotcl	%1 ; div1 %2, r0\n\t"	\
++		"rotcl	%1 ; div1 %2, r0\n\t"	\
++		"rotcl	%1 ; div1 %2, r0\n\t"	\
++ 		""				\
++		"rotcl	%1 ; div1 %2, r0\n\t"	\
++		"rotcl	%1 ; div1 %2, r0\n\t"	\
++		"rotcl	%1 ; div1 %2, r0\n\t"	\
++		"rotcl	%1 ; div1 %2, r0\n\t"	\
++		"rotcl	%1 ; div1 %2, r0\n\t"	\
++		"rotcl	%1 ; div1 %2, r0\n\t"	\
++		"rotcl	%1 ; div1 %2, r0\n\t"	\
++		"rotcl	%1 ; div1 %2, r0\n\t"	\
++		"rotcl	%1\n\t"
++		: "=r" (res)
++		: "0" (n), "r" (base)
++		: "r0","cc");
++
++	return n - (base * res);
++}
++
++#define do_rem(result, n, base)     ((result) = _dl_urem((n), (base)))
++
++/* 4096 bytes alignment */
++#define PAGE_ALIGN 0xfffff000
++#define ADDR_ALIGN 0xfff
++#define OFFS_ALIGN 0x7ffff000
+diff -urN uClibc/ldso-0.9.24/ldso/sh/resolve.S uClibc.ldso.24/ldso-0.9.24/ldso/sh/resolve.S
+--- uClibc/ldso-0.9.24/ldso/sh/resolve.S	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/sh/resolve.S	2002-11-07 20:18:16.000000000 -0600
+@@ -0,0 +1,91 @@
++/*
++ * Stolen from glibc-2.2.2 by Eddie C. Dost <ecd@atecom.com>
++ */
++
++	.text
++	.globl	_dl_linux_resolver
++	.globl	_dl_linux_resolve
++	.type	_dl_linux_resolve, @function
++	.balign	16
++_dl_linux_resolve:
++	mov.l	r3, @-r15
++	mov.l	r4, @-r15
++	mov.l	r5, @-r15
++	mov.l	r6, @-r15
++	mov.l	r7, @-r15
++	mov.l	r12, @-r15
++	movt	r3		! Save T flag
++	mov.l	r3, @-r15
++
++#ifdef HAVE_FPU
++	sts.l	fpscr, @-r15
++	mov	#8,r3
++	swap.w	r3, r3
++	lds	r3, fpscr
++	fmov.s	fr11, @-r15
++	fmov.s	fr10, @-r15
++	fmov.s	fr9, @-r15
++	fmov.s	fr8, @-r15
++	fmov.s	fr7, @-r15
++	fmov.s	fr6, @-r15
++	fmov.s	fr5, @-r15
++	fmov.s	fr4, @-r15
++#endif
++	sts.l	pr, @-r15
++/* Note - The PLT entries have been "optimised" not to use r2.  r2 is used by
++   GCC to return the address of large structures, so it should not be
++   corrupted here.  This does mean however, that those PLTs does not conform
++   to the SH PIC ABI.  That spec says that r0 contains the type of the PLT
++   and r2 contains the GOT id.  The GNU Plt version stores the GOT id in r0 and
++   ignores the type.  We can easily detect this difference however,
++   since the type will always be 0 or 8, and the GOT ids will always be
++   greater than or equal to 12.
++
++   Found in binutils/bfd/elf32-sh.c by Stefan Allius <allius@atecom.com>
++ */
++	mov     #8 ,r5
++	cmp/gt  r5, r0
++	bt      1f
++	mov     r2, r0          ! link map address in r2 (SH PIC ABI)
++1:
++	mov     r0, r4          ! link map address in r0 (GNUs PLT)
++	mova    .LG, r0
++	mov.l   .LG, r5
++	add     r5, r0
++	mov.l   3f, r5
++	mov.l   @(r0, r5),r5
++	jsr     @r5
++	 mov	r1, r5		! Reloc offset
++
++	lds.l	@r15+, pr	! Get register content back
++
++#ifdef HAVE_FPU
++	fmov.s	@r15+, fr4
++	fmov.s	@r15+, fr5
++	fmov.s	@r15+, fr6
++	fmov.s	@r15+, fr7
++	fmov.s	@r15+, fr8
++	fmov.s	@r15+, fr9
++	fmov.s	@r15+, fr10
++	fmov.s	@r15+, fr11
++	lds.l	@r15+, fpscr
++#endif
++
++	mov.l	@r15+, r3
++	shal	r3		! Load T flag
++	mov.l	@r15+, r12
++	mov.l	@r15+, r7
++	mov.l	@r15+, r6
++	mov.l	@r15+, r5
++	mov.l	@r15+, r4
++	jmp	@r0		! Jump to function address
++	 mov.l	@r15+, r3
++
++	.balign	4
++
++3:
++	.long   _dl_linux_resolver@GOT
++.LG:
++	.long	_GLOBAL_OFFSET_TABLE_
++	.size	_dl_linux_resolve, . - _dl_linux_resolve
++
+diff -urN uClibc/ldso-0.9.24/ldso/sparc/boot1_arch.h uClibc.ldso.24/ldso-0.9.24/ldso/sparc/boot1_arch.h
+--- uClibc/ldso-0.9.24/ldso/sparc/boot1_arch.h	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/sparc/boot1_arch.h	2002-08-08 09:35:49.000000000 -0500
+@@ -0,0 +1,7 @@
++/* Any assmbly language/system dependent hacks needed to setup boot1.c so it
++ * will work as expected and cope with whatever platform specific wierdness is
++ * needed for this architecture.  See arm/boot1_arch.h for an example of what
++ * can be done.
++ */
++
++#define LD_BOOT(X)   void _dl_boot (X)
+diff -urN uClibc/ldso-0.9.24/ldso/sparc/elfinterp.c uClibc.ldso.24/ldso-0.9.24/ldso/sparc/elfinterp.c
+--- uClibc/ldso-0.9.24/ldso/sparc/elfinterp.c	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/sparc/elfinterp.c	2002-11-05 12:21:12.000000000 -0600
+@@ -0,0 +1,357 @@
++/* vi: set sw=4 ts=4: */
++/* sparc ELF shared library loader suppport
++ *
++ * Copyright (c) 1994-2000 Eric Youngdale, Peter MacDonald, 
++ *				David Engel, Hongjiu Lu and Mitch D'Souza
++ *
++ * All rights reserved.
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions
++ * are met:
++ * 1. Redistributions of source code must retain the above copyright
++ *    notice, this list of conditions and the following disclaimer.
++ * 2. The name of the above contributors may not be
++ *    used to endorse or promote products derived from this software
++ *    without specific prior written permission.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE CONTRIBUTORS ``AS IS'' AND
++ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
++ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
++ * ARE DISCLAIMED.  IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE
++ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
++ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
++ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
++ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
++ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
++ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
++ * SUCH DAMAGE.
++ */
++
++#if defined (__SUPPORT_LD_DEBUG__)
++static const char * _dl_reltypes[] = { "R_SPARC_NONE", "R_SPARC_8",
++  "R_SPARC_16", "R_SPARC_32", "R_SPARC_DISP8", "R_SPARC_DISP16",
++  "R_SPARC_DISP32", "R_SPARC_WDISP30", "R_SPARC_WDISP22",
++  "R_SPARC_HI22", "R_SPARC_22", "R_SPARC_13", "R_SPARC_LO10",
++  "R_SPARC_GOT10", "R_SPARC_GOT13", "R_SPARC_GOT22", "R_SPARC_PC10",
++  "R_SPARC_PC22", "R_SPARC_WPLT30", "R_SPARC_COPY",
++  "R_SPARC_GLOB_DAT", "R_SPARC_JMP_SLOT", "R_SPARC_RELATIVE",
++  "R_SPARC_UA32"};
++#endif
++
++/* Program to load an ELF binary on a linux system, and run it.
++References to symbols in sharable libraries can be resolved by either
++an ELF sharable library or a linux style of shared library. */
++
++/* Disclaimer:  I have never seen any AT&T source code for SVr4, nor have
++   I ever taken any courses on internals.  This program was developed using
++   information available through the book "UNIX SYSTEM V RELEASE 4,
++   Programmers guide: Ansi C and Programming Support Tools", which did
++   a more than adequate job of explaining everything required to get this
++   working. */
++
++extern _dl_linux_resolve(void);
++
++unsigned int _dl_linux_resolver(unsigned int reloc_entry, unsigned int * plt)
++{
++  int reloc_type;
++  Elf32_Rela * this_reloc;
++  char * strtab;
++  Elf32_Sym * symtab; 
++  Elf32_Rela * rel_addr;
++  struct elf_resolve * tpnt;
++  int symtab_index;
++  char * new_addr;
++  char ** got_addr;
++  unsigned int instr_addr;
++  tpnt = (struct elf_resolve *) plt[2];
++
++  rel_addr = (Elf32_Rela *) (tpnt->dynamic_info[DT_JMPREL] + 
++				   tpnt->loadaddr);
++
++  /*
++   * Generate the correct relocation index into the .rela.plt section.
++   */
++  reloc_entry = (reloc_entry >> 12) - 0xc;
++
++  this_reloc = (Elf32_Rela *) ((char *) rel_addr + reloc_entry);
++
++  reloc_type = ELF32_R_TYPE(this_reloc->r_info);
++  symtab_index = ELF32_R_SYM(this_reloc->r_info);
++
++  symtab =  (Elf32_Sym *) (tpnt->dynamic_info[DT_SYMTAB] + tpnt->loadaddr);
++  strtab = (char *) (tpnt->dynamic_info[DT_STRTAB] + tpnt->loadaddr);
++
++  _dl_dprintf(2, "tpnt = %x\n", tpnt);
++  _dl_dprintf(2, "reloc = %x\n", this_reloc);
++  _dl_dprintf(2, "symtab = %x\n", symtab);
++  _dl_dprintf(2, "strtab = %x\n", strtab);
++
++
++  if (reloc_type != R_SPARC_JMP_SLOT) {
++    _dl_dprintf(2, "%s: incorrect relocation type in jump relocations (%d)\n",
++		  _dl_progname, reloc_type);
++    _dl_exit(30);
++  };
++
++  /* Address of jump instruction to fix up */
++  instr_addr  = ((int)this_reloc->r_offset  + (int)tpnt->loadaddr);
++  got_addr = (char **) instr_addr;
++
++  _dl_dprintf(2, "symtab_index %d\n", symtab_index);
++
++#ifdef __SUPPORT_LD_DEBUG__
++  if (_dl_debug_symbols) {
++	  _dl_dprintf(2, "Resolving symbol %s\n",
++			  strtab + symtab[symtab_index].st_name);
++  }
++#endif
++
++  /* Get the address of the GOT entry */
++  new_addr = _dl_find_hash(strtab + symtab[symtab_index].st_name, 
++  			tpnt->symbol_scope, tpnt, resolver);
++  if(!new_addr) {
++    _dl_dprintf(2, "%s: can't resolve symbol '%s'\n",
++	       _dl_progname, strtab + symtab[symtab_index].st_name);
++    _dl_exit(31);
++  };
++
++#if defined (__SUPPORT_LD_DEBUG__)
++	if ((unsigned long) got_addr < 0x40000000)
++	{
++		if (_dl_debug_bindings)
++		{
++			_dl_dprintf(_dl_debug_file, "\nresolve function: %s",
++					strtab + symtab[symtab_index].st_name);
++			if(_dl_debug_detail) _dl_dprintf(_dl_debug_file, 
++					"\tpatch %x ==> %x @ %x", *got_addr, new_addr, got_addr);
++		}
++	}
++	if (!_dl_debug_nofixups) {
++		got_addr[1] = (char *) (0x03000000 | (((unsigned int) new_addr >> 10) & 0x3fffff));
++		got_addr[2] = (char *) (0x81c06000 | ((unsigned int) new_addr & 0x3ff));
++	}
++#else
++	got_addr[1] = (char *) (0x03000000 | (((unsigned int) new_addr >> 10) & 0x3fffff));
++	got_addr[2] = (char *) (0x81c06000 | ((unsigned int) new_addr & 0x3ff));
++#endif
++
++	_dl_dprintf(2, "Address = %x\n",new_addr);
++	_dl_exit(32);
++
++  return (unsigned int) new_addr;
++}
++
++void _dl_parse_lazy_relocation_information(struct elf_resolve * tpnt, int rel_addr,
++       int rel_size, int type){
++  int i;
++  char * strtab;
++  int reloc_type;
++  int symtab_index;
++  Elf32_Sym * symtab; 
++  Elf32_Rela * rpnt;
++  unsigned int * reloc_addr;
++
++  /* Now parse the relocation information */
++  rpnt = (Elf32_Rela *) (rel_addr + tpnt->loadaddr);
++
++  symtab =  (Elf32_Sym *) (tpnt->dynamic_info[DT_SYMTAB] + tpnt->loadaddr);
++  strtab = ( char *) (tpnt->dynamic_info[DT_STRTAB] + tpnt->loadaddr);
++
++  for(i=0; i< rel_size; i += sizeof(Elf32_Rela), rpnt++){
++    reloc_addr = (int *) (tpnt->loadaddr + (int)rpnt->r_offset);
++    reloc_type = ELF32_R_TYPE(rpnt->r_info);
++    symtab_index = ELF32_R_SYM(rpnt->r_info);
++
++    /* When the dynamic linker bootstrapped itself, it resolved some symbols.
++       Make sure we do not do them again */
++    if(!symtab_index && tpnt->libtype == program_interpreter) continue;
++    if(symtab_index && tpnt->libtype == program_interpreter &&
++       _dl_symbol(strtab + symtab[symtab_index].st_name))
++      continue;
++
++    switch(reloc_type){
++    case R_SPARC_NONE:
++      break;
++    case R_SPARC_JMP_SLOT:
++      break;
++    default:
++      _dl_dprintf(2, "%s: (LAZY) can't handle reloc type ", _dl_progname);
++#if defined (__SUPPORT_LD_DEBUG__)
++      _dl_dprintf(2, "%s ", _dl_reltypes[reloc_type]);
++#endif
++      if(symtab_index) _dl_dprintf(2, "'%s'\n",
++				  strtab + symtab[symtab_index].st_name);
++      _dl_exit(33);
++    };
++  };
++}
++
++int _dl_parse_relocation_information(struct elf_resolve * tpnt, int rel_addr,
++       int rel_size, int type){
++  int i;
++  char * strtab;
++  int reloc_type;
++  int goof = 0;
++  Elf32_Sym * symtab; 
++  Elf32_Rela * rpnt;
++  unsigned int * reloc_addr;
++  unsigned int symbol_addr;
++  int symtab_index;
++  /* Now parse the relocation information */
++
++  rpnt = (Elf32_Rela *) (rel_addr + tpnt->loadaddr);
++
++  symtab =  (Elf32_Sym *) (tpnt->dynamic_info[DT_SYMTAB] + tpnt->loadaddr);
++  strtab = ( char *) (tpnt->dynamic_info[DT_STRTAB] + tpnt->loadaddr);
++
++  for(i=0; i< rel_size; i+= sizeof(Elf32_Rela), rpnt++){
++    reloc_addr = (int *) (tpnt->loadaddr + (int)rpnt->r_offset);
++    reloc_type = ELF32_R_TYPE(rpnt->r_info);
++    symtab_index = ELF32_R_SYM(rpnt->r_info);
++    symbol_addr = 0;
++
++    if(!symtab_index && tpnt->libtype == program_interpreter) continue;
++
++    if(symtab_index) {
++
++      if(tpnt->libtype == program_interpreter && 
++	 _dl_symbol(strtab + symtab[symtab_index].st_name))
++	continue;
++
++      symbol_addr = (unsigned int) 
++	_dl_find_hash(strtab + symtab[symtab_index].st_name,
++			      tpnt->symbol_scope,
++		      (reloc_type == R_SPARC_JMP_SLOT ? tpnt : NULL), symbolrel);
++
++      if(!symbol_addr &&
++	 ELF32_ST_BIND(symtab [symtab_index].st_info) == STB_GLOBAL) {
++	_dl_dprintf(2, "%s: can't resolve symbol '%s'\n",
++		     _dl_progname, strtab + symtab[symtab_index].st_name);
++	goof++;
++      };
++    };
++    switch(reloc_type){
++    case R_SPARC_NONE:
++	break;
++    case R_SPARC_32:
++      *reloc_addr = symbol_addr + rpnt->r_addend;
++      break;
++    case R_SPARC_DISP32:
++      *reloc_addr = symbol_addr + rpnt->r_addend - (unsigned int) reloc_addr;
++      break;
++    case R_SPARC_GLOB_DAT:
++      *reloc_addr = symbol_addr + rpnt->r_addend;
++      break;
++    case R_SPARC_JMP_SLOT:
++      reloc_addr[1] = 0x03000000 | ((symbol_addr >> 10) & 0x3fffff);
++      reloc_addr[2] = 0x81c06000 | (symbol_addr & 0x3ff);
++      break;
++    case R_SPARC_RELATIVE:
++      *reloc_addr += (unsigned int) tpnt->loadaddr + rpnt->r_addend;
++      break;
++    case R_SPARC_HI22:
++      if (!symbol_addr)
++        symbol_addr = tpnt->loadaddr + rpnt->r_addend;
++      else
++	symbol_addr += rpnt->r_addend;
++      *reloc_addr = (*reloc_addr & 0xffc00000)|(symbol_addr >> 10);
++      break;
++    case R_SPARC_LO10:
++      if (!symbol_addr)
++        symbol_addr = tpnt->loadaddr + rpnt->r_addend;
++      else
++	symbol_addr += rpnt->r_addend;
++      *reloc_addr = (*reloc_addr & ~0x3ff)|(symbol_addr & 0x3ff);
++      break;
++    case R_SPARC_WDISP30:
++      *reloc_addr = (*reloc_addr & 0xc0000000)|
++	((symbol_addr - (unsigned int) reloc_addr) >> 2);
++      break;
++    case R_SPARC_COPY:
++#if 0 /* This one is done later */
++      _dl_dprintf(2, "Doing copy for symbol ");
++      if(symtab_index) _dl_dprintf(2, strtab + symtab[symtab_index].st_name);
++      _dl_dprintf(2, "\n");
++      _dl_memcpy((void *) symtab[symtab_index].st_value,
++		 (void *) symbol_addr, 
++		 symtab[symtab_index].st_size);
++#endif
++      break;
++    default:
++      _dl_dprintf(2, "%s: can't handle reloc type ", _dl_progname);
++#if defined (__SUPPORT_LD_DEBUG__)
++      _dl_dprintf(2, "%s ", _dl_reltypes[reloc_type]);
++#endif
++      if (symtab_index)
++	_dl_dprintf(2, "'%s'\n", strtab + symtab[symtab_index].st_name);
++      _dl_exit(34);
++    };
++
++  };
++  return goof;
++}
++
++
++/* This is done as a separate step, because there are cases where
++   information is first copied and later initialized.  This results in
++   the wrong information being copied.  Someone at Sun was complaining about
++   a bug in the handling of _COPY by SVr4, and this may in fact be what he
++   was talking about.  Sigh. */
++
++/* No, there are cases where the SVr4 linker fails to emit COPY relocs
++   at all */
++
++int _dl_parse_copy_information(struct dyn_elf * xpnt, int rel_addr,
++       int rel_size, int type)
++{
++  int i;
++  char * strtab;
++  int reloc_type;
++  int goof = 0;
++  Elf32_Sym * symtab; 
++  Elf32_Rela * rpnt;
++  unsigned int * reloc_addr;
++  unsigned int symbol_addr;
++  struct elf_resolve *tpnt;
++  int symtab_index;
++  /* Now parse the relocation information */
++
++  tpnt = xpnt->dyn;
++  
++  rpnt = (Elf32_Rela *) (rel_addr + tpnt->loadaddr);
++
++  symtab =  (Elf32_Sym *) (tpnt->dynamic_info[DT_SYMTAB] + tpnt->loadaddr);
++  strtab = ( char *) (tpnt->dynamic_info[DT_STRTAB] + tpnt->loadaddr);
++
++  for(i=0; i< rel_size; i+= sizeof(Elf32_Rela), rpnt++){
++    reloc_addr = (int *) (tpnt->loadaddr + (int)rpnt->r_offset);
++    reloc_type = ELF32_R_TYPE(rpnt->r_info);
++    if(reloc_type != R_SPARC_COPY) continue;
++    symtab_index = ELF32_R_SYM(rpnt->r_info);
++    symbol_addr = 0;
++    if(!symtab_index && tpnt->libtype == program_interpreter) continue;
++    if(symtab_index) {
++
++      if(tpnt->libtype == program_interpreter && 
++	 _dl_symbol(strtab + symtab[symtab_index].st_name))
++	continue;
++
++      symbol_addr = (unsigned int) 
++	_dl_find_hash(strtab + symtab[symtab_index].st_name,
++			      xpnt->next, NULL, copyrel);
++      if(!symbol_addr) {
++	_dl_dprintf(2, "%s: can't resolve symbol '%s'\n",
++		   _dl_progname, strtab + symtab[symtab_index].st_name);
++	goof++;
++      };
++    };
++    if (!goof)
++      _dl_memcpy((char *) symtab[symtab_index].st_value, 
++		  (char *) symbol_addr, 
++		  symtab[symtab_index].st_size);
++  };
++  return goof;
++}
++
++
+diff -urN uClibc/ldso-0.9.24/ldso/sparc/ld_syscalls.h uClibc.ldso.24/ldso-0.9.24/ldso/sparc/ld_syscalls.h
+--- uClibc/ldso-0.9.24/ldso/sparc/ld_syscalls.h	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/sparc/ld_syscalls.h	2002-03-19 04:43:35.000000000 -0600
+@@ -0,0 +1,155 @@
++/*
++ * This file contains the system call macros and syscall 
++ * numbers used by the shared library loader.
++ */
++
++#define __NR_exit		  1
++#define __NR_read		  3
++#define __NR_write		  4
++#define __NR_open		  5
++#define __NR_close		  6
++#define __NR_getuid		 24
++#define __NR_getgid		 47
++#define __NR_geteuid		 49
++#define __NR_getegid		 50
++#define __NR_readlink            58
++#define __NR_mmap		 71
++#define __NR_munmap		 73
++#define __NR_stat		 38
++#define __NR_mprotect		 74
++
++/* Here are the macros which define how this platform makes
++ * system calls.  This particular variant does _not_ set 
++ * errno (note how it is disabled in __syscall_return) since
++ * these will get called before the errno symbol is dynamicly 
++ * linked. */
++
++#define _syscall0(type,name) \
++type name(void) \
++{ \
++long __res; \
++register long __g1 __asm__ ("g1") = __NR_##name; \
++__asm__ __volatile__ ("t 0x10\n\t" \
++		      "bcc 1f\n\t" \
++		      "mov %%o0, %0\n\t" \
++		      "sub %%g0, %%o0, %0\n\t" \
++		      "1:\n\t" \
++		      : "=r" (__res)\
++		      : "r" (__g1) \
++		      : "o0", "cc"); \
++if (__res < -255 || __res >= 0) \
++    return (type) __res; \
++/*errno = -__res; */\
++return -1; \
++}
++
++#define _syscall1(type,name,type1,arg1) \
++type name(type1 arg1) \
++{ \
++long __res; \
++register long __g1 __asm__ ("g1") = __NR_##name; \
++register long __o0 __asm__ ("o0") = (long)(arg1); \
++__asm__ __volatile__ ("t 0x10\n\t" \
++		      "bcc 1f\n\t" \
++		      "mov %%o0, %0\n\t" \
++		      "sub %%g0, %%o0, %0\n\t" \
++		      "1:\n\t" \
++		      : "=r" (__res), "=&r" (__o0) \
++		      : "1" (__o0), "r" (__g1) \
++		      : "cc"); \
++if (__res < -255 || __res >= 0) \
++	return (type) __res; \
++/*errno = -__res;*/ \
++return -1; \
++}
++
++#define _syscall2(type,name,type1,arg1,type2,arg2) \
++type name(type1 arg1,type2 arg2) \
++{ \
++long __res; \
++register long __g1 __asm__ ("g1") = __NR_##name; \
++register long __o0 __asm__ ("o0") = (long)(arg1); \
++register long __o1 __asm__ ("o1") = (long)(arg2); \
++__asm__ __volatile__ ("t 0x10\n\t" \
++		      "bcc 1f\n\t" \
++		      "mov %%o0, %0\n\t" \
++		      "sub %%g0, %%o0, %0\n\t" \
++		      "1:\n\t" \
++		      : "=r" (__res), "=&r" (__o0) \
++		      : "1" (__o0), "r" (__o1), "r" (__g1) \
++		      : "cc"); \
++if (__res < -255 || __res >= 0) \
++	return (type) __res; \
++/*errno = -__res;*/ \
++return -1; \
++}
++
++#define _syscall3(type,name,type1,arg1,type2,arg2,type3,arg3) \
++type name(type1 arg1,type2 arg2,type3 arg3) \
++{ \
++long __res; \
++register long __g1 __asm__ ("g1") = __NR_##name; \
++register long __o0 __asm__ ("o0") = (long)(arg1); \
++register long __o1 __asm__ ("o1") = (long)(arg2); \
++register long __o2 __asm__ ("o2") = (long)(arg3); \
++__asm__ __volatile__ ("t 0x10\n\t" \
++		      "bcc 1f\n\t" \
++		      "mov %%o0, %0\n\t" \
++		      "sub %%g0, %%o0, %0\n\t" \
++		      "1:\n\t" \
++		      : "=r" (__res), "=&r" (__o0) \
++		      : "1" (__o0), "r" (__o1), "r" (__o2), "r" (__g1) \
++		      : "cc"); \
++if (__res < -255 || __res>=0) \
++	return (type) __res; \
++/*errno = -__res;*/ \
++return -1; \
++}
++
++#define _syscall4(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4) \
++type name (type1 arg1, type2 arg2, type3 arg3, type4 arg4) \
++{ \
++long __res; \
++register long __g1 __asm__ ("g1") = __NR_##name; \
++register long __o0 __asm__ ("o0") = (long)(arg1); \
++register long __o1 __asm__ ("o1") = (long)(arg2); \
++register long __o2 __asm__ ("o2") = (long)(arg3); \
++register long __o3 __asm__ ("o3") = (long)(arg4); \
++__asm__ __volatile__ ("t 0x10\n\t" \
++		      "bcc 1f\n\t" \
++		      "mov %%o0, %0\n\t" \
++		      "sub %%g0, %%o0, %0\n\t" \
++		      "1:\n\t" \
++		      : "=r" (__res), "=&r" (__o0) \
++		      : "1" (__o0), "r" (__o1), "r" (__o2), "r" (__o3), "r" (__g1) \
++		      : "cc"); \
++if (__res < -255 || __res>=0) \
++	return (type) __res; \
++/*errno = -__res;*/ \
++return -1; \
++} 
++
++#define _syscall5(type,name,type1,arg1,type2,arg2,type3,arg3,type4,arg4, \
++	  type5,arg5) \
++type name (type1 arg1,type2 arg2,type3 arg3,type4 arg4,type5 arg5) \
++{ \
++long __res; \
++register long __g1 __asm__ ("g1") = __NR_##name; \
++register long __o0 __asm__ ("o0") = (long)(arg1); \
++register long __o1 __asm__ ("o1") = (long)(arg2); \
++register long __o2 __asm__ ("o2") = (long)(arg3); \
++register long __o3 __asm__ ("o3") = (long)(arg4); \
++register long __o4 __asm__ ("o4") = (long)(arg5); \
++__asm__ __volatile__ ("t 0x10\n\t" \
++		      "bcc 1f\n\t" \
++		      "mov %%o0, %0\n\t" \
++		      "sub %%g0, %%o0, %0\n\t" \
++		      "1:\n\t" \
++		      : "=r" (__res), "=&r" (__o0) \
++		      : "1" (__o0), "r" (__o1), "r" (__o2), "r" (__o3), "r" (__o4), "r" (__g1) \
++		      : "cc"); \
++if (__res < -255 || __res>=0) \
++	return (type) __res; \
++/*errno = -__res; */\
++return -1; \
++}
+diff -urN uClibc/ldso-0.9.24/ldso/sparc/ld_sysdep.h uClibc.ldso.24/ldso-0.9.24/ldso/sparc/ld_sysdep.h
+--- uClibc/ldso-0.9.24/ldso/sparc/ld_sysdep.h	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/sparc/ld_sysdep.h	2002-08-09 08:05:29.000000000 -0500
+@@ -0,0 +1,112 @@
++
++/*
++ * Various assmbly language/system dependent  hacks that are required
++ * so that we can minimize the amount of platform specific code.
++ */
++#define LINUXBIN
++
++/*
++ * Define this if the system uses RELOCA.
++ */
++#define ELF_USES_RELOCA
++
++/*
++ * Get a pointer to the argv array.  On many platforms this can be just
++ * the address if the first argument, on other platforms we need to
++ * do something a little more subtle here.  We assume that argc is stored
++ * at the word just below the argvp that we return here.
++ */
++#define GET_ARGV(ARGVP, ARGS) __asm__("\tadd %%fp,68,%0\n" : "=r" (ARGVP));
++
++/*
++ * Initialization sequence for a GOT.  For the Sparc, this points to the
++ * PLT, and we need to initialize a couple of the slots.  The PLT should
++ * look like:
++ *
++ *		save %sp, -64, %sp
++ *		call _dl_linux_resolve
++ *		nop
++ *		.word implementation_dependent
++ */
++#define INIT_GOT(GOT_BASE,MODULE) \
++{				\
++   GOT_BASE[0] = 0x9de3bfc0;  /* save %sp, -64, %sp */	\
++   GOT_BASE[1] = 0x40000000 | (((unsigned int) _dl_linux_resolve - (unsigned int) GOT_BASE - 4) >> 2);	\
++   GOT_BASE[2] = 0x01000000; /* nop */ 			\
++   GOT_BASE[3] = (int) MODULE;					\
++}
++
++/*
++ * Here is a macro to perform a relocation.  This is only used when
++ * bootstrapping the dynamic loader.
++ */
++#define PERFORM_BOOTSTRAP_RELOC(RELP,REL,SYMBOL,LOAD) \
++	switch(ELF32_R_TYPE((RELP)->r_info)) {		\
++	case R_SPARC_32:				\
++	  *REL = SYMBOL + (RELP)->r_addend;		\
++	  break;					\
++	case R_SPARC_GLOB_DAT:				\
++	  *REL = SYMBOL + (RELP)->r_addend;		\
++	  break;					\
++	case R_SPARC_JMP_SLOT:				\
++	  REL[1] = 0x03000000 | ((SYMBOL >> 10) & 0x3fffff);	\
++	  REL[2] = 0x81c06000 | (SYMBOL & 0x3ff);	\
++	  break;					\
++	case R_SPARC_NONE:				\
++	  break;					\
++        case R_SPARC_WDISP30:				\
++          break;                                        \
++	case R_SPARC_RELATIVE:				\
++	  *REL += (unsigned int) LOAD + (RELP)->r_addend; \
++	  break;					\
++	default:					\
++	  _dl_exit(1);					\
++	}
++
++
++/*
++ * Transfer control to the user's application, once the dynamic loader
++ * is done.  The crt calls atexit with $g1 if not null, so we need to
++ * ensure that it contains NULL.
++ */
++
++#define START()		\
++	__asm__ volatile ( \
++	                   "add %%g0,%%g0,%%g1\n\t" \
++			   "jmpl %0, %%o7\n\t"	\
++			   "restore %%g0,%%g0,%%g0\n\t" \
++		    	: /*"=r" (status) */ :	\
++		    	  "r" (_dl_elf_main): "g1", "o0", "o1")
++
++
++
++/* Here we define the magic numbers that this dynamic loader should accept */
++
++#define MAGIC1 EM_SPARC
++#undef  MAGIC2
++/* Used for error messages */
++#define ELF_TARGET "Sparc"
++
++#ifndef COMPILE_ASM
++extern unsigned int _dl_linux_resolver(unsigned int reloc_entry,
++					unsigned int * i);
++#endif
++
++/*
++ * Define this if you want a dynamic loader that works on Solaris.
++ */
++#define SOLARIS_COMPATIBLE
++
++#define do_rem(result, n, base)	    result = (n % base)
++
++/*
++ * dbx wants the binder to have a specific name.  Mustn't disappoint it.
++ */
++#ifdef SOLARIS_COMPATIBLE
++#define _dl_linux_resolve _elf_rtbndr
++#endif
++
++/* 4096 bytes alignment */
++#define PAGE_ALIGN 0xfffff000
++#define ADDR_ALIGN 0xfff
++#define OFFS_ALIGN 0x7ffff000
+diff -urN uClibc/ldso-0.9.24/ldso/sparc/resolve.S uClibc.ldso.24/ldso-0.9.24/ldso/sparc/resolve.S
+--- uClibc/ldso-0.9.24/ldso/sparc/resolve.S	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/ldso/sparc/resolve.S	2002-01-11 13:57:41.000000000 -0600
+@@ -0,0 +1,25 @@
++/*
++ * These are various helper routines that are needed to run an ELF image.
++ */
++#define COMPILE_ASM
++#include "ld_sysdep.h"
++
++.text
++	.align 16
++
++.globl _dl_linux_resolve
++_dl_linux_resolve:
++	/*
++ 	 * Call the resolver - pass the address of the PLT so that we can
++	 * figure out which module we are in.
++	 */
++	mov %o7,%o1
++	call  _dl_linux_resolver
++	mov %g1,%o0
++
++	jmpl %o0,%o7
++	restore
++.LFE2:
++
++	.type	_dl_linux_resolve,#function
++	.size _dl_linux_resolve,.LFE2-_dl_linux_resolve
+diff -urN uClibc/ldso-0.9.24/libdl/.cvsignore uClibc.ldso.24/ldso-0.9.24/libdl/.cvsignore
+--- uClibc/ldso-0.9.24/libdl/.cvsignore	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/libdl/.cvsignore	2001-04-26 11:12:47.000000000 -0500
+@@ -0,0 +1,2 @@
++libdl.so*
++
+diff -urN uClibc/ldso-0.9.24/libdl/Makefile uClibc.ldso.24/ldso-0.9.24/libdl/Makefile
+--- uClibc/ldso-0.9.24/libdl/Makefile	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/libdl/Makefile	2004-03-01 03:05:53.000000000 -0600
+@@ -0,0 +1,86 @@
++# Makefile for uClibc
++#
++# Copyright (C) 2000 by Lineo, inc.
++# Copyright (C) 2000-2002 Erik Andersen <andersen@uclibc.org>
++#
++# This program 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.
++#
++# 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 Library General Public License for more
++# details.
++#
++# You should have received a copy of the GNU Library 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
++
++
++TOPDIR=../../
++include $(TOPDIR)Rules.mak
++
++XXFLAGS=$(XWARNINGS) $(OPTIMIZATION) $(XARCH_CFLAGS) $(CPU_CFLAGS) \
++	-DUCLIBC_RUNTIME_PREFIX=\"$(RUNTIME_PREFIX)\" \
++	-fno-builtin -nostdinc -D_LIBC -I$(TOPDIR)ldso-0.9.24/include -I. -I$(TOPDIR)include
++
++ifeq ($(DODEBUG),y)
++XXFLAGS=$(XWARNINGS) -O0 -g3 $(XARCH_CFLAGS) $(CPU_CFLAGS) \
++	-DUCLIBC_RUNTIME_PREFIX=\"$(RUNTIME_PREFIX)\" \
++	-fno-builtin -nostdinc -D_LIBC -I$(TOPDIR)ldso-0.9.24/include -I. -I$(TOPDIR)include
++endif
++
++XXFLAGS+=$(shell $(CC) -print-search-dirs | sed -ne "s/install: *\(.*\)/-I\1include/gp")
++XXFLAGS_NOPIC:=$(XXFLAGS)
++ifeq ($(DOPIC),y)
++    XXFLAGS += $(PICFLAG) -D__LIBDL_SHARED__
++endif
++ifeq ($(strip $(SUPPORT_LD_DEBUG)),y)
++XXFLAGS+=-D__SUPPORT_LD_DEBUG__
++endif
++
++LIBDL=libdl.a
++LIBDL_PIC=libdl_pic.a
++LIBDL_SHARED=libdl.so
++LIBDL_SHARED_FULLNAME=libdl-$(MAJOR_VERSION).$(MINOR_VERSION).$(SUBLEVEL).so
++
++CSRC=dlib.c
++OBJS=dlib.o
++PIC_OBJS=dlib_pic.o
++
++all: $(OBJS) $(LIBDL) shared
++
++$(LIBDL): ar-target
++
++ar-target: $(OBJS) $(PIC_OBJS)
++	$(AR) $(ARFLAGS) $(LIBDL) ../ldso/$(TARGET_ARCH)/resolve.o $(OBJS)
++	$(AR) $(ARFLAGS) $(LIBDL_PIC) $(PIC_OBJS)
++	$(INSTALL) -d $(TOPDIR)lib
++	$(RM) $(TOPDIR)lib/$(LIBDL)
++	$(INSTALL) -m 644 $(LIBDL) $(TOPDIR)lib
++
++
++dlib.o: dlib.c
++	$(CC) $(XXFLAGS_NOPIC) -c dlib.c -o dlib.o
++	$(STRIPTOOL) -x -R .note -R .comment $*.o
++
++dlib_pic.o: dlib.c
++	$(CC) $(XXFLAGS) -c dlib.c -o dlib_pic.o
++	$(STRIPTOOL) -x -R .note -R .comment $*.o
++
++$(OBJ): Makefile
++
++shared:
++	$(LD) $(LDFLAGS) -soname=$(LIBDL_SHARED).$(MAJOR_VERSION) \
++		-o $(LIBDL_SHARED_FULLNAME) --whole-archive $(LIBDL_PIC) \
++		--no-whole-archive $(TOPDIR)/libc/misc/internals/interp.o \
++		-L$(TOPDIR)/lib -lc $(LDADD_LIBFLOAT) $(LIBGCC);
++	$(INSTALL) -d $(TOPDIR)lib
++	$(RM) $(TOPDIR)lib/$(LIBDL_SHARED_FULLNAME) $(TOPDIR)lib/$(LIBDL_SHARED).$(MAJOR_VERSION)
++	$(INSTALL) -m 644 $(LIBDL_SHARED_FULLNAME) $(TOPDIR)lib
++	$(LN) -sf $(LIBDL_SHARED_FULLNAME) $(TOPDIR)lib/$(LIBDL_SHARED)
++	$(LN) -sf $(LIBDL_SHARED_FULLNAME) $(TOPDIR)lib/$(LIBDL_SHARED).$(MAJOR_VERSION)
++
++clean:
++	$(RM) .depend $(LIBDL_SHARED)* $(LIBDL_SHARED_FULLNAME) core *.o *.a *.s *.i tmp_make foo *~
+diff -urN uClibc/ldso-0.9.24/libdl/dlib.c uClibc.ldso.24/ldso-0.9.24/libdl/dlib.c
+--- uClibc/ldso-0.9.24/libdl/dlib.c	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/libdl/dlib.c	2004-03-01 03:04:42.000000000 -0600
+@@ -0,0 +1,664 @@
++/*
++ * libdl.c
++ * 
++ * Functions required for dlopen et. al.
++ */
++
++#include <ldso.h>
++
++
++/* The public interfaces */
++void *dlopen(const char *, int) __attribute__ ((__weak__, __alias__ ("_dlopen")));
++int dlclose(void *) __attribute__ ((__weak__, __alias__ ("_dlclose")));
++void *dlsym(void *, const char *) __attribute__ ((__weak__, __alias__ ("_dlsym")));
++const char *dlerror(void) __attribute__ ((__weak__, __alias__ ("_dlerror")));
++int dladdr(void *, Dl_info *) __attribute__ ((__weak__, __alias__ ("_dladdr")));
++void _dlinfo(void);
++
++
++#ifdef __LIBDL_SHARED__
++/* This is a real hack.  We need access to the dynamic linker, but we
++also need to make it possible to link against this library without any
++unresolved externals.  We provide these weak symbols to make the link
++possible, but at run time the normal symbols are accessed. */
++static void __attribute__ ((unused)) foobar(void)
++{
++	const char msg[]="libdl library not correctly linked\n";
++	_dl_write(2, msg, _dl_strlen(msg));
++	_dl_exit(1);
++}
++
++static int __attribute__ ((unused)) foobar1 = (int) foobar;	/* Use as pointer */
++extern void _dl_dprintf(int, const char *, ...) __attribute__ ((__weak__, __alias__ ("foobar")));
++extern char *_dl_find_hash(const char *, struct dyn_elf *, struct elf_resolve *, enum caller_type)
++	__attribute__ ((__weak__, __alias__ ("foobar")));
++extern struct elf_resolve * _dl_load_shared_library(int, struct dyn_elf **, struct elf_resolve *, char *)
++	__attribute__ ((__weak__, __alias__ ("foobar")));
++extern struct elf_resolve * _dl_check_if_named_library_is_loaded(const char *full_libname)
++	__attribute__ ((__weak__, __alias__ ("foobar")));
++extern int _dl_fixup(struct elf_resolve *tpnt, int lazy)
++	 __attribute__ ((__weak__, __alias__ ("foobar")));
++extern int _dl_copy_fixups(struct dyn_elf * tpnt)
++	 __attribute__ ((__weak__, __alias__ ("foobar")));
++#ifdef __mips__
++extern void _dl_perform_mips_global_got_relocations(struct elf_resolve *tpnt)
++	__attribute__ ((__weak__, __alias__ ("foobar")));
++#endif
++#ifdef USE_CACHE
++int _dl_map_cache(void) __attribute__ ((__weak__, __alias__ ("foobar")));
++int _dl_unmap_cache(void) __attribute__ ((__weak__, __alias__ ("foobar")));
++#endif	
++
++extern struct dyn_elf *_dl_symbol_tables __attribute__ ((__weak__, __alias__ ("foobar1")));
++extern struct dyn_elf *_dl_handles __attribute__ ((__weak__, __alias__ ("foobar1")));
++extern struct elf_resolve *_dl_loaded_modules __attribute__ ((__weak__, __alias__ ("foobar1")));
++extern struct r_debug *_dl_debug_addr __attribute__ ((__weak__, __alias__ ("foobar1")));
++extern unsigned long _dl_error_number __attribute__ ((__weak__, __alias__ ("foobar1")));
++extern void *(*_dl_malloc_function)(size_t) __attribute__ ((__weak__, __alias__ ("foobar1")));
++#ifdef __SUPPORT_LD_DEBUG__
++extern char *_dl_debug __attribute__ ((__weak__, __alias__ ("foobar1")));
++extern char *_dl_debug_symbols __attribute__ ((__weak__, __alias__ ("foobar1")));
++extern char *_dl_debug_move __attribute__ ((__weak__, __alias__ ("foobar1")));
++extern char *_dl_debug_reloc __attribute__ ((__weak__, __alias__ ("foobar1")));
++extern char *_dl_debug_detail __attribute__ ((__weak__, __alias__ ("foobar1")));
++extern char *_dl_debug_nofixups __attribute__ ((__weak__, __alias__ ("foobar1")));
++extern char *_dl_debug_bindings __attribute__ ((__weak__, __alias__ ("foobar1")));
++extern int   _dl_debug_file __attribute__ ((__weak__, __alias__ ("foobar1")));
++#endif
++
++#else	/* __LIBDL_SHARED__ */
++
++#ifdef __SUPPORT_LD_DEBUG__
++char *_dl_debug  = 0;
++char *_dl_debug_symbols = 0;
++char *_dl_debug_move    = 0;
++char *_dl_debug_reloc   = 0;
++char *_dl_debug_detail  = 0;
++char *_dl_debug_nofixups  = 0;
++char *_dl_debug_bindings  = 0;
++int   _dl_debug_file = 2;
++#endif
++char *_dl_library_path = 0;
++char *_dl_ldsopath = 0;
++struct r_debug *_dl_debug_addr = NULL;
++static char *_dl_malloc_addr, *_dl_mmap_zero;
++#include "../ldso/_dl_progname.h"               /* Pull in the name of ld.so */
++#include "../ldso/hash.c"
++#define _dl_trace_loaded_objects    0
++#include "../ldso/readelflib1.c"
++void *(*_dl_malloc_function) (size_t size);
++int _dl_fixup(struct elf_resolve *tpnt, int lazy);
++#endif
++
++static int do_dlclose(void *, int need_fini);
++
++
++static const char *dl_error_names[] = {
++	"",
++	"File not found",
++	"Unable to open /dev/zero",
++	"Not an ELF file",
++#if defined (__i386__)
++	"Not i386 binary",
++#elif defined (__sparc__)
++	"Not sparc binary",
++#elif defined (__mc68000__)
++	"Not m68k binary",
++#else
++	"Unrecognized binary type",
++#endif
++	"Not an ELF shared library",
++	"Unable to mmap file",
++	"No dynamic section",
++#ifdef ELF_USES_RELOCA
++	"Unable to process REL relocs",
++#else
++	"Unable to process RELA relocs",
++#endif
++	"Bad handle",
++	"Unable to resolve symbol"
++};
++
++static void __attribute__ ((destructor)) dl_cleanup(void)
++{
++	struct dyn_elf *d;
++
++	for (d = _dl_handles; d; d = d->next_handle)
++		if (d->dyn->libtype == loaded_file && d->dyn->dynamic_info[DT_FINI]) {
++			(* ((int (*)(void)) (d->dyn->loadaddr + d->dyn->dynamic_info[DT_FINI]))) ();
++			d->dyn->dynamic_info[DT_FINI] = 0;
++		}
++}
++
++void *_dlopen(const char *libname, int flag)
++{
++	struct elf_resolve *tpnt, *tfrom, *tcurr;
++	struct dyn_elf *dyn_chain, *rpnt = NULL;
++	struct dyn_elf *dpnt;
++	static int dl_init = 0;
++	ElfW(Addr) from;
++	struct elf_resolve *tpnt1;
++	void (*dl_brk) (void);
++
++	/* A bit of sanity checking... */
++	if (!(flag & (RTLD_LAZY|RTLD_NOW))) {
++		_dl_error_number = LD_BAD_HANDLE;
++		return NULL;
++	}
++
++	from = (ElfW(Addr)) __builtin_return_address(0);
++
++	/* Have the dynamic linker use the regular malloc function now */
++	if (!dl_init) {
++		dl_init++;
++		_dl_malloc_function = malloc;
++	}
++
++	/* Cover the trivial case first */
++	if (!libname)
++		return _dl_symbol_tables;
++
++	_dl_map_cache();
++
++	/*
++	 * Try and locate the module we were called from - we
++	 * need this so that we get the correct RPATH.  Note that
++	 * this is the current behavior under Solaris, but the
++	 * ABI+ specifies that we should only use the RPATH from
++	 * the application.  Thus this may go away at some time
++	 * in the future.
++	 */
++	tfrom = NULL;
++	for (dpnt = _dl_symbol_tables; dpnt; dpnt = dpnt->next) {
++		tpnt = dpnt->dyn;
++		if (tpnt->loadaddr < from
++				&& (tfrom == NULL || tfrom->loadaddr < tpnt->loadaddr))
++			tfrom = tpnt;
++	}
++
++	/* Try to load the specified library */
++#ifdef __SUPPORT_LD_DEBUG__
++	if(_dl_debug) 
++	_dl_dprintf(_dl_debug_file, "Trying to dlopen '%s'\n", (char*)libname);
++#endif
++	tpnt = _dl_load_shared_library(0, &rpnt, tfrom, (char*)libname);
++	if (tpnt == NULL) {
++		_dl_unmap_cache();
++		return NULL;
++	}
++
++	dyn_chain = (struct dyn_elf *) malloc(sizeof(struct dyn_elf));
++	_dl_memset(dyn_chain, 0, sizeof(struct dyn_elf));
++	dyn_chain->dyn = tpnt;
++	dyn_chain->flags = flag;
++	if (!tpnt->symbol_scope)
++		tpnt->symbol_scope = dyn_chain;
++
++	dyn_chain->next_handle = _dl_handles;
++	_dl_handles = rpnt = dyn_chain;
++
++	if (tpnt->init_flag & INIT_FUNCS_CALLED) {
++	    /* If the init and fini stuff has already been run, that means
++	     * the dlopen'd library has already been loaded, and nothing
++	     * further needs to be done. */
++	    return (void *) dyn_chain;
++	}
++
++
++#ifdef __SUPPORT_LD_DEBUG__
++	if(_dl_debug) 
++	_dl_dprintf(_dl_debug_file, "Looking for needed libraries\n");
++#endif
++
++	for (tcurr = tpnt; tcurr; tcurr = tcurr->next)
++	{
++		Elf32_Dyn *dpnt;
++		char *lpntstr;
++		for (dpnt = (Elf32_Dyn *) tcurr->dynamic_addr; dpnt->d_tag; dpnt++) {
++			if (dpnt->d_tag == DT_NEEDED) {
++
++				char *name;
++				lpntstr = (char*) (tcurr->loadaddr + tcurr->dynamic_info[DT_STRTAB] + 
++					dpnt->d_un.d_val);
++				name = _dl_get_last_path_component(lpntstr);
++
++#ifdef __SUPPORT_LD_DEBUG__
++				if(_dl_debug) 
++				_dl_dprintf(_dl_debug_file, "Trying to load '%s', needed by '%s'\n", 
++						lpntstr, tcurr->libname);
++#endif
++
++				if (!(tpnt1 = _dl_load_shared_library(0, &rpnt, tcurr, lpntstr))) {
++					goto oops;
++				}
++
++#if 1
++//FIXME:  Enabling this is _so_ wrong....
++				/* We need global symbol resolution for everything
++				 * in the dependent chain */
++				dyn_chain->flags |= RTLD_GLOBAL;
++#endif
++
++				rpnt->next = (struct dyn_elf *) malloc(sizeof(struct dyn_elf));
++				_dl_memset (rpnt->next, 0, sizeof (struct dyn_elf));
++				rpnt = rpnt->next;
++				if (!tpnt1->symbol_scope) tpnt1->symbol_scope = rpnt;
++				rpnt->dyn = tpnt1;
++
++			}
++		}
++	}
++
++	/*
++	 * OK, now attach the entire chain at the end
++	 */
++	rpnt->next = _dl_symbol_tables;
++
++#ifdef __mips__
++	/*
++	 * Relocation of the GOT entries for MIPS have to be done
++	 * after all the libraries have been loaded.
++	 */
++	_dl_perform_mips_global_got_relocations(tpnt);
++#endif
++
++#ifdef __SUPPORT_LD_DEBUG__
++	if(_dl_debug) 
++	_dl_dprintf(_dl_debug_file, "Beginning dlopen relocation fixups\n");
++#endif
++	/*
++	 * OK, now all of the kids are tucked into bed in their proper addresses.
++	 * Now we go through and look for REL and RELA records that indicate fixups
++	 * to the GOT tables.  We need to do this in reverse order so that COPY
++	 * directives work correctly */
++	if (_dl_fixup(dyn_chain->dyn, dyn_chain->flags))
++		goto oops;
++
++#ifdef __SUPPORT_LD_DEBUG__
++	if(_dl_debug) 
++	_dl_dprintf(_dl_debug_file, "Beginning dlopen copy fixups\n");
++#endif
++	if (_dl_symbol_tables) {
++		if (_dl_copy_fixups(dyn_chain))
++			goto oops;
++	}
++
++
++	/* TODO:  Should we set the protections of all pages back to R/O now ? */
++	
++
++	/* Notify the debugger we have added some objects. */
++	_dl_debug_addr->r_state = RT_ADD;
++	if (_dl_debug_addr) {
++		dl_brk = (void (*)(void)) _dl_debug_addr->r_brk;
++		if (dl_brk != NULL) {
++			_dl_debug_addr->r_state = RT_ADD;
++			(*dl_brk) ();
++
++			_dl_debug_addr->r_state = RT_CONSISTENT;
++			(*dl_brk) ();
++		}
++	}
++
++#if 0 //def __SUPPORT_LD_DEBUG__
++	if(_dl_debug) 
++	_dlinfo();
++#endif
++
++#ifdef __LIBDL_SHARED__
++	/* Find the last library so we can run things in the right order */
++	for (tpnt = dyn_chain->dyn; tpnt->next!=NULL; tpnt = tpnt->next)
++	    ;
++
++	/* Run the ctors and set up the dtors */
++	for (; tpnt != dyn_chain->dyn->prev; tpnt=tpnt->prev)
++	{
++		/* Apparently crt1 for the application is responsible for handling this.
++		 * We only need to run the init/fini for shared libraries
++		 */
++		if (tpnt->libtype == program_interpreter)
++			continue;
++		if (tpnt->libtype == elf_executable)
++			continue;
++		if (tpnt->init_flag & INIT_FUNCS_CALLED)
++			continue;
++		tpnt->init_flag |= INIT_FUNCS_CALLED;
++
++		if (tpnt->dynamic_info[DT_INIT]) {
++		    void (*dl_elf_func) (void);
++		    dl_elf_func = (void (*)(void)) (tpnt->loadaddr + tpnt->dynamic_info[DT_INIT]);
++		    if (dl_elf_func && *dl_elf_func != NULL) {
++#ifdef __SUPPORT_LD_DEBUG__
++			if(_dl_debug) 
++			_dl_dprintf(2, "running ctors for library %s at '%x'\n", tpnt->libname, dl_elf_func);
++#endif
++			(*dl_elf_func) ();
++		    }
++		}
++		if (tpnt->dynamic_info[DT_FINI]) {
++		    void (*dl_elf_func) (void);
++		    dl_elf_func = (void (*)(void)) (tpnt->loadaddr + tpnt->dynamic_info[DT_FINI]);
++		    if (dl_elf_func && *dl_elf_func != NULL) {
++#ifdef __SUPPORT_LD_DEBUG__
++			if(_dl_debug) 
++			_dl_dprintf(2, "setting up dtors for library %s at '%x'\n", tpnt->libname, dl_elf_func);
++#endif
++			atexit(dl_elf_func);
++		    }
++		}
++	}
++#endif
++	return (void *) dyn_chain;
++
++oops:
++	/* Something went wrong.  Clean up and return NULL. */
++	_dl_unmap_cache();
++	do_dlclose(dyn_chain, 0);
++	return NULL;
++}
++
++void *_dlsym(void *vhandle, const char *name)
++{
++	struct elf_resolve *tpnt, *tfrom;
++	struct dyn_elf *handle;
++	ElfW(Addr) from;
++	struct dyn_elf *rpnt;
++	void *ret;
++
++	handle = (struct dyn_elf *) vhandle;
++
++	/* First of all verify that we have a real handle
++	   of some kind.  Return NULL if not a valid handle. */
++
++	if (handle == NULL)
++		handle = _dl_symbol_tables;
++	else if (handle != RTLD_NEXT && handle != _dl_symbol_tables) {
++		for (rpnt = _dl_handles; rpnt; rpnt = rpnt->next_handle)
++			if (rpnt == handle)
++				break;
++		if (!rpnt) {
++			_dl_error_number = LD_BAD_HANDLE;
++			return NULL;
++		}
++	} else if (handle == RTLD_NEXT) {
++		/*
++		 * Try and locate the module we were called from - we
++		 * need this so that we know where to start searching
++		 * from.  We never pass RTLD_NEXT down into the actual
++		 * dynamic loader itself, as it doesn't know
++		 * how to properly treat it.
++		 */
++		from = (ElfW(Addr)) __builtin_return_address(0);
++
++		tfrom = NULL;
++		for (rpnt = _dl_symbol_tables; rpnt; rpnt = rpnt->next) {
++			tpnt = rpnt->dyn;
++			if (tpnt->loadaddr < from
++				&& (tfrom == NULL || tfrom->loadaddr < tpnt->loadaddr)) {
++				tfrom = tpnt;
++				handle = rpnt->next;
++			}
++		}
++	}
++
++	ret = _dl_find_hash((char*)name, handle, NULL, copyrel);
++
++	/*
++	 * Nothing found.
++	 */
++	if (!ret)
++		_dl_error_number = LD_NO_SYMBOL;
++	return ret;
++}
++
++int _dlclose(void *vhandle)
++{
++	return do_dlclose(vhandle, 1);
++}
++
++static int do_dlclose(void *vhandle, int need_fini)
++{
++	struct dyn_elf *rpnt, *rpnt1;
++	struct dyn_elf *spnt, *spnt1;
++	ElfW(Phdr) *ppnt;
++	struct elf_resolve *tpnt;
++	int (*dl_elf_fini) (void);
++	void (*dl_brk) (void);
++	struct dyn_elf *handle;
++	unsigned int end;
++	int i = 0;
++
++	handle = (struct dyn_elf *) vhandle;
++	rpnt1 = NULL;
++	for (rpnt = _dl_handles; rpnt; rpnt = rpnt->next_handle) {
++		if (rpnt == handle) {
++			break;
++		}
++		rpnt1 = rpnt;
++	}
++
++	if (!rpnt) {
++		_dl_error_number = LD_BAD_HANDLE;
++		return 1;
++	}
++
++	/* OK, this is a valid handle - now close out the file.
++	 * We check if we need to call fini () on the handle. */
++	spnt = need_fini ? handle : handle->next;
++	for (; spnt; spnt = spnt1) {
++		spnt1 = spnt->next;
++
++		/* We appended the module list to the end - when we get back here, 
++		   quit. The access counts were not adjusted to account for being here. */
++		if (spnt == _dl_symbol_tables)
++			break;
++		if (spnt->dyn->usage_count == 1
++			&& spnt->dyn->libtype == loaded_file) {
++			tpnt = spnt->dyn;
++			/* Apparently crt1 for the application is responsible for handling this.
++			 * We only need to run the init/fini for shared libraries
++			 */
++
++			if (tpnt->dynamic_info[DT_FINI]) {
++				dl_elf_fini = (int (*)(void)) (tpnt->loadaddr + 
++					tpnt->dynamic_info[DT_FINI]);
++				(*dl_elf_fini) ();
++			}
++		}
++	}
++	if (rpnt1)
++		rpnt1->next_handle = rpnt->next_handle;
++	else
++		_dl_handles = rpnt->next_handle;
++
++	/* OK, this is a valid handle - now close out the file */
++	for (rpnt = handle; rpnt; rpnt = rpnt1) {
++		rpnt1 = rpnt->next;
++
++		/* We appended the module list to the end - when we get back here, 
++		   quit. The access counts were not adjusted to account for being here. */
++		if (rpnt == _dl_symbol_tables)
++			break;
++
++		rpnt->dyn->usage_count--;
++		if (rpnt->dyn->usage_count == 0
++			&& rpnt->dyn->libtype == loaded_file) {
++			tpnt = rpnt->dyn;
++			/* Apparently crt1 for the application is responsible for handling this.
++			 * We only need to run the init/fini for shared libraries
++			 */
++#if 0
++
++			/* We have to do this above, before we start closing objects.  
++			 * Otherwise when the needed symbols for _fini handling are 
++			 * resolved a coredump would occur. Rob Ryan (robr@cmu.edu)*/ 
++			if (tpnt->dynamic_info[DT_FINI]) { 
++			    dl_elf_fini = (int (*)(void)) (tpnt->loadaddr + tpnt->dynamic_info[DT_FINI]);
++				(*dl_elf_fini) ();
++			}
++#endif
++			end = 0;
++			for (i = 0, ppnt = rpnt->dyn->ppnt;
++				 i < rpnt->dyn->n_phent; ppnt++, i++) {
++				if (ppnt->p_type != PT_LOAD)
++					continue;
++				if (end < ppnt->p_vaddr + ppnt->p_memsz)
++					end = ppnt->p_vaddr + ppnt->p_memsz;
++			}
++			_dl_munmap((void*)rpnt->dyn->loadaddr, end);
++			/* Next, remove rpnt->dyn from the loaded_module list */
++			if (_dl_loaded_modules == rpnt->dyn) {
++				_dl_loaded_modules = rpnt->dyn->next;
++				if (_dl_loaded_modules)
++					_dl_loaded_modules->prev = 0;
++			} else
++				for (tpnt = _dl_loaded_modules; tpnt; tpnt = tpnt->next)
++					if (tpnt->next == rpnt->dyn) {
++						tpnt->next = tpnt->next->next;
++						if (tpnt->next)
++							tpnt->next->prev = tpnt;
++						break;
++					}
++			free(rpnt->dyn->libname);
++			free(rpnt->dyn);
++		}
++		free(rpnt);
++	}
++
++
++	if (_dl_debug_addr) {
++	    dl_brk = (void (*)(void)) _dl_debug_addr->r_brk;
++	    if (dl_brk != NULL) {
++		_dl_debug_addr->r_state = RT_DELETE;
++		(*dl_brk) ();
++
++		_dl_debug_addr->r_state = RT_CONSISTENT;
++		(*dl_brk) ();
++	    }
++	}
++
++	return 0;
++}
++
++const char *_dlerror(void)
++{
++	const char *retval;
++
++	if (!_dl_error_number)
++		return NULL;
++	retval = dl_error_names[_dl_error_number];
++	_dl_error_number = 0;
++	return retval;
++}
++
++/*
++ * Dump information to stderrr about the current loaded modules
++ */
++static char *type[] = { "Lib", "Exe", "Int", "Mod" };
++
++void _dlinfo(void)
++{
++	struct elf_resolve *tpnt;
++	struct dyn_elf *rpnt, *hpnt;
++
++	_dl_dprintf(2, "List of loaded modules\n");
++	/* First start with a complete list of all of the loaded files. */
++	for (tpnt = _dl_loaded_modules; tpnt; tpnt = tpnt->next) { 
++		_dl_dprintf(2, "\t%x %x %x %s %d %s\n", 
++			(unsigned) tpnt->loadaddr, (unsigned) tpnt,
++			(unsigned) tpnt->symbol_scope,
++			type[tpnt->libtype],
++			tpnt->usage_count, tpnt->libname);
++	}
++
++	/* Next dump the module list for the application itself */
++	_dl_dprintf(2, "\nModules for application (%x):\n",
++				 (unsigned) _dl_symbol_tables);
++	for (rpnt = _dl_symbol_tables; rpnt; rpnt = rpnt->next)
++		_dl_dprintf(2, "\t%x %s\n", (unsigned) rpnt->dyn, rpnt->dyn->libname);
++
++	for (hpnt = _dl_handles; hpnt; hpnt = hpnt->next_handle) {
++		_dl_dprintf(2, "Modules for handle %x\n", (unsigned) hpnt);
++		for (rpnt = hpnt; rpnt; rpnt = rpnt->next)
++			_dl_dprintf(2, "\t%x %s\n", (unsigned) rpnt->dyn, 
++				rpnt->dyn->libname);
++	}
++}
++
++int _dladdr(void *__address, Dl_info * __dlip)
++{
++	struct elf_resolve *pelf;
++	struct elf_resolve *rpnt;
++
++	_dl_map_cache();
++
++	/*
++	 * Try and locate the module address is in
++	 */
++	pelf = NULL;
++
++#if 0
++	_dl_dprintf(2, "dladdr( %x, %x )\n", __address, __dlip);
++#endif
++
++	for (rpnt = _dl_loaded_modules; rpnt; rpnt = rpnt->next) {
++		struct elf_resolve *tpnt;
++
++		tpnt = rpnt;
++#if 0
++		_dl_dprintf(2, "Module \"%s\" at %x\n", 
++			tpnt->libname, tpnt->loadaddr);
++#endif
++		if (tpnt->loadaddr < (ElfW(Addr)) __address
++			&& (pelf == NULL || pelf->loadaddr < tpnt->loadaddr)) {
++		    pelf = tpnt;
++		}
++	}
++
++	if (!pelf) {
++		return 0;
++	}
++
++	/*
++	 * Try and locate the symbol of address
++	 */
++
++	{
++		char *strtab;
++		Elf32_Sym *symtab;
++		int hn, si;
++		int sf;
++		int sn = 0;
++		ElfW(Addr) sa;
++
++		sa = 0;
++		symtab = (Elf32_Sym *) (pelf->dynamic_info[DT_SYMTAB] + pelf->loadaddr);
++		strtab = (char *) (pelf->dynamic_info[DT_STRTAB] + pelf->loadaddr);
++
++		sf = 0;
++		for (hn = 0; hn < pelf->nbucket; hn++) {
++			for (si = pelf->elf_buckets[hn]; si; si = pelf->chains[si]) {
++				ElfW(Addr) symbol_addr;
++
++				symbol_addr = pelf->loadaddr + symtab[si].st_value;
++				if (symbol_addr <= (ElfW(Addr))__address && (!sf || sa < symbol_addr)) {
++					sa = symbol_addr;
++					sn = si;
++					sf = 1;
++				}
++#if 0
++				_dl_dprintf(2, "Symbol \"%s\" at %x\n", 
++					strtab + symtab[si].st_name, symbol_addr);
++#endif
++			}
++		}
++
++		if (sf) {
++			__dlip->dli_fname = pelf->libname;
++			__dlip->dli_fbase = (void *)pelf->loadaddr;
++			__dlip->dli_sname = strtab + symtab[sn].st_name;
++			__dlip->dli_saddr = (void *)sa;
++		}
++		return 1;
++	}
++}
+diff -urN uClibc/ldso-0.9.24/man/Makefile uClibc.ldso.24/ldso-0.9.24/man/Makefile
+--- uClibc/ldso-0.9.24/man/Makefile	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/man/Makefile	2003-10-18 05:18:37.000000000 -0500
+@@ -0,0 +1,33 @@
++# Makefile for uClibc
++#
++# Copyright (C) 2000,2001 Erik Andersen <andersen@uclibc.org>
++#
++# This program 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.
++#
++# 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 Library General Public License for more
++# details.
++#
++# You should have received a copy of the GNU Library 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
++#
++# Derived in part from the Linux-8086 C library, the GNU C Library, and several
++# other sundry sources.  Files within this library are copyright by their
++# respective copyright holders.
++
++include ../Config.mk
++
++ALL = #ld.so.info
++
++all:	$(ALL)
++
++ld.so.info: ld.so.texi
++	makeinfo $<
++
++clean:
++	$(RM) $(ALL) *~
+diff -urN uClibc/ldso-0.9.24/man/dlopen.3 uClibc.ldso.24/ldso-0.9.24/man/dlopen.3
+--- uClibc/ldso-0.9.24/man/dlopen.3	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/man/dlopen.3	2001-04-23 12:43:54.000000000 -0500
+@@ -0,0 +1,218 @@
++.\" -*- nroff -*-
++.\" Copyright 1995 Yggdrasil Computing, Incorporated.
++.\" written by Adam J. Richter (adam@yggdrasil.com),
++.\" with typesetting help from Daniel Quinlan (quinlan@yggdrasil.com).
++.\"
++.\" This is free documentation; 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.
++.\"
++.\" The GNU General Public License's references to "object code"
++.\" and "executables" are to be interpreted as the output of any
++.\" document formatting or typesetting system, including
++.\" intermediate and printed output.
++.\"
++.\" This manual 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 manual; if not, write to the Free
++.\" Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139,
++.\" USA.
++.\"
++.TH DLOPEN 3 "16 May 1995" "Linux" "Linux Programmer's Manual"
++.SH NAME
++dlclose, dlerror, dlopen, dlsym \- Programming interface to dynamic linking loader.
++.SH SYNOPSIS
++.B #include <dlfcn.h>
++.sp
++.BI "void *dlopen (const char *" "filename" ", int " flag ");
++.br
++.BI "const char *dlerror(void);"
++.br
++.BI "void *dlsym(void *"handle ", char *"symbol ");"
++.br
++.BI "int dladdr(void *"address ", Dl_info *"dlip ");"
++.br
++.BI "int dlclose (void *"handle ");
++.sp
++Special symbols:
++.BR "_init" ", " "_fini" ". "
++.SH DESCRIPTION
++.B dlopen
++loads a dynamic library from the file named by the null terminated
++string
++.I filename
++and returns an opaque "handle" for the dynamic library.
++If
++.I filename
++is not an absolute path (i.e., it does not begin with a "/"), then the
++file is searched for in the following locations:
++.RS
++.PP
++A colon-separated list of directories in the user's
++\fBLD_LIBRARY\fP path environment variable.
++.PP
++The list of libraries specified in \fI/etc/ld.so.cache\fP.
++.PP
++\fI/usr/lib\fP, followed by \fI/lib\fP.
++.RE
++.PP
++If
++.I filename
++is a NULL pointer, then the returned handle is for the main program.
++.PP
++External references in the library are resolved using the libraries
++in that library's dependency list and any other libraries previously
++opened with the 
++.B RTLD_GLOBAL
++flag.
++If the executable was linked
++with the flag "-rdynamic", then the global symbols in the executable
++will also be used to resolve references in a dynamically loaded
++library.
++.PP
++.I flag
++must be either
++.BR RTLD_LAZY ,
++meaning resolve undefined symbols as code from the dynamic library is
++executed, or
++.BR RTLD_NOW ,
++meaning resolve all undefined symbols before
++.B dlopen
++returns, and fail if this cannot be done.
++Optionally,
++.B RTLD_GLOBAL
++may be or'ed with
++.IR flag,
++in which case the external symbols defined in the library will be
++made available to subsequently loaded libraries.
++.PP
++If the library exports a routine named
++.BR _init ,
++then that code is executed before dlopen returns.
++If the same library is loaded twice with
++.BR dlopen() ,
++the same file handle is returned.  The dl library maintains link
++counts for dynamic file handles, so a dynamic library is not
++deallocated until
++.B dlclose
++has been called on it as many times as
++.B dlopen
++has succeeded on it.
++.PP
++If
++.B dlopen
++fails for any reason, it returns NULL.
++A human readable string describing the most recent error that occurred
++from any of the dl routines (dlopen, dlsym or dlclose) can be
++extracted with
++.BR dlerror() .
++.B dlerror
++returns NULL if no errors have occurred since initialization or since
++it was last called.  (Calling
++.B dlerror()
++twice consecutively, will always result in the second call returning
++NULL.)
++
++.B dlsym
++takes a "handle" of a dynamic library returned by dlopen and the null
++terminated symbol name, returning the address where that symbol is
++loaded.  If the symbol is not found,
++.B dlsym
++returns NULL; however, the correct way to test for an error from
++.B dlsym
++is to save the result of
++.B dlerror
++into a variable, and then check if saved value is not NULL.
++This is because the value of the symbol could actually be NULL.
++It is also necessary to save the results of
++.B dlerror
++into a variable because if
++.B dlerror
++is called again, it will return NULL.
++.PP
++.B dladdr
++returns information about the shared library containing the memory 
++location specified by
++.IR address .
++.B dladdr
++returns zero on success and non-zero on error.
++.PP
++.B dlclose
++decrements the reference count on the dynamic library handle
++.IR handle .
++If the reference count drops to zero and no other loaded libraries use
++symbols in it, then the dynamic library is unloaded.  If the dynamic
++library exports a routine named
++.BR _fini ,
++then that routine is called just before the library is unloaded.
++.SH EXAMPLES
++.B Load the math library, and print the cosine of 2.0:
++.RS
++.nf
++.if t .ft CW
++#include <dlfcn.h>
++
++int main(int argc, char **argv) {
++    void *handle = dlopen ("/lib/libm.so", RTLD_LAZY);
++    double (*cosine)(double) = dlsym(handle, "cos");
++    printf ("%f\\n", (*cosine)(2.0));
++    dlclose(handle);
++}
++.if t .ft P
++.fi
++.PP
++If this program were in a file named "foo.c", you would build the program
++with the following command:
++.RS
++.LP
++gcc -rdynamic -o foo foo.c -ldl
++.RE
++.RE
++.LP
++.B Do the same thing, but check for errors at every step:
++.RS
++.nf
++.if t .ft CW
++#include <stdio.h>
++#include <dlfcn.h>
++
++int main(int argc, char **argv) {
++    void *handle;
++    double (*cosine)(double);
++    char *error;
++
++    handle = dlopen ("/lib/libm.so", RTLD_LAZY);
++    if (!handle) {
++        fputs (dlerror(), stderr);
++        exit(1);
++    }
++
++    cosine = dlsym(handle, "cos");
++    if ((error = dlerror()) != NULL)  {
++        fputs(error, stderr);
++        exit(1);
++    }
++
++    printf ("%f\\n", (*cosine)(2.0));
++    dlclose(handle);
++}
++.if t .ft P
++.fi
++.RE
++.SH ACKNOWLEDGEMENTS
++The dlopen interface standard comes from Solaris.
++The Linux dlopen implementation was primarily written by
++Eric Youngdale with help from Mitch D'Souza, David Engel,
++Hongjiu Lu, Andreas Schwab and others.
++The manual page was written by Adam Richter.
++.SH SEE ALSO
++.BR ld(1) ,
++.BR ld.so(8) ,
++.BR ldconfig(8) ,
++.BR ldd(1) ,
++.BR ld.so.info .
+diff -urN uClibc/ldso-0.9.24/man/ld.so.8 uClibc.ldso.24/ldso-0.9.24/man/ld.so.8
+--- uClibc/ldso-0.9.24/man/ld.so.8	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/man/ld.so.8	2001-04-23 12:43:54.000000000 -0500
+@@ -0,0 +1,113 @@
++.TH ld.so 8 "14 March 1998"
++.SH NAME
++ld.so/ld-linux.so \- dynamic linker/loader
++.SH DESCRIPTION
++.B ld.so
++loads the shared libraries needed by a program, prepares the program
++to run, and then runs it.
++Unless explicitly specified via the
++.B \-static
++option to
++.B ld
++during compilation, all Linux programs are incomplete and require 
++further linking at run time.
++.PP
++The necessary shared libraries needed by the program are searched for 
++in the following order
++.IP o
++Using the environment variable
++.B LD_LIBRARY_PATH
++.RB ( LD_AOUT_LIBRARY_PATH
++for a.out programs).
++Except if the executable is a setuid/setgid binary, in which case it
++is ignored.
++.IP o
++From the cache file
++.BR /etc/ld.so.cache
++which contains a compiled list of candidate libraries previously found
++in the augmented library path.
++.IP o
++In the default path
++.BR /usr/lib ,
++and then
++.BR /lib .
++.SH ENVIRONMENT
++.TP
++.B LD_LIBRARY_PATH
++A colon-separated list of directories in which to search for
++ELF libraries at execution-time.
++Similar to the 
++.B PATH
++environment variable.
++.TP
++.B LD_PRELOAD
++A whitespace-separated list of additional, user-specified, ELF shared 
++libraries to be loaded before all others.
++This can be used to selectively override functions in other shared libraries.
++For setuid/setgid ELF binaries, only libraries in the standard search
++directories that are also setgid will be loaded.
++.TP
++.B LD_TRACE_LOADED_OBJECTS
++If present, causes the program to list its dynamic library dependencies,
++as if run by ldd, instead of running normally.
++.TP
++.B LD_BIND_NOW
++If present, causes the dynamic linker to resolve all symbols at program
++startup instead of when they are first referenced.
++.TP
++.B LD_AOUT_LIBRARY_PATH
++A colon-separated list of directories in which to search for
++a.out libraries at execution-time.
++Similar to the 
++.B PATH
++environment variable.
++.TP
++.B LD_AOUT_PRELOAD
++The name of an additional, user-specified, a.out shared library to be loaded 
++after all others.
++This can be used to selectively override functions in other shared libraries.
++.TP
++.B LD_NOWARN
++Suppress warnings about a.out libraries with incompatible minor 
++version numbers.
++.TP
++.B LD_KEEPDIR
++Don't ignore the directory in the names of a.out libraries to be loaded.
++Use of this option is strongly discouraged.
++.SH FILES
++.PD 0
++.TP 20
++.B /lib/ld.so
++a.out dynamic linker/loader
++.TP 20
++.B /lib/ld-linux.so.*
++ELF dynamic linker/loader
++.TP
++.B /etc/ld.so.cache
++File containing a compiled list of directories in which to search for
++libraries and an ordered list of candidate libraries.
++.TP
++.B /etc/ld.so.preload
++File containing a whitespace separated list of ELF shared libraries to
++be loaded before the program.
++libraries and an ordered list of candidate libraries.
++.TP
++.B lib*.so*
++shared libraries
++.PD
++.SH SEE ALSO
++.BR ldd (1),
++.BR ldconfig (8).
++.SH BUGS
++.LP
++Currently
++.B ld.so
++has no means of unloading and searching for compatible or newer version of
++libraries.
++.PP
++.B ld.so
++functionality is only available for executables compiled using libc version
++4.4.3 or greater.
++.SH AUTHORS
++David Engel, Eric Youngdale, Peter MacDonald, Hongjiu Lu, Linus
++Torvalds, Lars Wirzenius and Mitch D'Souza (not necessarily in that order).
+diff -urN uClibc/ldso-0.9.24/man/ld.so.texi uClibc.ldso.24/ldso-0.9.24/man/ld.so.texi
+--- uClibc/ldso-0.9.24/man/ld.so.texi	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/man/ld.so.texi	2001-04-23 12:43:54.000000000 -0500
+@@ -0,0 +1,411 @@
++\input texinfo @c -*-texinfo-*-
++@c %**start of header
++@setfilename ld.so.info
++@settitle ld.so : Dynamic-Link Library support
++@c %**end of header
++
++@ifinfo
++This file documents the dynamic-link support libraries and utilities for the
++Linux OS, version 1.8.1.
++
++Copyright 1996 Michael Deutschmann
++
++This document is subject to the GNU General Public License as published by 
++the Free Software foundation, version 2 or later (your choice).
++
++Note: The software described in this document is under a different copyright
++and license.
++
++@end ifinfo
++
++@titlepage 
++@title ld.so
++@subtitle Dynamic Link library support for the Linux OS.
++@author David Engel
++@author Eric Youngdale
++@author Peter Macdonald 
++@author Hongjiu Lu 
++@author Mitch D'Souza
++@author Michael Deutschmann (this documentation)
++
++@page
++Copyright @copyright{} 1996 Michael Deutschmann
++
++This document is subject to the GNU General Public License as published by 
++the Free Software foundation, version 2 or later (your choice).
++
++Note: The software described in this document is under a different copyright
++and license.
++@end titlepage
++
++@ifinfo
++@node Top
++@top
++
++The @code{ld.so} module provides dynamic linked library support in Linux.
++This file documents @code{ld.so} and its companion software.
++
++@menu
++* intro::	Introduction
++
++* ld.so::	The dynamic linker core program
++* ldd::		A utility to print out dependencies
++* ldconfig::	A utility to maintain the cache and symlinks
++* libdl::	Manual dynamic linking library
++@end menu
++
++@end ifinfo
++
++@node intro
++@unnumbered Introduction
++
++The @code{ld.so} suite contains special files and utilities needed for linux
++to handle @dfn{dynamic libraries}.
++
++Ordinary static libraries (@file{lib*.a} files) are included into executables
++that use their functions. A file that only uses static libraries needs less
++intelligence to load, but takes up more space. If many executables use the
++same library, there can be much wastage of storage space, since multiple
++copies of the library functions are scattered across the executables.
++However, static libraries are easier to make.
++
++Dynamic libraries (@file{lib*.so*} files) are not copied into executables ---
++the executable is written in such a way that it will automatically load the
++libraries. In linux, the executable will first load the special library 
++@code{ld.so} or @code{ld-linux.so}, which contains the intelligence
++to load further dynamic libraries. Since multiple files end up getting
++executable data from the same file, dynamic libraries are also known as
++shared libraries.
++
++Linux executables come in two flavors, @sc{elf} and a.out.
++
++a.out is the original executable format used by Linux. It has somewhat less 
++overhead than @sc{elf}. However creating shared libraries for a.out is
++@emph{very} involved, and each a.out shared library must be explicitly 
++registered.
++ 
++@sc{elf} is a more recent format, which supports a much simpler method of
++creating libraries. @sc{elf} libraries may also be linked manually
++(@pxref{libdl}).
++
++Since many library authors prefer @sc{elf} and no longer release shared a.out 
++libraries, a.out is moribund on Linux. This version of the @code{ld.so} can
++be compiled to support only @sc{elf}, or to support both formats. (The last
++release of ld.so to support a.out alone was 1.8.0.)
++
++@node ld.so
++@chapter @code{ld.so}: Dynamic linker core
++
++@code{ld.so} works behind the scenes to handle dynamic libraries in Linux.
++Users will almost never have to deal with it directly, but in special cases
++one can send instructions to it through environment variables. Also, if
++something is wrong with your libraries (usually an incorrect version) ld.so
++will give error messages.
++
++Actually @code{ld.so} is the a.out linker. The new @sc{elf} executables are
++handled by a related program @code{ld-linux.so}.
++
++@menu
++* files::	Configuration files used by the suite
++* environment::	Environment settings that tweak @code{ld.so}
++* errors::	Complaints @code{ld.so} might make
++@end menu
++
++@node files
++@section Configuration Files
++
++@table @file
++@item /etc/ld.so.cache
++A file created by @code{ldconfig} and used to speed linking. It's structure
++is private to the suite.
++
++@item /etc/ld.so.conf
++A simple list of directories to scan for libraries, in addition to
++@file{/usr/lib} and @file{/lib}, which are hardwired. It may contain
++comments started with a @samp{#}.
++
++@item /etc/ld.so.preload
++A list of libraries to preload. This allows preloading libraries for
++setuid/setgid executables securely. It may contain comments. 
++@end table
++
++@node environment
++@section Environment Variables
++
++@table @code
++@item LD_AOUT_LIBRARY_PATH
++@itemx LD_LIBRARY_PATH
++These variables supply a library path for finding dynamic libraries, in the
++standard colon seperated format. These variables are ignored when executing 
++setuid/setgid programs, because otherwise they would be a security hazard. 
++@code{ld.so} will use @code{LD_AOUT_LIBRARY_PATH} and @code{ld-linux.so} will 
++use @code{LD_LIBRARY_PATH}.
++
++@item LD_AOUT_PRELOAD
++@itemx LD_PRELOAD
++These variables allow an extra library not specified in the executable to be
++loaded. Generally this is only useful if you want to override a function. 
++These are also ignored when running setuid/setgid executables. @code{ld.so} 
++will use @code{LD_AOUT_PRELOAD} and @code{ld-linux.so} will use 
++@code{LD_PRELOAD}.
++
++@item LD_NOWARN
++If non-empty, errors about incompatible minor revisions are suppressed.
++
++@item LD_KEEPDIR
++If non-empty, allow executables to specify absolute library names. This
++option is deprecated.
++@c FIXME:
++@c The following are things I noticed in the ld-linux.so source.
++@c I don't really understand 'em. Could someone help me?
++@c
++@c @item LD_BIND_NOW
++@c This option is used by the @code{ld-linux.so} only. I don't know 
++@c what it does. (I suspect, looking at the code, that it specifies
++@c "RTLD_NOW" rather than "RTLD_LAZY" mode for the shared libraries.)
++@c 
++@c @item LD_TRACE_LOADED_OBJECTS
++@c @itemx LD_WARN
++@c These seem to have something to do with the communication between the
++@c @code{ld-linux.so} and @code{ldd}. I don't know more.
++@end table
++
++@node errors
++@section Errors
++
++@table @samp
++@item Can't find library @var{library}
++The executable required a dynamically linked library that ld.so cannot find.
++Your symbolic links may be not set right, or you may have not installed a 
++library needed by the program.
++
++@item Can't load library @var{library}
++The library is corrupt. 
++
++@item Incompatible library @var{library}
++@itemx   Require major version @var{x} and found @var{y}
++Your version of the library is incompatible with the executable. Recompiling
++the executable, or upgrading the library will fix the problem.
++
++@item using incompatible library @var{library}
++@itemx   Desire minor version >= @var{x} and found @var{y}.
++Your version of the library is older than that expected by the executable,
++but not so old that the library interface has radically changed, so the
++linker will attempt to run anyway. There is a chance that it will work, but 
++you should upgrade the library or recompile the software. The environment 
++variable @code{LD_NOWARN} can be used to supress this message.
++
++@item too many directories in library path
++The linker only supports up to 32 library directories. You have too many.
++
++@item dynamic linker error in @var{blah}
++The linker is having trouble handling a binary - it is probably corrupt.
++
++@item can't map cache file @var{cache-file}
++@itemx cache file @var{cache-file} @var{blah}
++The linker cache file (generally @file{/etc/ld.so.cache}) is corrupt or
++non-existent. These errors can be ignored, and can be prevented by 
++regenerating the cache file with @code{ldconfig}.
++@end table
++
++@node ldd
++@chapter @code{ldd}: Dependency scanner
++
++@code{ldd} is a utility that prints out the dynamic libraries that an
++executable is linked to. 
++
++Actually @code{ldd} works by signalling ld.so to print the dependencies. 
++For a.out executables this is done by starting the executable with 
++@code{argc} equal to 0. The linker detects this and prints the dependencies. 
++(This can cause problems with @emph{very} old binaries, which would run as 
++normal only with an inappropriate @code{argc}.)
++
++For @sc{elf} executables, special environment variables are used to tell the
++linker to print the dependencies.
++
++@code{ldd} has a few options:
++
++@table @samp
++@item -v
++Print the version number of @code{ldd} itself
++
++@item -V
++Print the version number of the dynamic linker
++
++@item -d
++Report missing functions. This is only supported for @sc{elf} executables.
++
++@item -r
++Report missing objects. This is also only available for @sc{elf}
++executables.
++@end table
++
++@node ldconfig
++@chapter @code{ldconfig}: Setup program 
++
++This utility is used by the system administrator to automatically set up
++symbolic links needed by the libraries, and also to set up the cache file.
++
++@code{ldconfig} is run after new dynamic libraries are installed, and if the 
++cache file or links are damaged. It is also run when upgrading the
++@code{ld.so} suite itself.
++
++The @file{/lib} and @file{/usr/lib} directories, and any listed in the file 
++@file{/etc/ld.so.conf} are scanned by default unless @samp{-n} is used.
++Additional directories may be specified on the command line.
++
++It has the following options:
++
++@table @samp
++@item -D
++Enter debug mode. Implies @samp{-N} and @samp{-X}.
++
++@item -v
++Verbose. Print out links created and directories scanned.
++
++@item -n 
++Check directories specified on the commandline @emph{only}.
++
++@item -N
++Do not regenerate the cache.
++
++@item -X
++Do not rebuild symbolic links.
++
++@item -l
++Set up symbolic links for only libraries presented on the command line.
++
++@item -p
++Print out the library pathnames in the cache file (@file{/etc/ld.so.cache})
++@end table
++
++@node libdl
++@chapter User dynamic linking library
++
++The @code{ld.so} package includes a small library of functions
++(@code{libdl}) to allow manual dynamic linking. Normally programs are linked 
++so that dynamic functions and objects are automagically available. These 
++functions allow one to manually load and access a symbol from a library. 
++They are only available for @sc{elf} executables.
++
++@menu
++* using libdl::	General points
++* functions::	How to use the functions
++* example::	A sample program
++@end menu
++
++@node using libdl
++@section Overview
++
++To access this library, add the flag @samp{-ldl} to your compile command when
++linking the executable. You also must include the header file
++@code{dlfcn.h}. You may also need the flag @samp{-rdynamic}, which enables
++resolving references in the loaded libraries against your executable.
++
++Generally, you will first use @code{dlopen} to open a library. Then you use
++@code{dlsym} one or more times to access symbols. Finally you use
++@code{dlclose} to close the library.
++
++These facilities are most useful for language interpreters that provide
++access to external libraries. Without @code{libdl}, it would be neccessary
++to link the interpreter executable with any and all external libraries
++needed by the programs it runs. With @code{libdl}, the interpreter only 
++needs to be linked with the libraries it uses itself, and can dynamically 
++load in additional ones if programs need it.
++
++@node functions
++@section Functions
++
++@deftypefun void *dlopen ( const char @var{filename}, int @var{flags} )
++
++This function opens the dynamic library specified by @var{filename}
++and returns an abstract handle, which can be used in subsequent calls to 
++@code{dlsym}. The function will respect the @code{LD_ELF_LIBRARY_PATH} and
++@code{LD_LIBRARY_PATH} environment variables.
++
++@end deftypefun
++
++The following flags can be used with @code{dlopen}:
++
++@deftypevr Macro int RTLD_LAZY
++Resolve symbols in the library as they are needed.
++@end deftypevr
++
++@deftypevr Macro int RTLD_NOW
++Resolve all symbols in the library before returning, and fail if not all can
++be resolved. This is mutually exclusive with @code{RTLD_LAZY}.
++@end deftypevr
++
++@deftypevr Macro int RTLD_GLOBAL
++Make symbols in this library available for resolving symbols in other
++libraries loaded with @code{dlopen}.
++@end deftypevr
++
++@deftypefun int dlclose ( void *@var{handle} )
++
++This function releases a library handle.
++
++Note that if a library opened twice, the handle will be the same. However,
++a reference count is used, so you should still close the library as many 
++times as you open it.
++
++@end deftypefun
++
++@deftypefun void *dlsym (void *@var{handle},char *@var{symbol-name})
++
++This function looks up the name @var{symbol-name} in the library and returns
++it in the void pointer.
++
++If there is an error, a null pointer will be returned. However, it is
++possible for a valid name in the library to have a null value, so
++@code{dlerror} should be used to check if there was an error.
++
++@end deftypefun
++
++@deftypefun {libdl function} {const char} *dlerror( void )
++
++This function is used to read the error state. It returns a human-readable
++string describing the last error, or null, meaning no error.
++
++The function resets the error value each time it is called, so the result
++should be copied into a variable. If the function is called more than once
++after an error, the second and subsequent calls will return null.
++
++@end deftypefun
++
++@node example
++@section Example program
++
++Here is an example program that prints the cosine of two by manually linking
++to the math library:
++ 
++@example
++@c The following was snarfed verbatim from the dlopen.3 man file.
++#include <stdio.h>
++#include <dlfcn.h>
++
++int main(int argc, char **argv) @{
++    void *handle;
++    double (*cosine)(double);
++    char *error;
++
++    handle = dlopen ("/lib/libm.so", RTLD_LAZY);
++    if (!handle) @{
++        fputs (dlerror(), stderr);
++        exit(1);
++    @}
++
++    cosine = dlsym(handle, "cos");
++    if ((error = dlerror()) != NULL)  @{
++        fputs(error, stderr);
++        exit(1);
++    @}
++
++    printf ("%f\\n", (*cosine)(2.0));
++    dlclose(handle);
++@}
++@end example
++
++@contents
++
++@bye
+diff -urN uClibc/ldso-0.9.24/man/ldconfig.8 uClibc.ldso.24/ldso-0.9.24/man/ldconfig.8
+--- uClibc/ldso-0.9.24/man/ldconfig.8	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/man/ldconfig.8	2001-04-23 12:43:54.000000000 -0500
+@@ -0,0 +1,189 @@
++.TH ldconfig 8 "14 March 1998"
++.SH NAME
++ldconfig \- determine run-time link bindings
++.SH SYNOPSIS
++ldconfig
++.RB [ \-DvqnNX ]
++.RB [ \-f\ conf ]
++.RB [ \-C\ cache ]
++.RB [ \-r\ root ]
++.IR directory \ ...
++.PD 0
++.PP
++.PD
++ldconfig
++.B \-l
++.RB [ \-Dvq ]
++.IR library \ ...
++.PD 0
++.PP
++.PD
++ldconfig
++.B \-p
++.SH DESCRIPTION
++.B ldconfig
++creates the necessary links and cache (for use by the run-time linker,
++.IR ld.so )
++to the most recent shared libraries found in the directories specified
++on the command line, in the file
++.IR /etc/ld.so.conf ,
++and in the trusted directories
++.RI ( /usr/lib
++and
++.IR /lib ).
++.B ldconfig
++checks the header and file names of the libraries it encounters when
++determining which versions should have their links updated.
++.B ldconfig
++ignores symbolic links when scanning for libraries. 
++.PP
++.B ldconfig
++will attempt to deduce the type of ELF libs (ie. libc5 or libc6/glibc)
++based on what C libs if any the library was linked against, therefore when
++making dynamic libraries, it is wise to explicitly link against libc (use -lc).
++.PP
++Some existing libs do not contain enough information to allow the deduction of 
++their type, therefore the 
++.IR /etc/ld.so.conf 
++file format allows the specification of an expected type.  This is 
++.B only
++used for those ELF libs which we can not work out. The format 
++is like this "dirname=TYPE", where type can be libc4, libc5 or libc6.
++(This syntax also works on the command line).  Spaces are 
++.B not 
++allowed.  Also see the 
++.B -p 
++option.
++.PP 
++Directory names containing an
++.B = are no longer legal
++unless they also have an expected type specifier.
++.PP
++.B ldconfig
++should normally be run by the super-user as it may require write 
++permission on some root owned directories and files.
++It is normally run automatically at bootup, from /etc/rc, or manually
++whenever new DLL's are installed.
++.SH OPTIONS
++.TP
++.B \-D
++Debug mode.
++Implies
++.B \-N
++and
++.BR \-X .
++.TP
++.B \-v
++Verbose mode.
++Print current version number, the name of each directory as it
++is scanned and any links that are created.
++Overrides quiet mode.
++.TP
++.B \-q
++Quiet mode.
++Don't print warnings.
++.TP
++.B \-n
++Only process directories specified on the command line.
++Don't process the trusted directories
++.RI ( /usr/lib
++and
++.IR /lib )
++nor those specified in
++.IR /etc/ld.so.conf .
++Implies
++.BR \-N .
++.TP
++.B \-N
++Don't rebuild the cache.
++Unless
++.B \-X
++is also specified, links are still updated.
++.TP
++.B \-X
++Don't update links.
++Unless
++.B \-N
++is also specified, the cache is still rebuilt.
++.TP
++.B \-f conf
++Use
++.B conf
++instead of
++.IR /etc/ld.so.conf .
++.TP
++.B \-C cache
++Use
++.B cache
++instead of
++.IR /etc/ld.so.cache .
++.TP
++.B \-r root
++Change to and use
++.B root
++as the root directory.
++.TP
++.B \-l
++Library mode.
++Manually link individual libraries.
++Intended for use by experts only.
++.TP
++.B \-p
++Print the lists of directories and candidate libraries stored in
++the current cache.
++.SH EXAMPLES
++In the bootup file
++.I /etc/rc
++having the line
++.RS
++
++/sbin/ldconfig -v
++
++.RE
++will set up the correct links for the shared binaries and rebuild
++the cache.
++.TP
++On the command line
++.RS
++
++# /sbin/ldconfig -n /lib
++
++.RE
++as root after the installation of a new DLL, will properly update the
++shared library symbolic links in /lib.
++
++.SH FILES
++.PD 0
++.TP 20
++.B /lib/ld.so
++execution time linker/loader
++.TP 20
++.B /etc/ld.so.conf
++File containing a list of colon, space, tab, newline, or comma spearated
++directories in which to search for libraries.
++.TP 20
++.B /etc/ld.so.cache
++File containing an ordered list of libraries found in the directories
++specified in
++.BR /etc/ld.so.conf .
++.TP
++.B lib*.so.version
++shared libraries
++.PD
++.SH SEE ALSO
++.BR ldd (1),
++.BR ld.so (8).
++.SH BUGS
++.LP
++.BR ldconfig 's
++functionality, in conjunction with
++.BR ld.so ,
++is only available for executables compiled using libc version 4.4.3 or greater.
++.PP
++.BR ldconfig ,
++being a user process, must be run manually and has no means of dynamically
++determining and relinking shared libraries for use by
++.BR ld.so
++when a new DLL is installed.
++.SH AUTHORS
++David Engel and Mitch D'Souza.
+diff -urN uClibc/ldso-0.9.24/man/ldd.1 uClibc.ldso.24/ldso-0.9.24/man/ldd.1
+--- uClibc/ldso-0.9.24/man/ldd.1	1969-12-31 18:00:00.000000000 -0600
++++ uClibc.ldso.24/ldso-0.9.24/man/ldd.1	2001-04-23 12:43:54.000000000 -0500
+@@ -0,0 +1,59 @@
++.\" Copyright 1995-2000 David Engel (david@ods.com)
++.\" Copyright 1995 Rickard E. Faith (faith@cs.unc.edu)
++.\" Most of this was copied from the README file.  Do not restrict distribution.
++.\" May be distributed under the GNU General Public License
++.TH LDD 1 "14 March 1998"
++.SH NAME
++ldd \- print shared library dependencies
++.SH SYNOPSIS
++.B ldd
++.RB [ \-vVdr ]
++program|library ...
++.SH DESCRIPTION
++.B ldd
++prints the shared libraries required by each program or shared library
++specified on the command line.
++If a shared library name does not contain a '/',
++.B ldd
++attempts to locate the library in the standard locations.
++To run
++.B ldd
++on a shared library in the current directory, a "./" must be prepended
++to its name.
++.SH OPTIONS
++.TP
++.B \-v
++Print the version number of
++.BR ldd .
++.TP
++.B \-V
++Print the version number of the dynamic linker,
++.BR ld.so .
++.TP
++.B \-d
++Perform relocations and report any missing functions (ELF only).
++.TP
++.B \-r
++Perform relocations for both data objects and functions, and
++report any missing objects (ELF only).
++.SH BUGS
++.B ldd
++does not work very well on libc.so.5 itself.
++.PP
++.B ldd
++does not work on a.out shared libraries.
++.PP
++.B ldd
++does not work with some extremely old a.out programs which were 
++built before
++.B ldd
++support was added to the compiler releases.
++If you use
++.B ldd
++on one of these programs, the program will attempt to run with argc = 0 and
++the results will be unpredictable.
++.SH AUTHOR
++David Engel.
++.SH SEE ALSO
++.BR ldconfig (8),
++.BR ld.so (8).