 @@ -1,401 +1,423 @@
-/*	$NetBSD: headers.c,v 1.41.4.1 2012/08/08 06:24:51 jdc Exp $	 */
+/*	$NetBSD: headers.c,v 1.41.4.1.2.1 2013/01/22 21:47:27 matt Exp $	 */
 /*
  * Copyright 1996 John D. Polstra.
  * Copyright 1996 Matt Thomas <matt@3am-software.com>
  * Copyright 2002 Charles M. Hannum <root@ihack.net>
  * 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. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
  *      This product includes software developed by John Polstra.
  * 4. The name of the author may not be used to endorse or promote products
  *    derived from this software without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
  */
 /*
  * Dynamic linker for ELF.
+ *
  * John Polstra <jdp@polstra.com>.
  */
 #include <sys/cdefs.h>
 #ifndef lint
-__RCSID("$NetBSD: headers.c,v 1.41.4.1 2012/08/08 06:24:51 jdc Exp $");
+__RCSID("$NetBSD: headers.c,v 1.41.4.1.2.1 2013/01/22 21:47:27 matt Exp $");
 #endif /* not lint */
 #include <err.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <sys/types.h>
 #include <sys/mman.h>
 #include <sys/bitops.h>
 #include <dirent.h>
 #include "debug.h"
 #include "rtld.h"
 /*
  * Process a shared object's DYNAMIC section, and save the important
  * information in its Obj_Entry structure.
  */
 void
 _rtld_digest_dynamic(const char *execname, Obj_Entry *obj)
+{
 	Elf_Dyn        *dynp;
 	Needed_Entry  **needed_tail = &obj->needed;
 	const Elf_Dyn  *dyn_rpath = NULL;
 	bool		use_pltrel = false;
 	bool		use_pltrela = false;
 	Elf_Addr        relsz = 0, relasz = 0;
 	Elf_Addr	pltrel = 0, pltrelsz = 0;
 	Elf_Addr	init = 0, fini = 0;
 	for (dynp = obj->dynamic; dynp->d_tag != DT_NULL; ++dynp) {
 		switch (dynp->d_tag) {
 		case DT_REL:
 			obj->rel = (const Elf_Rel *)
 			    (obj->relocbase + dynp->d_un.d_ptr);
 			break;
 		case DT_RELSZ:
 			relsz = dynp->d_un.d_val;
 			break;
 		case DT_RELENT:
 			assert(dynp->d_un.d_val == sizeof(Elf_Rel));
 			break;
 		case DT_JMPREL:
 			pltrel = dynp->d_un.d_ptr;
 			break;
 		case DT_PLTRELSZ:
 			pltrelsz = dynp->d_un.d_val;
 			break;
 		case DT_RELA:
 			obj->rela = (const Elf_Rela *)
 			    (obj->relocbase + dynp->d_un.d_ptr);
 			break;
 		case DT_RELASZ:
 			relasz = dynp->d_un.d_val;
 			break;
 		case DT_RELAENT:
 			assert(dynp->d_un.d_val == sizeof(Elf_Rela));
 			break;
 		case DT_PLTREL:
 			use_pltrel = dynp->d_un.d_val == DT_REL;
 			use_pltrela = dynp->d_un.d_val == DT_RELA;
 			assert(use_pltrel || use_pltrela);
 			break;
 		case DT_SYMTAB:
 			obj->symtab = (const Elf_Sym *)
 				(obj->relocbase + dynp->d_un.d_ptr);
 			break;
 		case DT_SYMENT:
 			assert(dynp->d_un.d_val == sizeof(Elf_Sym));
 			break;
 		case DT_STRTAB:
 			obj->strtab = (const char *)
 			    (obj->relocbase + dynp->d_un.d_ptr);
 			break;
 		case DT_STRSZ:
 			obj->strsize = dynp->d_un.d_val;
 			break;
 		case DT_VERNEED:
 			obj->verneed = (const Elf_Verneed *)
 			    (obj->relocbase + dynp->d_un.d_ptr);
 			break;
 		case DT_VERNEEDNUM:
 			obj->verneednum = dynp->d_un.d_val;
 			break;
 		case DT_VERDEF:
 			obj->verdef = (const Elf_Verdef *)
 			    (obj->relocbase + dynp->d_un.d_ptr);
 			break;
 		case DT_VERDEFNUM:
 			obj->verdefnum = dynp->d_un.d_val;
 			break;
 		case DT_VERSYM:
 			obj->versyms = (const Elf_Versym *)
 			    (obj->relocbase + dynp->d_un.d_ptr);
 			break;
 		case DT_HASH:
+			{
 				const Elf_Symindx *hashtab = (const Elf_Symindx *)
 				    (obj->relocbase + dynp->d_un.d_ptr);
 				if (hashtab[0] > UINT32_MAX)
 					obj->nbuckets = UINT32_MAX;
 				else
 					obj->nbuckets = hashtab[0];
 				obj->nchains = hashtab[1];
 				obj->buckets = hashtab + 2;
 				obj->chains = obj->buckets + obj->nbuckets;
 				/*
 				 * Should really be in _rtld_relocate_objects,
 				 * but _rtld_symlook_obj might be used before.
 				 */
 				if (obj->nbuckets) {
 					fast_divide32_prepare(obj->nbuckets,
 					    &obj->nbuckets_m,
 					    &obj->nbuckets_s1,
 					    &obj->nbuckets_s2);
+				}
+			}
 			break;
 		case DT_NEEDED:
+			{
 				Needed_Entry *nep = NEW(Needed_Entry);
 				nep->name = dynp->d_un.d_val;
 				nep->obj = NULL;
 				nep->next = NULL;
 				*needed_tail = nep;
 				needed_tail = &nep->next;
+			}
 			break;
 		case DT_PLTGOT:
 			obj->pltgot = (Elf_Addr *)
 			    (obj->relocbase + dynp->d_un.d_ptr);
 			break;
 		case DT_TEXTREL:
 			obj->textrel = true;
 			break;
 		case DT_SYMBOLIC:
 			obj->symbolic = true;
 			break;
 		case DT_RPATH:
 			/*
 		         * We have to wait until later to process this, because
 			 * we might not have gotten the address of the string
 			 * table yet.
 		         */
 			dyn_rpath = dynp;
 			break;
 		case DT_SONAME:
 			/* Not used by the dynamic linker. */
 			break;
 		case DT_INIT:
 			init = dynp->d_un.d_ptr;
 			break;
 #ifdef HAVE_INITFINI_ARRAY
 		case DT_INIT_ARRAY:
 			obj->init_array =
 			    (fptr_t *)(obj->relocbase + dynp->d_un.d_ptr);
 			break;
 		case DT_INIT_ARRAYSZ:
 			obj->init_arraysz = dynp->d_un.d_val / sizeof(fptr_t);
 			break;
 #endif
 		case DT_FINI:
 			fini = dynp->d_un.d_ptr;
 			break;
 #ifdef HAVE_INITFINI_ARRAY
 		case DT_FINI_ARRAY:
 			obj->fini_array =
 			    (fptr_t *)(obj->relocbase + dynp->d_un.d_ptr);
 			break;
 		case DT_FINI_ARRAYSZ:
 			obj->fini_arraysz = dynp->d_un.d_val / sizeof(fptr_t);
 			break;
 #endif
 		/*
 		 * Don't process DT_DEBUG on MIPS as the dynamic section
 		 * is mapped read-only. DT_MIPS_RLD_MAP is used instead.
 		 * XXX: n32/n64 may use DT_DEBUG, not sure yet.
 		 */
 #ifndef __mips__
 		case DT_DEBUG:
 #ifdef RTLD_LOADER
 			dynp->d_un.d_ptr = (Elf_Addr)&_rtld_debug;
 #endif
 			break;
 #endif
 #ifdef __mips__
 		case DT_MIPS_LOCAL_GOTNO:
 			obj->local_gotno = dynp->d_un.d_val;
 			break;
 		case DT_MIPS_SYMTABNO:
 			obj->symtabno = dynp->d_un.d_val;
 			break;
 		case DT_MIPS_GOTSYM:
 			obj->gotsym = dynp->d_un.d_val;
 			break;
 		case DT_MIPS_RLD_MAP:
 #ifdef RTLD_LOADER
 			*((Elf_Addr *)(dynp->d_un.d_ptr)) = (Elf_Addr)
 			    &_rtld_debug;
 #endif
 			break;
 #endif
 #ifdef __powerpc__
 		case DT_PPC_GOT:
 			obj->gotptr = (Elf_Addr *)(obj->relocbase + dynp->d_un.d_ptr);
 			break;
 #endif
 		case DT_FLAGS_1:
 			obj->z_now =
 			    ((dynp->d_un.d_val & DF_1_BIND_NOW) != 0);
 			obj->z_nodelete =
 			    ((dynp->d_un.d_val & DF_1_NODELETE) != 0);
 			obj->z_initfirst =
 			    ((dynp->d_un.d_val & DF_1_INITFIRST) != 0);
 			obj->z_noopen =
 			    ((dynp->d_un.d_val & DF_1_NOOPEN) != 0);
 			break;
+		}
+	}
 	obj->rellim = (const Elf_Rel *)((const uint8_t *)obj->rel + relsz);
 	obj->relalim = (const Elf_Rela *)((const uint8_t *)obj->rela + relasz);
 	if (use_pltrel) {
 		obj->pltrel = (const Elf_Rel *)(obj->relocbase + pltrel);
 		obj->pltrellim = (const Elf_Rel *)(obj->relocbase + pltrel + pltrelsz);
 		obj->pltrelalim = 0;
 		/* On PPC and SPARC, at least, REL(A)SZ may include JMPREL.
 		   Trim rel(a)lim to save time later. */
 		if (obj->rellim && obj->pltrel &&
 		    obj->rellim > obj->pltrel &&
 		    obj->rellim <= obj->pltrellim)
 			obj->rellim = obj->pltrel;
 	} else if (use_pltrela) {
 		obj->pltrela = (const Elf_Rela *)(obj->relocbase + pltrel);
 		obj->pltrellim = 0;
 		obj->pltrelalim = (const Elf_Rela *)(obj->relocbase + pltrel + pltrelsz);
 		/* On PPC and SPARC, at least, REL(A)SZ may include JMPREL.
 		   Trim rel(a)lim to save time later. */
 		if (obj->relalim && obj->pltrela &&
 		    obj->relalim > obj->pltrela &&
 		    obj->relalim <= obj->pltrelalim)
 			obj->relalim = obj->pltrela;
+	}
 #if defined(RTLD_LOADER) && defined(__HAVE_FUNCTION_DESCRIPTORS)
 	if (init != 0)
 		obj->init = (void (*)(void))
 		    _rtld_function_descriptor_alloc(obj, NULL, init);
 	if (fini != 0)
 		obj->fini = (void (*)(void))
 		    _rtld_function_descriptor_alloc(obj, NULL, fini);
 #else
 	if (init != 0)
 		obj->init = (void (*)(void))
 		    (obj->relocbase + init);
 	if (fini != 0)
 		obj->fini = (void (*)(void))
 		    (obj->relocbase + fini);
 #endif
 	if (dyn_rpath != NULL) {
 		_rtld_add_paths(execname, &obj->rpaths, obj->strtab +
 		    dyn_rpath->d_un.d_val);
+	}
+}
 /*
  * Process a shared object's program header.  This is used only for the
  * main program, when the kernel has already loaded the main program
  * into memory before calling the dynamic linker.  It creates and
  * returns an Obj_Entry structure.
  */
 Obj_Entry *
 _rtld_digest_phdr(const Elf_Phdr *phdr, int phnum, caddr_t entry)
+{
 	Obj_Entry      *obj;
 	const Elf_Phdr *phlimit = phdr + phnum;
 	const Elf_Phdr *ph;
 	int             nsegs = 0;
 	Elf_Addr	vaddr;
 	obj = _rtld_obj_new();
 	for (ph = phdr; ph < phlimit; ++ph) {
 		if (ph->p_type != PT_PHDR)
 			continue;
 		obj->phdr = (void *)(uintptr_t)phdr->p_vaddr;
 		obj->phsize = phdr->p_memsz;
 		obj->relocbase = (caddr_t)((uintptr_t)phdr - (uintptr_t)ph->p_vaddr);
 		dbg(("headers: phdr %p phsize %zu relocbase %lx", obj->phdr,
 		    obj->phsize, (long)obj->relocbase));
 		break;
+	}
 	for (ph = phdr; ph < phlimit; ++ph) {
 		vaddr = (Elf_Addr)(uintptr_t)(obj->relocbase + ph->p_vaddr);
 		switch (ph->p_type) {
 		case PT_INTERP:
 			obj->interp = (const char *)(uintptr_t)vaddr;
 			break;
 		case PT_LOAD:
 			assert(nsegs < 2);
 			if (nsegs == 0) {	/* First load segment */
 				obj->vaddrbase = round_down(vaddr);
 				obj->mapbase = (caddr_t)(uintptr_t)obj->vaddrbase;
 				obj->textsize = round_up(vaddr + ph->p_memsz) -
 				    obj->vaddrbase;
 			} else {		/* Last load segment */
 				obj->mapsize = round_up(vaddr + ph->p_memsz) -
 				    obj->vaddrbase;
+			}
 			++nsegs;
 			break;
 		case PT_DYNAMIC:
 			obj->dynamic = (Elf_Dyn *)(uintptr_t)vaddr;
 			break;
 #if defined(__HAVE_TLS_VARIANT_I) || defined(__HAVE_TLS_VARIANT_II)
 		case PT_TLS:
 			obj->tlsindex = 1;
 			obj->tlssize = ph->p_memsz;
 			obj->tlsalign = ph->p_align;
 			obj->tlsinitsize = ph->p_filesz;
 			obj->tlsinit = (void *)(uintptr_t)ph->p_vaddr;
 			break;
 #endif
+		}
+	}
 	assert(nsegs == 2);
 	obj->entry = entry;
 	return obj;
+}

 @@ -1,1255 +1,1289 @@
-/*	$NetBSD: rtld.c,v 1.155 2011/11/25 21:27:15 joerg Exp $	 */
+/*	$NetBSD: rtld.c,v 1.155.4.1 2013/01/22 21:47:28 matt Exp $	 */
 /*
  * Copyright 1996 John D. Polstra.
  * Copyright 1996 Matt Thomas <matt@3am-software.com>
  * Copyright 2002 Charles M. Hannum <root@ihack.net>
  * 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. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
  *      This product includes software developed by John Polstra.
  * 4. The name of the author may not be used to endorse or promote products
  *    derived from this software without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
  */
 /*
  * Dynamic linker for ELF.
+ *
  * John Polstra <jdp@polstra.com>.
  */
 #include <sys/cdefs.h>
 #ifndef lint
-__RCSID("$NetBSD: rtld.c,v 1.155 2011/11/25 21:27:15 joerg Exp $");
+__RCSID("$NetBSD: rtld.c,v 1.155.4.1 2013/01/22 21:47:28 matt Exp $");
 #endif /* not lint */
 #include <sys/param.h>
 #include <sys/atomic.h>
 #include <sys/mman.h>
 #include <err.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <lwp.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <dirent.h>
 #include <ctype.h>
 #include <dlfcn.h>
 #include "debug.h"
 #include "rtld.h"
 #if !defined(lint)
 #include "sysident.h"
 #endif
 /*
  * Function declarations.
  */
 static void     _rtld_init(caddr_t, caddr_t, const char *);
 static void     _rtld_exit(void);
 Elf_Addr        _rtld(Elf_Addr *, Elf_Addr);
 /*
  * Data declarations.
  */
 static char    *error_message;	/* Message for dlopen(), or NULL */
 struct r_debug  _rtld_debug;	/* for GDB; */
 bool            _rtld_trust;	/* False for setuid and setgid programs */
 Obj_Entry      *_rtld_objlist;	/* Head of linked list of shared objects */
 Obj_Entry     **_rtld_objtail;	/* Link field of last object in list */
 Obj_Entry      *_rtld_objmain;	/* The main program shared object */
 Obj_Entry       _rtld_objself;	/* The dynamic linker shared object */
 u_int		_rtld_objcount;	/* Number of objects in _rtld_objlist */
 u_int		_rtld_objloads;	/* Number of objects loaded in _rtld_objlist */
 u_int		_rtld_objgen;	/* Generation count for _rtld_objlist */
 const char	_rtld_path[] = _PATH_RTLD;
 /* Initialize a fake symbol for resolving undefined weak references. */
 Elf_Sym		_rtld_sym_zero = {
     .st_info	= ELF_ST_INFO(STB_GLOBAL, STT_NOTYPE),
     .st_shndx	= SHN_ABS,
 };
 size_t	_rtld_pagesz;	/* Page size, as provided by kernel */
 Search_Path    *_rtld_default_paths;
 Search_Path    *_rtld_paths;
 Library_Xform  *_rtld_xforms;
 /*
  * Global declarations normally provided by crt0.
  */
 char           *__progname;
 char          **environ;
 static volatile bool _rtld_mutex_may_recurse;
 #if defined(RTLD_DEBUG)
 #ifndef __sh__
 extern Elf_Addr _GLOBAL_OFFSET_TABLE_[];
 #else  /* 32-bit SuperH */
 register Elf_Addr *_GLOBAL_OFFSET_TABLE_ asm("r12");
 #endif
 #endif /* RTLD_DEBUG */
 extern Elf_Dyn  _DYNAMIC;
 static void _rtld_call_fini_functions(sigset_t *, int);
 static void _rtld_call_init_functions(sigset_t *);
 static void _rtld_initlist_visit(Objlist *, Obj_Entry *, int);
 static void _rtld_initlist_tsort(Objlist *, int);
 static Obj_Entry *_rtld_dlcheck(void *);
 static void _rtld_init_dag(Obj_Entry *);
 static void _rtld_init_dag1(Obj_Entry *, Obj_Entry *);
 static void _rtld_objlist_remove(Objlist *, Obj_Entry *);
 static void _rtld_objlist_clear(Objlist *);
 static void _rtld_unload_object(sigset_t *, Obj_Entry *, bool);
 static void _rtld_unref_dag(Obj_Entry *);
 static Obj_Entry *_rtld_obj_from_addr(const void *);
 static inline void
 _rtld_call_initfini_function(fptr_t func, sigset_t *mask)
+{
 	_rtld_exclusive_exit(mask);
 	(*func)();
 	_rtld_exclusive_enter(mask);
+}
 static void
 _rtld_call_fini_function(Obj_Entry *obj, sigset_t *mask, u_int cur_objgen)
+{
 	if (obj->fini_arraysz == 0 && (obj->fini == NULL || obj->fini_called)) {
 		    	return;
+	}
 	if (obj->fini != NULL && !obj->fini_called) {
 		dbg (("calling fini function %s at %p%s", obj->path,
 		    (void *)obj->fini,
 		    obj->z_initfirst ? " (DF_1_INITFIRST)" : ""));
 		obj->fini_called = 1;
 		_rtld_call_initfini_function(obj->fini, mask);
+	}
 #ifdef HAVE_INITFINI_ARRAY
 	/*
 	 * Now process the fini_array if it exists.  Simply go from
 	 * start to end.  We need to make restartable so just advance
 	 * the array pointer and decrement the size each time through
 	 * the loop.
 	 */
 	while (obj->fini_arraysz > 0 && _rtld_objgen == cur_objgen) {
 		fptr_t fini = *obj->fini_array++;
 		obj->fini_arraysz--;
 		dbg (("calling fini array function %s at %p%s", obj->path,
 		    (void *)fini,
 		    obj->z_initfirst ? " (DF_1_INITFIRST)" : ""));
 		_rtld_call_initfini_function(fini, mask);
+	}
 #endif /* HAVE_INITFINI_ARRAY */
+}
 static void
 _rtld_call_fini_functions(sigset_t *mask, int force)
+{
 	Objlist_Entry *elm;
 	Objlist finilist;
 	Obj_Entry *obj;
 	void (*fini)(void);
 	u_int cur_objgen;
 	dbg(("_rtld_call_fini_functions(%d)", force));
 restart:
 	cur_objgen = ++_rtld_objgen;
 	SIMPLEQ_INIT(&finilist);
 	_rtld_initlist_tsort(&finilist, 1);
 	/* First pass: objects _not_ marked with DF_1_INITFIRST. */
 	SIMPLEQ_FOREACH(elm, &finilist, link) {
-		obj = elm->obj;
+		Obj_Entry * const obj = elm->obj;
-		if (obj->refcount > 0 && !force) {
+		if (!obj->z_initfirst) {
-			continue;
+			if (obj->refcount > 0 && !force) {
 				continue;
 		if (obj->fini == NULL || obj->fini_called || obj->z_initfirst) {
-		    	continue;
+			/*
 			 * XXX This can race against a concurrent dlclose().
 			 * XXX In that case, the object could be unmapped before
 			 * XXX the fini() call or the fini_array has completed.
 			 */
 			_rtld_call_fini_function(obj, mask, cur_objgen);
 			if (_rtld_objgen != cur_objgen) {
 				dbg(("restarting fini iteration"));
 				_rtld_objlist_clear(&finilist);
 				goto restart;
+		}
 		dbg (("calling fini function %s at %p",  obj->path,
 		    (void *)obj->fini));
 		obj->fini_called = 1;
 		/*
 		 * XXX This can race against a concurrent dlclose().
 		 * XXX In that case, the object could be unmapped before
 		 * XXX the fini() call is done.
 		 */
 		fini = obj->fini;
 		_rtld_exclusive_exit(mask);
 		(*fini)();
 		_rtld_exclusive_enter(mask);
 		if (_rtld_objgen != cur_objgen) {
 			dbg(("restarting fini iteration"));
 			_rtld_objlist_clear(&finilist);
 			goto restart;
+		}
+	}
 	/* Second pass: objects marked with DF_1_INITFIRST. */
 	SIMPLEQ_FOREACH(elm, &finilist, link) {
-		obj = elm->obj;
+		Obj_Entry * const obj = elm->obj;
 		if (obj->refcount > 0 && !force) {
 			continue;
+		}
 		if (obj->fini == NULL || obj->fini_called) {
 		    	continue;
 		dbg (("calling fini function %s at %p (DF_1_INITFIRST)",
 		    obj->path, (void *)obj->fini));
 		obj->fini_called = 1;
 		/* XXX See above for the race condition here */
-		fini = obj->fini;
+		_rtld_call_fini_function(obj, mask, cur_objgen);
 		_rtld_exclusive_exit(mask);
 		(*fini)();
 		_rtld_exclusive_enter(mask);
 		if (_rtld_objgen != cur_objgen) {
 			dbg(("restarting fini iteration"));
 			_rtld_objlist_clear(&finilist);
 			goto restart;
+		}
+	}
         _rtld_objlist_clear(&finilist);
+}
 static void
 _rtld_call_init_function(Obj_Entry *obj, sigset_t *mask, u_int cur_objgen)
+{
 	if (obj->init_arraysz == 0 && (obj->init_called || obj->init == NULL)) {
 		return;
+	}
 	if (!obj->init_called && obj->init != NULL) {
 		dbg (("calling init function %s at %p%s",
 		    obj->path, (void *)obj->init,
 		    obj->z_initfirst ? " (DF_1_INITFIRST)" : ""));
 		obj->init_called = 1;
 		_rtld_call_initfini_function(obj->init, mask);
+	}
 #ifdef HAVE_INITFINI_ARRAY
 	/*
 	 * Now process the init_array if it exists.  Simply go from
 	 * start to end.  We need to make restartable so just advance
 	 * the array pointer and decrement the size each time through
 	 * the loop.
 	 */
 	while (obj->init_arraysz > 0 && _rtld_objgen == cur_objgen) {
 		fptr_t init = *obj->init_array++;
 		obj->init_arraysz--;
 		dbg (("calling init_array function %s at %p%s",
 		    obj->path, (void *)init,
 		    obj->z_initfirst ? " (DF_1_INITFIRST)" : ""));
 		_rtld_call_initfini_function(init, mask);
+	}
 #endif /* HAVE_INITFINI_ARRAY */
+}
 static void
 _rtld_call_init_functions(sigset_t *mask)
+{
 	Objlist_Entry *elm;
 	Objlist initlist;
 	Obj_Entry *obj;
 	void (*init)(void);
 	u_int cur_objgen;
 	dbg(("_rtld_call_init_functions()"));
 restart:
 	cur_objgen = ++_rtld_objgen;
 	SIMPLEQ_INIT(&initlist);
 	_rtld_initlist_tsort(&initlist, 0);
 	/* First pass: objects marked with DF_1_INITFIRST. */
 	SIMPLEQ_FOREACH(elm, &initlist, link) {
-		obj = elm->obj;
+		Obj_Entry * const obj = elm->obj;
-		if (obj->init == NULL || obj->init_called || !obj->z_initfirst) {
+		if (obj->z_initfirst) {
-			continue;
+			_rtld_call_init_function(obj, mask, cur_objgen);
 			if (_rtld_objgen != cur_objgen) {
-		dbg (("calling init function %s at %p (DF_1_INITFIRST)",
+				dbg(("restarting init iteration"));
-		    obj->path, (void *)obj->init));
+				_rtld_objlist_clear(&initlist);
-		obj->init_called = 1;
+				goto restart;
 		init = obj->init;
 		_rtld_exclusive_exit(mask);
 		(*init)();
 		_rtld_exclusive_enter(mask);
 		if (_rtld_objgen != cur_objgen) {
 			dbg(("restarting init iteration"));
 			_rtld_objlist_clear(&initlist);
 			goto restart;
+		}
+	}
 	/* Second pass: all other objects. */
 	SIMPLEQ_FOREACH(elm, &initlist, link) {
-		obj = elm->obj;
+		_rtld_call_init_function(elm->obj, mask, cur_objgen);
 		if (obj->init == NULL || obj->init_called) {
 			continue;
 		dbg (("calling init function %s at %p",  obj->path,
 		    (void *)obj->init));
 		obj->init_called = 1;
 		init = obj->init;
 		_rtld_exclusive_exit(mask);
 		(*init)();
 		_rtld_exclusive_enter(mask);
 		if (_rtld_objgen != cur_objgen) {
 			dbg(("restarting init iteration"));
 			_rtld_objlist_clear(&initlist);
 			goto restart;
+		}
+	}
         _rtld_objlist_clear(&initlist);
+}
 /*
  * Initialize the dynamic linker.  The argument is the address at which
  * the dynamic linker has been mapped into memory.  The primary task of
  * this function is to create an Obj_Entry for the dynamic linker and
  * to resolve the PLT relocation for platforms that need it (those that
  * define __HAVE_FUNCTION_DESCRIPTORS
  */
 static void
 _rtld_init(caddr_t mapbase, caddr_t relocbase, const char *execname)
+{
 	/* Conjure up an Obj_Entry structure for the dynamic linker. */
 	_rtld_objself.path = __UNCONST(_rtld_path);
 	_rtld_objself.pathlen = sizeof(_rtld_path)-1;
 	_rtld_objself.rtld = true;
 	_rtld_objself.mapbase = mapbase;
 	_rtld_objself.relocbase = relocbase;
 	_rtld_objself.dynamic = (Elf_Dyn *) &_DYNAMIC;
 	_rtld_objself.strtab = "_rtld_sym_zero";
 	/*
 	 * Set value to -relocbase so that
+	 *
 	 *     _rtld_objself.relocbase + _rtld_sym_zero.st_value == 0
+	 *
 	 * This allows unresolved references to weak symbols to be computed
 	 * to a value of 0.
 	 */
 	_rtld_sym_zero.st_value = -(uintptr_t)relocbase;
 	_rtld_digest_dynamic(_rtld_path, &_rtld_objself);
 	assert(!_rtld_objself.needed);
 #if !defined(__hppa__)
 	assert(!_rtld_objself.pltrel && !_rtld_objself.pltrela);
 #else
 	_rtld_relocate_plt_objects(&_rtld_objself);
 #endif
 #if !defined(__mips__) && !defined(__hppa__)
 	assert(!_rtld_objself.pltgot);
 #endif
 #if !defined(__arm__) && !defined(__mips__) && !defined(__sh__)
 	/* ARM, MIPS and SH{3,5} have a bogus DT_TEXTREL. */
 	assert(!_rtld_objself.textrel);
 #endif
 	_rtld_add_paths(execname, &_rtld_default_paths,
 	    RTLD_DEFAULT_LIBRARY_PATH);
 #ifdef RTLD_ARCH_SUBDIR
 	_rtld_add_paths(execname, &_rtld_default_paths,
 	    RTLD_DEFAULT_LIBRARY_PATH "/" RTLD_ARCH_SUBDIR);
 #endif
 	/*
 	 * Set up the _rtld_objlist pointer, so that rtld symbols can be found.
 	 */
 	_rtld_objlist = &_rtld_objself;
 	/* Make the object list empty again. */
 	_rtld_objlist = NULL;
 	_rtld_objtail = &_rtld_objlist;
 	_rtld_objcount = 0;
 	_rtld_debug.r_brk = _rtld_debug_state;
 	_rtld_debug.r_state = RT_CONSISTENT;
+}
 /*
  * Cleanup procedure.  It will be called (by the atexit() mechanism) just
  * before the process exits.
  */
 static void
 _rtld_exit(void)
+{
 	sigset_t mask;
 	dbg(("rtld_exit()"));
 	_rtld_exclusive_enter(&mask);
 	_rtld_call_fini_functions(&mask, 1);
 	_rtld_exclusive_exit(&mask);
+}
 /*
  * Main entry point for dynamic linking.  The argument is the stack
  * pointer.  The stack is expected to be laid out as described in the
  * SVR4 ABI specification, Intel 386 Processor Supplement.  Specifically,
  * the stack pointer points to a word containing ARGC.  Following that
  * in the stack is a null-terminated sequence of pointers to argument
  * strings.  Then comes a null-terminated sequence of pointers to
  * environment strings.  Finally, there is a sequence of "auxiliary
  * vector" entries.
+ *
  * This function returns the entry point for the main program, the dynamic
  * linker's exit procedure in sp[0], and a pointer to the main object in
  * sp[1].
  */
 Elf_Addr
 _rtld(Elf_Addr *sp, Elf_Addr relocbase)
+{
 	const AuxInfo  *pAUX_base, *pAUX_entry, *pAUX_execfd, *pAUX_phdr,
 	               *pAUX_phent, *pAUX_phnum, *pAUX_euid, *pAUX_egid,
 		       *pAUX_ruid, *pAUX_rgid;
 	const AuxInfo  *pAUX_pagesz;
 	char          **env, **oenvp;
 	const AuxInfo  *aux;
 	const AuxInfo  *auxp;
 	Obj_Entry      *obj;
 	Elf_Addr       *const osp = sp;
 	bool            bind_now = 0;
 	const char     *ld_bind_now, *ld_preload, *ld_library_path;
 	const char    **argv;
 	const char     *execname;
 	long		argc;
 	const char **real___progname;
 	const Obj_Entry **real___mainprog_obj;
 	char ***real_environ;
 	sigset_t        mask;
 #ifdef DEBUG
 	const char     *ld_debug;
 #endif
 #ifdef RTLD_DEBUG
 	int i = 0;
 #endif
 	/*
          * On entry, the dynamic linker itself has not been relocated yet.
          * Be very careful not to reference any global data until after
          * _rtld_init has returned.  It is OK to reference file-scope statics
          * and string constants, and to call static and global functions.
          */
 	/* Find the auxiliary vector on the stack. */
 	/* first Elf_Word reserved to address of exit routine */
 #if defined(RTLD_DEBUG)
 	debug = 1;
 	dbg(("sp = %p, argc = %ld, argv = %p <%s> relocbase %p", sp,
 	    (long)sp[2], &sp[3], (char *) sp[3], (void *)relocbase));
 #if 0
 	dbg(("got is at %p, dynamic is at %p", _GLOBAL_OFFSET_TABLE_,
 	    &_DYNAMIC));
 #endif
 	dbg(("_ctype_ is %p", _ctype_));
 #endif
 	sp += 2;		/* skip over return argument space */
 	argv = (const char **) &sp[1];
 	argc = *(long *)sp;
 	sp += 2 + argc;		/* Skip over argc, arguments, and NULL
 				 * terminator */
 	env = (char **) sp;
 	while (*sp++ != 0) {	/* Skip over environment, and NULL terminator */
 #if defined(RTLD_DEBUG)
 		dbg(("env[%d] = %p %s", i++, (void *)sp[-1], (char *)sp[-1]));
 #endif
+	}
 	aux = (const AuxInfo *) sp;
 	pAUX_base = pAUX_entry = pAUX_execfd = NULL;
 	pAUX_phdr = pAUX_phent = pAUX_phnum = NULL;
 	pAUX_euid = pAUX_ruid = pAUX_egid = pAUX_rgid = NULL;
 	pAUX_pagesz = NULL;
 	execname = NULL;
 	/* Digest the auxiliary vector. */
 	for (auxp = aux; auxp->a_type != AT_NULL; ++auxp) {
 		switch (auxp->a_type) {
 		case AT_BASE:
 			pAUX_base = auxp;
 			break;
 		case AT_ENTRY:
 			pAUX_entry = auxp;
 			break;
 		case AT_EXECFD:
 			pAUX_execfd = auxp;
 			break;
 		case AT_PHDR:
 			pAUX_phdr = auxp;
 			break;
 		case AT_PHENT:
 			pAUX_phent = auxp;
 			break;
 		case AT_PHNUM:
 			pAUX_phnum = auxp;
 			break;
 #ifdef AT_EUID
 		case AT_EUID:
 			pAUX_euid = auxp;
 			break;
 		case AT_RUID:
 			pAUX_ruid = auxp;
 			break;
 		case AT_EGID:
 			pAUX_egid = auxp;
 			break;
 		case AT_RGID:
 			pAUX_rgid = auxp;
 			break;
 #endif
 #ifdef AT_SUN_EXECNAME
 		case AT_SUN_EXECNAME:
 			execname = (const char *)(const void *)auxp->a_v;
 			break;
 #endif
 		case AT_PAGESZ:
 			pAUX_pagesz = auxp;
 			break;
+		}
+	}
 	/* Initialize and relocate ourselves. */
 	if (pAUX_base == NULL) {
 		_rtld_error("Bad pAUX_base");
 		_rtld_die();
+	}
 	assert(pAUX_pagesz != NULL);
 	_rtld_pagesz = (int)pAUX_pagesz->a_v;
 	_rtld_init((caddr_t)pAUX_base->a_v, (caddr_t)relocbase, execname);
 	__progname = _rtld_objself.path;
 	environ = env;
 	_rtld_trust = ((pAUX_euid ? (uid_t)pAUX_euid->a_v : geteuid()) ==
 	    (pAUX_ruid ? (uid_t)pAUX_ruid->a_v : getuid())) &&
 	    ((pAUX_egid ? (gid_t)pAUX_egid->a_v : getegid()) ==
 	    (pAUX_rgid ? (gid_t)pAUX_rgid->a_v : getgid()));
 #ifdef DEBUG
 	ld_debug = NULL;
 #endif
 	ld_bind_now = NULL;
 	ld_library_path = NULL;
 	ld_preload = NULL;
 	/*
 	 * Inline avoid using normal getenv/unsetenv here as the libc
 	 * code is quite a bit more complicated.
 	 */
 	for (oenvp = env; *env != NULL; ++env) {
 		static const char bind_var[] = "LD_BIND_NOW=";
 		static const char debug_var[] =  "LD_DEBUG=";
 		static const char path_var[] = "LD_LIBRARY_PATH=";
 		static const char preload_var[] = "LD_PRELOAD=";
 #define LEN(x)	(sizeof(x) - 1)
 		if ((*env)[0] != 'L' || (*env)[1] != 'D') {
 			/*
 			 * Special case to skip most entries without
 			 * the more expensive calls to strncmp.
 			 */
 			*oenvp++ = *env;
 		} else if (strncmp(*env, debug_var, LEN(debug_var)) == 0) {
 			if (_rtld_trust) {
 #ifdef DEBUG
 				ld_debug = *env + LEN(debug_var);
 #endif
 				*oenvp++ = *env;
+			}
 		} else if (strncmp(*env, bind_var, LEN(bind_var)) == 0) {
 			ld_bind_now = *env + LEN(bind_var);
 		} else if (strncmp(*env, path_var, LEN(path_var)) == 0) {
 			if (_rtld_trust) {
 				ld_library_path = *env + LEN(path_var);
 				*oenvp++ = *env;
+			}
 		} else if (strncmp(*env, preload_var, LEN(preload_var)) == 0) {
 			if (_rtld_trust) {
 				ld_preload = *env + LEN(preload_var);
 				*oenvp++ = *env;
+			}
 		} else {
 			*oenvp++ = *env;
+		}
 #undef LEN
+	}
 	*oenvp++ = NULL;
 	if (ld_bind_now != NULL && *ld_bind_now != '\0')
 		bind_now = true;
 	if (_rtld_trust) {
 #ifdef DEBUG
 #ifdef RTLD_DEBUG
 		debug = 0;
 #endif
 		if (ld_debug != NULL && *ld_debug != '\0')
 			debug = 1;
 #endif
 		_rtld_add_paths(execname, &_rtld_paths, ld_library_path);
 	} else {
 		execname = NULL;
+	}
 	_rtld_process_hints(execname, &_rtld_paths, &_rtld_xforms,
 	    _PATH_LD_HINTS);
 	dbg(("dynamic linker is initialized, mapbase=%p, relocbase=%p",
 	     _rtld_objself.mapbase, _rtld_objself.relocbase));
 	/*
          * Load the main program, or process its program header if it is
          * already loaded.
          */
 	if (pAUX_execfd != NULL) {	/* Load the main program. */
 		int             fd = pAUX_execfd->a_v;
 		const char *obj_name = argv[0] ? argv[0] : "main program";
 		dbg(("loading main program"));
 		_rtld_objmain = _rtld_map_object(obj_name, fd, NULL);
 		close(fd);
 		if (_rtld_objmain == NULL)
 			_rtld_die();
 	} else {		/* Main program already loaded. */
 		const Elf_Phdr *phdr;
 		int             phnum;
 		caddr_t         entry;
 		dbg(("processing main program's program header"));
 		assert(pAUX_phdr != NULL);
 		phdr = (const Elf_Phdr *) pAUX_phdr->a_v;
 		assert(pAUX_phnum != NULL);
 		phnum = pAUX_phnum->a_v;
 		assert(pAUX_phent != NULL);
 		assert(pAUX_phent->a_v == sizeof(Elf_Phdr));
 		assert(pAUX_entry != NULL);
 		entry = (caddr_t) pAUX_entry->a_v;
 		_rtld_objmain = _rtld_digest_phdr(phdr, phnum, entry);
 		_rtld_objmain->path = xstrdup(argv[0] ? argv[0] :
 		    "main program");
 		_rtld_objmain->pathlen = strlen(_rtld_objmain->path);
+	}
 	_rtld_objmain->mainprog = true;
 	/*
 	 * Get the actual dynamic linker pathname from the executable if
 	 * possible.  (It should always be possible.)  That ensures that
 	 * gdb will find the right dynamic linker even if a non-standard
 	 * one is being used.
 	 */
 	if (_rtld_objmain->interp != NULL &&
 	    strcmp(_rtld_objmain->interp, _rtld_objself.path) != 0)
 		_rtld_objself.path = xstrdup(_rtld_objmain->interp);
 	dbg(("actual dynamic linker is %s", _rtld_objself.path));
 	_rtld_digest_dynamic(execname, _rtld_objmain);
 	/* Link the main program into the list of objects. */
 	*_rtld_objtail = _rtld_objmain;
 	_rtld_objtail = &_rtld_objmain->next;
 	_rtld_objcount++;
 	_rtld_objloads++;
 	_rtld_linkmap_add(_rtld_objmain);
 	_rtld_linkmap_add(&_rtld_objself);
 	++_rtld_objmain->refcount;
 	_rtld_objmain->mainref = 1;
 	_rtld_objlist_push_tail(&_rtld_list_main, _rtld_objmain);
 	if (ld_preload) {
 		/*
 		 * Pre-load user-specified objects after the main program
 		 * but before any shared object dependencies.
 		 */
 		dbg(("preloading objects"));
 		if (_rtld_preload(ld_preload) == -1)
 			_rtld_die();
+	}
 	dbg(("loading needed objects"));
 	if (_rtld_load_needed_objects(_rtld_objmain, _RTLD_MAIN) == -1)
 		_rtld_die();
 	dbg(("checking for required versions"));
 	for (obj = _rtld_objlist; obj != NULL; obj = obj->next) {
 		if (_rtld_verify_object_versions(obj) == -1)
 			_rtld_die();
+	}
 #if defined(__HAVE_TLS_VARIANT_I) || defined(__HAVE_TLS_VARIANT_II)
 	dbg(("initializing initial Thread Local Storage offsets"));
 	/*
 	 * All initial objects get the TLS space from the static block.
 	 */
 	for (obj = _rtld_objlist; obj != NULL; obj = obj->next)
 		_rtld_tls_offset_allocate(obj);
 #endif
 	dbg(("relocating objects"));
 	if (_rtld_relocate_objects(_rtld_objmain, bind_now) == -1)
 		_rtld_die();
 	dbg(("doing copy relocations"));
 	if (_rtld_do_copy_relocations(_rtld_objmain) == -1)
 		_rtld_die();
 #if defined(__HAVE_TLS_VARIANT_I) || defined(__HAVE_TLS_VARIANT_II)
 	dbg(("initializing Thread Local Storage for main thread"));
 	/*
 	 * Set up TLS area for the main thread.
 	 * This has to be done after all relocations are processed,
 	 * since .tdata may contain relocations.
 	 */
 	_rtld_tls_initial_allocation();
 #endif
 	/*
 	 * Set the __progname,  environ and, __mainprog_obj before
 	 * calling anything that might use them.
 	 */
 	real___progname = _rtld_objmain_sym("__progname");
 	if (real___progname) {
 		if (argv[0] != NULL) {
 			if ((*real___progname = strrchr(argv[0], '/')) == NULL)
 				(*real___progname) = argv[0];
 			else
 				(*real___progname)++;
 		} else {
 			(*real___progname) = NULL;
+		}
+	}
 	real_environ = _rtld_objmain_sym("environ");
 	if (real_environ)
 		*real_environ = environ;
 	/*
 	 * Set __mainprog_obj for old binaries.
 	 */
 	real___mainprog_obj = _rtld_objmain_sym("__mainprog_obj");
 	if (real___mainprog_obj)
 		*real___mainprog_obj = _rtld_objmain;
 	_rtld_exclusive_enter(&mask);
 	dbg(("calling _init functions"));
 	_rtld_call_init_functions(&mask);
 	dbg(("control at program entry point = %p, obj = %p, exit = %p",
 	     _rtld_objmain->entry, _rtld_objmain, _rtld_exit));
 	_rtld_exclusive_exit(&mask);
 	/*
 	 * Return with the entry point and the exit procedure in at the top
 	 * of stack.
 	 */
 	_rtld_debug_state();	/* say hello to gdb! */
 	((void **) osp)[0] = _rtld_exit;
 	((void **) osp)[1] = _rtld_objmain;
 	return (Elf_Addr) _rtld_objmain->entry;
+}
 void
 _rtld_die(void)
+{
 	const char *msg = dlerror();
 	if (msg == NULL)
 		msg = "Fatal error";
 	xerrx(1, "%s", msg);
+}
 static Obj_Entry *
 _rtld_dlcheck(void *handle)
+{
 	Obj_Entry *obj;
 	for (obj = _rtld_objlist; obj != NULL; obj = obj->next)
 		if (obj == (Obj_Entry *) handle)
 			break;
 	if (obj == NULL || obj->dl_refcount == 0) {
 		xwarnx("Invalid shared object handle %p", handle);
 		return NULL;
+	}
 	return obj;
+}
 static void
 _rtld_initlist_visit(Objlist* list, Obj_Entry *obj, int rev)
+{
 	Needed_Entry* elm;
 	/* dbg(("_rtld_initlist_visit(%s)", obj->path)); */
 	if (obj->init_done)
 		return;
 	obj->init_done = 1;
 	for (elm = obj->needed; elm != NULL; elm = elm->next) {
 		if (elm->obj != NULL) {
 			_rtld_initlist_visit(list, elm->obj, rev);
+		}
+	}
 	if (rev) {
 		_rtld_objlist_push_head(list, obj);
 	} else {
 		_rtld_objlist_push_tail(list, obj);
+	}
+}
 static void
 _rtld_initlist_tsort(Objlist* list, int rev)
+{
 	dbg(("_rtld_initlist_tsort"));
 	Obj_Entry* obj;
 	for (obj = _rtld_objlist->next; obj; obj = obj->next) {
 		obj->init_done = 0;
+	}
 	for (obj = _rtld_objlist->next; obj; obj = obj->next) {
 		_rtld_initlist_visit(list, obj, rev);
+	}
+}
 static void
 _rtld_init_dag(Obj_Entry *root)
+{
 	_rtld_init_dag1(root, root);
+}
 static void
 _rtld_init_dag1(Obj_Entry *root, Obj_Entry *obj)
+{
 	const Needed_Entry *needed;
 	if (!obj->mainref) {
 		if (_rtld_objlist_find(&obj->dldags, root))
 			return;
 		dbg(("add %p (%s) to %p (%s) DAG", obj, obj->path, root,
 		    root->path));
 		_rtld_objlist_push_tail(&obj->dldags, root);
 		_rtld_objlist_push_tail(&root->dagmembers, obj);
+	}
 	for (needed = obj->needed; needed != NULL; needed = needed->next)
 		if (needed->obj != NULL)
 			_rtld_init_dag1(root, needed->obj);
+}
 /*
  * Note, this is called only for objects loaded by dlopen().
  */
 static void
 _rtld_unload_object(sigset_t *mask, Obj_Entry *root, bool do_fini_funcs)
+{
 	_rtld_unref_dag(root);
 	if (root->refcount == 0) { /* We are finished with some objects. */
 		Obj_Entry *obj;
 		Obj_Entry **linkp;
 		Objlist_Entry *elm;
 		/* Finalize objects that are about to be unmapped. */
 		if (do_fini_funcs)
 			_rtld_call_fini_functions(mask, 0);
 		/* Remove the DAG from all objects' DAG lists. */
 		SIMPLEQ_FOREACH(elm, &root->dagmembers, link)
 			_rtld_objlist_remove(&elm->obj->dldags, root);
 		/* Remove the DAG from the RTLD_GLOBAL list. */
 		if (root->globalref) {
 			root->globalref = 0;
 			_rtld_objlist_remove(&_rtld_list_global, root);
+		}
 		/* Unmap all objects that are no longer referenced. */
 		linkp = &_rtld_objlist->next;
 		while ((obj = *linkp) != NULL) {
 			if (obj->refcount == 0) {
 				dbg(("unloading \"%s\"", obj->path));
 				if (obj->ehdr != MAP_FAILED)
 					munmap(obj->ehdr, _rtld_pagesz);
 				munmap(obj->mapbase, obj->mapsize);
 				_rtld_objlist_remove(&_rtld_list_global, obj);
 				_rtld_linkmap_delete(obj);
 				*linkp = obj->next;
 				_rtld_objcount--;
 				_rtld_obj_free(obj);
 			} else
 				linkp = &obj->next;
+		}
 		_rtld_objtail = linkp;
+	}
+}
 void
 _rtld_ref_dag(Obj_Entry *root)
+{
 	const Needed_Entry *needed;
 	assert(root);
 	++root->refcount;
 	dbg(("incremented reference on \"%s\" (%d)", root->path,
 	    root->refcount));
 	for (needed = root->needed; needed != NULL;
 	     needed = needed->next) {
 		if (needed->obj != NULL)
 			_rtld_ref_dag(needed->obj);
+	}
+}
 static void
 _rtld_unref_dag(Obj_Entry *root)
+{
 	assert(root);
 	assert(root->refcount != 0);
 	--root->refcount;
 	dbg(("decremented reference on \"%s\" (%d)", root->path,
 	    root->refcount));
 	if (root->refcount == 0) {
 		const Needed_Entry *needed;
 		for (needed = root->needed; needed != NULL;
 		     needed = needed->next) {
 			if (needed->obj != NULL)
 				_rtld_unref_dag(needed->obj);
+		}
+	}
+}
 __strong_alias(__dlclose,dlclose)
 int
 dlclose(void *handle)
+{
 	Obj_Entry *root;
 	sigset_t mask;
 	dbg(("dlclose of %p", handle));
 	_rtld_exclusive_enter(&mask);
 	root = _rtld_dlcheck(handle);
 	if (root == NULL) {
 		_rtld_exclusive_exit(&mask);
 		return -1;
+	}
 	_rtld_debug.r_state = RT_DELETE;
 	_rtld_debug_state();
 	--root->dl_refcount;
 	_rtld_unload_object(&mask, root, true);
 	_rtld_debug.r_state = RT_CONSISTENT;
 	_rtld_debug_state();
 	_rtld_exclusive_exit(&mask);
 	return 0;
+}
 __strong_alias(__dlerror,dlerror)
 char *
 dlerror(void)
+{
 	char *msg = error_message;
 	error_message = NULL;
 	return msg;
+}
 __strong_alias(__dlopen,dlopen)
 void *
 dlopen(const char *name, int mode)
+{
 	Obj_Entry **old_obj_tail = _rtld_objtail;
 	Obj_Entry *obj = NULL;
 	int flags = _RTLD_DLOPEN;
 	bool nodelete;
 	bool now;
 	sigset_t mask;
 	int result;
 	dbg(("dlopen of %s %d", name, mode));
 	_rtld_exclusive_enter(&mask);
 	flags |= (mode & RTLD_GLOBAL) ? _RTLD_GLOBAL : 0;
 	flags |= (mode & RTLD_NOLOAD) ? _RTLD_NOLOAD : 0;
 	nodelete = (mode & RTLD_NODELETE) ? true : false;
 	now = ((mode & RTLD_MODEMASK) == RTLD_NOW) ? true : false;
 	_rtld_debug.r_state = RT_ADD;
 	_rtld_debug_state();
 	if (name == NULL) {
 		obj = _rtld_objmain;
 		obj->refcount++;
 	} else
 		obj = _rtld_load_library(name, _rtld_objmain, flags);
 	if (obj != NULL) {
 		++obj->dl_refcount;
 		if (*old_obj_tail != NULL) {	/* We loaded something new. */
 			assert(*old_obj_tail == obj);
 			result = _rtld_load_needed_objects(obj, flags);
 			if (result != -1) {
 				Objlist_Entry *entry;
 				_rtld_init_dag(obj);
 				SIMPLEQ_FOREACH(entry, &obj->dagmembers, link) {
 					result = _rtld_verify_object_versions(entry->obj);
 					if (result == -1)
 						break;
+				}
+			}
 			if (result == -1 || _rtld_relocate_objects(obj,
 			    (now || obj->z_now)) == -1) {
 				_rtld_unload_object(&mask, obj, false);
 				obj->dl_refcount--;
 				obj = NULL;
 			} else {
 				_rtld_call_init_functions(&mask);
+			}
+		}
 		if (obj != NULL) {
 			if ((nodelete || obj->z_nodelete) && !obj->ref_nodel) {
 				dbg(("dlopen obj %s nodelete", obj->path));
 				_rtld_ref_dag(obj);
 				obj->z_nodelete = obj->ref_nodel = true;
+			}
+		}
+	}
 	_rtld_debug.r_state = RT_CONSISTENT;
 	_rtld_debug_state();
 	_rtld_exclusive_exit(&mask);
 	return obj;
+}
 /*
  * Find a symbol in the main program.
  */
 void *
 _rtld_objmain_sym(const char *name)
+{
 	unsigned long hash;
 	const Elf_Sym *def;
 	const Obj_Entry *obj;
 	DoneList donelist;
 	hash = _rtld_elf_hash(name);
 	obj = _rtld_objmain;
 	_rtld_donelist_init(&donelist);
 	def = _rtld_symlook_list(name, hash, &_rtld_list_main, &obj, 0,
 	    NULL, &donelist);
 	if (def != NULL)
 		return obj->relocbase + def->st_value;
 	return NULL;
+}
 #ifdef __powerpc__
 static void *
 hackish_return_address(void)
+{
 	return __builtin_return_address(1);
+}
 #endif
 #ifdef __HAVE_FUNCTION_DESCRIPTORS
 #define	lookup_mutex_enter()	_rtld_exclusive_enter(&mask)
 #define	lookup_mutex_exit()	_rtld_exclusive_exit(&mask)
 #else
 #define	lookup_mutex_enter()	_rtld_shared_enter()
 #define	lookup_mutex_exit()	_rtld_shared_exit()
 #endif
 static void *
 do_dlsym(void *handle, const char *name, const Ver_Entry *ventry, void *retaddr)
+{
 	const Obj_Entry *obj;
 	unsigned long hash;
 	const Elf_Sym *def;
 	const Obj_Entry *defobj;
 	DoneList donelist;
 	const u_int flags = SYMLOOK_DLSYM | SYMLOOK_IN_PLT;
 #ifdef __HAVE_FUNCTION_DESCRIPTORS
 	sigset_t mask;
 #endif
 	lookup_mutex_enter();
 	hash = _rtld_elf_hash(name);
 	def = NULL;
 	defobj = NULL;
 	switch ((intptr_t)handle) {
 	case (intptr_t)NULL:
 	case (intptr_t)RTLD_NEXT:
 	case (intptr_t)RTLD_DEFAULT:
 	case (intptr_t)RTLD_SELF:
 		if ((obj = _rtld_obj_from_addr(retaddr)) == NULL) {
 			_rtld_error("Cannot determine caller's shared object");
 			lookup_mutex_exit();
 			return NULL;
+		}
 		switch ((intptr_t)handle) {
 		case (intptr_t)NULL:	 /* Just the caller's shared object. */
 			def = _rtld_symlook_obj(name, hash, obj, flags, ventry);
 			defobj = obj;
 			break;
 		case (intptr_t)RTLD_NEXT:	/* Objects after callers */
 			obj = obj->next;
 			/*FALLTHROUGH*/
 		case (intptr_t)RTLD_SELF:	/* Caller included */
 			for (; obj; obj = obj->next) {
 				if ((def = _rtld_symlook_obj(name, hash, obj,
 				    flags, ventry)) != NULL) {
 					defobj = obj;
 					break;
+				}
+			}
 			break;
 		case (intptr_t)RTLD_DEFAULT:
 			def = _rtld_symlook_default(name, hash, obj, &defobj,
 			    flags, ventry);
 			break;
 		default:
 			abort();
+		}
 		break;
 	default:
 		if ((obj = _rtld_dlcheck(handle)) == NULL) {
 			lookup_mutex_exit();
 			return NULL;
+		}
 		_rtld_donelist_init(&donelist);
 		if (obj->mainprog) {
 			/* Search main program and all libraries loaded by it */
 			def = _rtld_symlook_list(name, hash, &_rtld_list_main,
 			    &defobj, flags, ventry, &donelist);
 		} else {
 			Needed_Entry fake;
 			DoneList depth;
 			/* Search the object and all the libraries loaded by it. */
 			fake.next = NULL;
 			fake.obj = __UNCONST(obj);
 			fake.name = 0;
 			_rtld_donelist_init(&depth);
 			def = _rtld_symlook_needed(name, hash, &fake, &defobj,
 			    flags, ventry, &donelist, &depth);
+		}
 		break;
+	}
 	if (def != NULL) {
 		void *p;
 #ifdef __HAVE_FUNCTION_DESCRIPTORS
 		if (ELF_ST_TYPE(def->st_info) == STT_FUNC) {
 			p = (void *)_rtld_function_descriptor_alloc(defobj,
 			    def, 0);
 			lookup_mutex_exit();
 			return p;
+		}
 #endif /* __HAVE_FUNCTION_DESCRIPTORS */
 		p = defobj->relocbase + def->st_value;
 		lookup_mutex_exit();
 		return p;
+	}
 	_rtld_error("Undefined symbol \"%s\"", name);
 	lookup_mutex_exit();
 	return NULL;
+}
 __strong_alias(__dlsym,dlsym)
 void *
 dlsym(void *handle, const char *name)
+{
 	void *retaddr;
 	dbg(("dlsym of %s in %p", name, handle));
 #ifdef __powerpc__
 	retaddr = hackish_return_address();
 #else
 	retaddr = __builtin_return_address(0);
 #endif
 	return do_dlsym(handle, name, NULL, retaddr);
+}
 __strong_alias(__dlvsym,dlvsym)
 void *
 dlvsym(void *handle, const char *name, const char *version)
+{
 	Ver_Entry *ventry = NULL;
 	Ver_Entry ver_entry;
 	void *retaddr;
 	dbg(("dlvsym of %s@%s in %p", name, version ? version : NULL, handle));
 	if (version != NULL) {
 		ver_entry.name = version;
 		ver_entry.file = NULL;
 		ver_entry.hash = _rtld_elf_hash(version);
 		ver_entry.flags = 0;
 		ventry = &ver_entry;
+	}
 #ifdef __powerpc__
 	retaddr = hackish_return_address();
 #else
 	retaddr = __builtin_return_address(0);
 #endif
 	return do_dlsym(handle, name, ventry, retaddr);
+}
 __strong_alias(__dladdr,dladdr)
 int
 dladdr(const void *addr, Dl_info *info)
+{
 	const Obj_Entry *obj;
 	const Elf_Sym *def, *best_def;
 	void *symbol_addr;
 	unsigned long symoffset;
 #ifdef __HAVE_FUNCTION_DESCRIPTORS
 	sigset_t mask;
 #endif
 	dbg(("dladdr of %p", addr));
 	lookup_mutex_enter();
 #ifdef __HAVE_FUNCTION_DESCRIPTORS
 	addr = _rtld_function_descriptor_function(addr);
 #endif /* __HAVE_FUNCTION_DESCRIPTORS */
 	obj = _rtld_obj_from_addr(addr);
 	if (obj == NULL) {
 		_rtld_error("No shared object contains address");
 		lookup_mutex_enter();
 		return 0;
+	}
 	info->dli_fname = obj->path;
 	info->dli_fbase = obj->mapbase;
 	info->dli_saddr = (void *)0;
 	info->dli_sname = NULL;
 	/*
 	 * Walk the symbol list looking for the symbol whose address is
 	 * closest to the address sent in.
 	 */
 	best_def = NULL;
 	for (symoffset = 0; symoffset < obj->nchains; symoffset++) {
 		def = obj->symtab + symoffset;
 		/*
 		 * For skip the symbol if st_shndx is either SHN_UNDEF or
 		 * SHN_COMMON.
 		 */
 		if (def->st_shndx == SHN_UNDEF || def->st_shndx == SHN_COMMON)
 			continue;
 		/*
 		 * If the symbol is greater than the specified address, or if it
 		 * is further away from addr than the current nearest symbol,
 		 * then reject it.
 		 */
 		symbol_addr = obj->relocbase + def->st_value;
 		if (symbol_addr > addr || symbol_addr < info->dli_saddr)
 			continue;
 		/* Update our idea of the nearest symbol. */
 		info->dli_sname = obj->strtab + def->st_name;

 @@ -1,457 +1,464 @@
-/*	$NetBSD: rtld.h,v 1.107 2011/12/02 09:06:49 skrll Exp $	 */
+/*	$NetBSD: rtld.h,v 1.107.4.1 2013/01/22 21:47:28 matt Exp $	 */
 /*
  * Copyright 1996 John D. Polstra.
  * Copyright 1996 Matt Thomas <matt@3am-software.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. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
  *      This product includes software developed by John Polstra.
  * 4. The name of the author may not be used to endorse or promote products
  *    derived from this software without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
  */
 #ifndef RTLD_H
 #define RTLD_H
 #include <dlfcn.h>
 #include <signal.h>
 #include <stdbool.h>
 #include <stddef.h>
 #include <sys/param.h>
 #include <sys/types.h>
 #include <sys/queue.h>
 #include <sys/exec_elf.h>
 #include <sys/tls.h>
 #include "rtldenv.h"
 #include "link.h"
 #if defined(_RTLD_SOURCE)
 #ifndef	RTLD_DEFAULT_LIBRARY_PATH
 #define	RTLD_DEFAULT_LIBRARY_PATH	"/usr/lib"
 #endif
 #define _PATH_LD_HINTS			"/etc/ld.so.conf"
 extern size_t _rtld_pagesz;
 #define round_down(x)	((x) & ~(_rtld_pagesz - 1))
 #define round_up(x)	round_down((x) + _rtld_pagesz - 1)
 #define NEW(type)	((type *) xmalloc(sizeof(type)))
 #define CNEW(type)	((type *) xcalloc(sizeof(type)))
 /*
  * Fill in a DoneList with an allocation large enough to hold all of
  * the currently-loaded objects. Keep this in a macro since it calls
  * alloca and we want that to occur within the scope of the caller.
  */
 #define _rtld_donelist_init(dlp)					\
     ((dlp)->num_alloc = _rtld_objcount,					\
     (dlp)->objs = alloca((dlp)->num_alloc * sizeof((dlp)->objs[0])),	\
     assert((dlp)->objs != NULL),					\
     (dlp)->num_used = 0)
 #endif /* _RTLD_SOURCE */
 /*
  * C++ has mandated the use of the following keywords for its new boolean
  * type.  We might as well follow their lead.
  */
 struct Struct_Obj_Entry;
 typedef struct Struct_Objlist_Entry {
 	SIMPLEQ_ENTRY(Struct_Objlist_Entry) link;
 	struct Struct_Obj_Entry *obj;
 } Objlist_Entry;
 typedef SIMPLEQ_HEAD(Struct_Objlist, Struct_Objlist_Entry) Objlist;
 typedef struct Struct_Name_Entry {
 	STAILQ_ENTRY(Struct_Name_Entry)	link;
 	char	name[1];
 } Name_Entry;
 typedef struct Struct_Needed_Entry {
 	struct Struct_Needed_Entry *next;
 	struct Struct_Obj_Entry *obj;
 	unsigned long   name;	/* Offset of name in string table */
 } Needed_Entry;
 typedef struct _rtld_search_path_t {
 	struct _rtld_search_path_t *sp_next;
 	const char     *sp_path;
 	size_t          sp_pathlen;
 } Search_Path;
 typedef struct Struct_Ver_Entry {
 	Elf_Word        hash;
 	u_int           flags;
 	const char     *name;
 	const char     *file;
 } Ver_Entry;
 /* Ver_Entry.flags */
 #define VER_INFO_HIDDEN	0x01
 #define RTLD_MAX_ENTRY 10
 #define RTLD_MAX_LIBRARY 4
 #define RTLD_MAX_CTL 2
 typedef struct _rtld_library_xform_t {
 	struct _rtld_library_xform_t *next;
 	char *name;
 	const char *ctlname;
 	struct {
 		char *value;
 		char *library[RTLD_MAX_LIBRARY];
 	} entry[RTLD_MAX_ENTRY];
 } Library_Xform;
 /*
  * Shared object descriptor.
+ *
  * Items marked with "(%)" are dynamically allocated, and must be freed
  * when the structure is destroyed.
+ *
  * The layout of this structure needs to be preserved because pre-2.0 binaries
  * hard-coded the location of dlopen() and friends.
  */
 #define RTLD_MAGIC	0xd550b87a
 #define RTLD_VERSION	1
 typedef void (*fptr_t)(void);
 typedef struct Struct_Obj_Entry {
 	Elf32_Word      magic;		/* Magic number (sanity check) */
 	Elf32_Word      version;	/* Version number of struct format */
 	struct Struct_Obj_Entry *next;
 	char           *path;		/* Pathname of underlying file (%) */
 	int             refcount;
 	int             dl_refcount;	/* Number of times loaded by dlopen */
 	/* These items are computed by map_object() or by digest_phdr(). */
 	caddr_t         mapbase;	/* Base address of mapped region */
 	size_t          mapsize;	/* Size of mapped region in bytes */
 	size_t          textsize;	/* Size of text segment in bytes */
 	Elf_Addr        vaddrbase;	/* Base address in shared object file */
 	caddr_t         relocbase;	/* Reloc const = mapbase - *vaddrbase */
 	Elf_Dyn        *dynamic;	/* Dynamic section */
 	caddr_t         entry;		/* Entry point */
 	const Elf_Phdr *phdr;		/* Program header (may be xmalloc'ed) */
 	size_t		phsize;		/* Size of program header in bytes */
 	/* Items from the dynamic section. */
 	Elf_Addr       *pltgot;		/* PLTGOT table */
 	const Elf_Rel  *rel;		/* Relocation entries */
 	const Elf_Rel  *rellim;		/* Limit of Relocation entries */
 	const Elf_Rela *rela;		/* Relocation entries */
 	const Elf_Rela *relalim;	/* Limit of Relocation entries */
 	const Elf_Rel  *pltrel;		/* PLT relocation entries */
 	const Elf_Rel  *pltrellim;	/* Limit of PLT relocation entries */
 	const Elf_Rela *pltrela;	/* PLT relocation entries */
 	const Elf_Rela *pltrelalim;	/* Limit of PLT relocation entries */
 	const Elf_Sym  *symtab;		/* Symbol table */
 	const char     *strtab;		/* String table */
 	unsigned long   strsize;	/* Size in bytes of string table */
 #ifdef __mips__
 	Elf_Word        local_gotno;	/* Number of local GOT entries */
 	Elf_Word        symtabno;	/* Number of dynamic symbols */
 	Elf_Word        gotsym;		/* First dynamic symbol in GOT */
 #endif
 	const Elf_Symindx *buckets;	/* Hash table buckets array */
 	unsigned long	unused1;	/* Used to be nbuckets */
 	const Elf_Symindx *chains;	/* Hash table chain array */
 	unsigned long   nchains;	/* Number of chains */
 	Search_Path    *rpaths;		/* Search path specified in object */
 	Needed_Entry   *needed;		/* Shared objects needed by this (%) */
-	void            (*init)(void); 	/* Initialization function to call */
+	fptr_t		init;		/* Initialization function to call */
-	void            (*fini)(void);	/* Termination function to call */
+	fptr_t		fini;		/* Termination function to call */
 	/*
 	 * BACKWARDS COMPAT Entry points for dlopen() and friends.
+	 *
 	 * DO NOT MOVE OR ADD TO THE LIST
+	 *
 	 */
 	void           *(*dlopen)(const char *, int);
 	void           *(*dlsym)(void *, const char *);
 	char           *(*dlerror)(void);
 	int             (*dlclose)(void *);
 	int             (*dladdr)(const void *, Dl_info *);
 	u_int32_t	mainprog:1,	/* True if this is the main program */
 	        	rtld:1,		/* True if this is the dynamic linker */
 			textrel:1,	/* True if there are relocations to
 					 * text seg */
 			symbolic:1,	/* True if generated with
 					 * "-Bsymbolic" */
 			printed:1,	/* True if ldd has printed it */
 			isdynamic:1,	/* True if this is a pure PIC object */
 			mainref:1,	/* True if on _rtld_list_main */
 			globalref:1,	/* True if on _rtld_list_global */
 			init_done:1,	/* True if .init has been added */
 			init_called:1,	/* True if .init function has been
 					 * called */
 			fini_called:1,	/* True if .fini function has been
 					 * called */
 			z_now:1,	/* True if object's symbols should be
 					   bound immediately */
 			z_nodelete:1,	/* True if object should never be
 					   unloaded */
 			z_initfirst:1,	/* True if object's .init/.fini take
 					 * priority over others */
 			z_noopen:1,	/* True if object should never be
 					   dlopen'ed */
 			phdr_loaded:1,	/* Phdr is loaded and doesn't need to
 					 * be freed. */
 #if defined(__HAVE_TLS_VARIANT_I) || defined(__HAVE_TLS_VARIANT_II)
 			tls_done:1,	/* True if static TLS offset
 					 * has been allocated */
 #endif
 			ref_nodel:1;	/* Refcount increased to prevent dlclose */
 	struct link_map linkmap;	/* for GDB */
 	/* These items are computed by map_object() or by digest_phdr(). */
 	const char     *interp;	/* Pathname of the interpreter, if any */
 	Objlist         dldags;	/* Object belongs to these dlopened DAGs (%) */
 	Objlist         dagmembers;	/* DAG has these members (%) */
 	dev_t           dev;		/* Object's filesystem's device */
 	ino_t           ino;		/* Object's inode number */
 	void		*ehdr;
 	uint32_t        nbuckets;	/* Number of buckets */
 	uint32_t        nbuckets_m;	/* Precomputed for fast remainder */
 	uint8_t         nbuckets_s1;
 	uint8_t         nbuckets_s2;
 	size_t		pathlen;	/* Pathname length */
 	STAILQ_HEAD(, Struct_Name_Entry) names;	/* List of names for this object we
 						   know about. */
 #ifdef __powerpc__
 	Elf_Addr       *gotptr;		/* GOT table (secure-plt only) */
 #endif
 #if defined(__HAVE_TLS_VARIANT_I) || defined(__HAVE_TLS_VARIANT_II)
 	/* Thread Local Storage support for this module */
 	size_t		tlsindex;	/* Index in DTV */
 	void		*tlsinit;	/* Base address of TLS init block */
 	size_t		tlsinitsize;	/* Size of TLS init block */
 	size_t		tlssize;	/* Size of TLS block */
 	size_t		tlsoffset;	/* Offset in the static TLS block */
 	size_t		tlsalign;	/* Needed alignment for static TLS */
 #endif
 	/* symbol versioning */
 	const Elf_Verneed *verneed;	/* Required versions. */
 	Elf_Word	verneednum;	/* Number of entries in verneed table */
 	const Elf_Verdef  *verdef;	/* Provided versions. */
 	Elf_Word	verdefnum;	/* Number of entries in verdef table */
 	const Elf_Versym *versyms;	/* Symbol versions table */
 	Ver_Entry	*vertab;	/* Versions required/defined by this
 					 * object */
 	int		vertabnum;	/* Number of entries in vertab */
 	/* init_array/fini_array */
 	fptr_t		*init_array;	/* start of init array */
 	size_t		init_arraysz;	/* # of entries in it */
 	fptr_t		*fini_array;	/* start of fini array */
 	size_t		fini_arraysz;	/* # of entries in it */
 } Obj_Entry;
 typedef struct Struct_DoneList {
 	const Obj_Entry **objs;		/* Array of object pointers */
 	unsigned int num_alloc;		/* Allocated size of the array */
 	unsigned int num_used;		/* Number of array slots used */
 } DoneList;
 #if defined(_RTLD_SOURCE)
 extern struct r_debug _rtld_debug;
 extern Search_Path *_rtld_default_paths;
 extern Obj_Entry *_rtld_objlist;
 extern Obj_Entry **_rtld_objtail;
 extern u_int _rtld_objcount;
 extern u_int _rtld_objloads;
 extern Obj_Entry *_rtld_objmain;
 extern Obj_Entry _rtld_objself;
 extern Search_Path *_rtld_paths;
 extern Library_Xform *_rtld_xforms;
 extern bool _rtld_trust;
 extern Objlist _rtld_list_global;
 extern Objlist _rtld_list_main;
 extern Elf_Sym _rtld_sym_zero;
 #define	RTLD_MODEMASK 0x3
 /* Flags to be passed into _rtld_symlook_ family of functions. */
 #define SYMLOOK_IN_PLT	0x01	/* Lookup for PLT symbol */
 #define SYMLOOK_DLSYM	0x02	/* Return newes versioned symbol.
 				   Used by dlsym. */
 /* Flags for _rtld_load_object() and friends. */
 #define	_RTLD_GLOBAL	0x01	/* Add object to global DAG. */
 #define	_RTLD_MAIN	0x02
 #define	_RTLD_NOLOAD	0x04	/* dlopen() specified RTLD_NOLOAD. */
 #define	_RTLD_DLOPEN	0x08	/* Load_object() called from dlopen(). */
 /* Preallocation for static TLS model */
 #define	RTLD_STATIC_TLS_RESERVATION	64
 /* rtld.c */
 /* We export these symbols using _rtld_symbol_lookup and is_exported. */
 __dso_public char *dlerror(void);
 __dso_public void *dlopen(const char *, int);
 __dso_public void *dlsym(void *, const char *);
 __dso_public int dlclose(void *);
 __dso_public int dladdr(const void *, Dl_info *);
 __dso_public int dlinfo(void *, int, void *);
 __dso_public int dl_iterate_phdr(int (*)(struct dl_phdr_info *, size_t, void *),
     void *);
 /* These aren't exported */
 void _rtld_error(const char *, ...)
      __attribute__((__format__(__printf__,1,2)));
 void _rtld_die(void) __attribute__((__noreturn__));
 void *_rtld_objmain_sym(const char *);
 __dso_public void _rtld_debug_state(void);
 void _rtld_linkmap_add(Obj_Entry *);
 void _rtld_linkmap_delete(Obj_Entry *);
 void _rtld_objlist_push_head(Objlist *, Obj_Entry *);
 void _rtld_objlist_push_tail(Objlist *, Obj_Entry *);
 Objlist_Entry *_rtld_objlist_find(Objlist *, const Obj_Entry *);
 void _rtld_ref_dag(Obj_Entry *);
 void _rtld_shared_enter(void);
 void _rtld_shared_exit(void);
 void _rtld_exclusive_enter(sigset_t *);
 void _rtld_exclusive_exit(sigset_t *);
 /* expand.c */
 size_t _rtld_expand_path(char *, size_t, const char *, const char *,\
     const char *);
 /* headers.c */
 void _rtld_digest_dynamic(const char *, Obj_Entry *);
 Obj_Entry *_rtld_digest_phdr(const Elf_Phdr *, int, caddr_t);
 /* load.c */
 Obj_Entry *_rtld_load_object(const char *, int);
 int _rtld_load_needed_objects(Obj_Entry *, int);
 int _rtld_preload(const char *);
 #define	OBJ_ERR	(Obj_Entry *)(-1)
 /* path.c */
 void _rtld_add_paths(const char *, Search_Path **, const char *);
 void _rtld_process_hints(const char *, Search_Path **, Library_Xform **,
     const char *);
 int _rtld_sysctl(const char *, void *, size_t *);
 /* reloc.c */
 int _rtld_do_copy_relocations(const Obj_Entry *);
 int _rtld_relocate_objects(Obj_Entry *, bool);
 int _rtld_relocate_nonplt_objects(Obj_Entry *);
 int _rtld_relocate_plt_lazy(const Obj_Entry *);
 int _rtld_relocate_plt_objects(const Obj_Entry *);
 void _rtld_setup_pltgot(const Obj_Entry *);
 /* search.c */
 Obj_Entry *_rtld_load_library(const char *, const Obj_Entry *, int);
 /* symbol.c */
 unsigned long _rtld_elf_hash(const char *);
 const Elf_Sym *_rtld_symlook_obj(const char *, unsigned long,
     const Obj_Entry *, u_int, const Ver_Entry *);
 const Elf_Sym *_rtld_find_symdef(unsigned long, const Obj_Entry *,
     const Obj_Entry **, u_int);
 const Elf_Sym *_rtld_find_plt_symdef(unsigned long, const Obj_Entry *,
     const Obj_Entry **, bool);
 const Elf_Sym *_rtld_symlook_list(const char *, unsigned long,
     const Objlist *, const Obj_Entry **, u_int, const Ver_Entry *, DoneList *);
 const Elf_Sym *_rtld_symlook_default(const char *, unsigned long,
     const Obj_Entry *, const Obj_Entry **, u_int, const Ver_Entry *);
 const Elf_Sym *_rtld_symlook_needed(const char *, unsigned long,
     const Needed_Entry *, const Obj_Entry **, u_int, const Ver_Entry *,
     DoneList *, DoneList *);
 #ifdef COMBRELOC
 void _rtld_combreloc_reset(const Obj_Entry *);
 #endif
 /* symver.c */
 int _rtld_object_match_name(const Obj_Entry *, const char *);
 int _rtld_verify_object_versions(Obj_Entry *);
 static __inline const Ver_Entry *
 _rtld_fetch_ventry(const Obj_Entry *obj, unsigned long symnum)
+{
 	Elf_Half vernum;
 	if (obj->vertab) {
 		vernum = VER_NDX(obj->versyms[symnum].vs_vers);
 		if (vernum >= obj->vertabnum) {
 			_rtld_error("%s: symbol %s has wrong verneed value %d",
 			    obj->path, &obj->strtab[symnum], vernum);
 		} else if (obj->vertab[vernum].hash) {
 			return &obj->vertab[vernum];
+		}
+	}
 	return NULL;
+}
 #if defined(__HAVE_TLS_VARIANT_I) || defined(__HAVE_TLS_VARIANT_II)
 /* tls.c */
 void *_rtld_tls_get_addr(void *, size_t, size_t);
 void _rtld_tls_initial_allocation(void);
 void *_rtld_tls_module_allocate(size_t index);
 int _rtld_tls_offset_allocate(Obj_Entry *);
 void _rtld_tls_offset_free(Obj_Entry *);
 extern size_t _rtld_tls_dtv_generation;
 extern size_t _rtld_tls_max_index;
 __dso_public extern void *__tls_get_addr(void *);
 #ifdef __i386__
 __dso_public extern void *___tls_get_addr(void *)
     __attribute__((__regparm__(1)));
 #endif
 #endif
 /* map_object.c */
 struct stat;
 Obj_Entry *_rtld_map_object(const char *, int, const struct stat *);
 void _rtld_obj_free(Obj_Entry *);
 Obj_Entry *_rtld_obj_new(void);
 /* function descriptors */
 #ifdef __HAVE_FUNCTION_DESCRIPTORS
 Elf_Addr _rtld_function_descriptor_alloc(const Obj_Entry *,
     const Elf_Sym *, Elf_Addr);
 const void *_rtld_function_descriptor_function(const void *);
 #endif /* __HAVE_FUNCTION_DESCRIPTORS */
 #endif /* _RTLD_SOURCE */
 #endif /* RTLD_H */

 @@ -1,583 +1,581 @@
-/*	$NetBSD: symbol.c,v 1.59 2011/11/25 14:39:02 joerg Exp $	 */
+/*	$NetBSD: symbol.c,v 1.59.4.1 2013/01/22 21:47:28 matt Exp $	 */
 /*
  * Copyright 1996 John D. Polstra.
  * Copyright 1996 Matt Thomas <matt@3am-software.com>
  * Copyright 2002 Charles M. Hannum <root@ihack.net>
  * 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. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
  *      This product includes software developed by John Polstra.
  * 4. The name of the author may not be used to endorse or promote products
  *    derived from this software without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
  */
 /*
  * Dynamic linker for ELF.
+ *
  * John Polstra <jdp@polstra.com>.
  */
 #include <sys/cdefs.h>
 #ifndef lint
-__RCSID("$NetBSD: symbol.c,v 1.59 2011/11/25 14:39:02 joerg Exp $");
+__RCSID("$NetBSD: symbol.c,v 1.59.4.1 2013/01/22 21:47:28 matt Exp $");
 #endif /* not lint */
 #include <err.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <stdarg.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include <sys/types.h>
 #include <sys/mman.h>
 #include <sys/bitops.h>
 #include <dirent.h>
 #include "debug.h"
 #include "rtld.h"
 typedef void (*fptr_t)(void);
 /*
  * If the given object is already in the donelist, return true.  Otherwise
  * add the object to the list and return false.
  */
 static bool
 _rtld_donelist_check(DoneList *dlp, const Obj_Entry *obj)
+{
 	unsigned int i;
 	for (i = 0;  i < dlp->num_used;  i++)
 		if (dlp->objs[i] == obj)
 			return true;
 	/*
 	 * Our donelist allocation may not always be sufficient as we're not
 	 * thread safe. We'll handle it properly anyway.
 	 */
 	if (dlp->num_used < dlp->num_alloc)
 		dlp->objs[dlp->num_used++] = obj;
 	return false;
+}
 static bool
 _rtld_is_exported(const Elf_Sym *def)
+{
 	static const fptr_t _rtld_exports[] = {
 		(fptr_t)dlopen,
 		(fptr_t)dlclose,
 		(fptr_t)dlsym,
 		(fptr_t)dlvsym,
 		(fptr_t)dlerror,
 		(fptr_t)dladdr,
 		(fptr_t)dlinfo,
 		(fptr_t)dl_iterate_phdr,
 #if defined(__HAVE_TLS_VARIANT_I) || defined(__HAVE_TLS_VARIANT_II)
 		(fptr_t)_rtld_tls_allocate,
 		(fptr_t)_rtld_tls_free,
 		(fptr_t)__tls_get_addr,
 #ifdef __i386__
 		(fptr_t)___tls_get_addr,
 #endif
 #endif
 		NULL
 	};
 	int i;
 	fptr_t value;
 	value = (fptr_t)(_rtld_objself.relocbase + def->st_value);
 	for (i = 0; _rtld_exports[i] != NULL; i++) {
 		if (value == _rtld_exports[i])
 			return true;
+	}
 	return false;
+}
 /*
  * Hash function for symbol table lookup.  Don't even think about changing
  * this.  It is specified by the System V ABI.
  */
 unsigned long
 _rtld_elf_hash(const char *name)
+{
 	const unsigned char *p = (const unsigned char *) name;
 	unsigned long   h = 0;
 	unsigned long   g;
 	unsigned long   c;
 	for (; __predict_true((c = *p) != '\0'); p++) {
 		h <<= 4;
 		h += c;
 		if ((g = h & 0xf0000000) != 0) {
 			h ^= g;
 			h ^= g >> 24;
+		}
+	}
 	return (h);
+}
 const Elf_Sym *
 _rtld_symlook_list(const char *name, unsigned long hash, const Objlist *objlist,
     const Obj_Entry **defobj_out, u_int flags, const Ver_Entry *ventry,
     DoneList *dlp)
+{
 	const Elf_Sym *symp;
 	const Elf_Sym *def;
 	const Obj_Entry *defobj;
 	const Objlist_Entry *elm;
 	def = NULL;
 	defobj = NULL;
 	SIMPLEQ_FOREACH(elm, objlist, link) {
 		if (_rtld_donelist_check(dlp, elm->obj))
 			continue;
 		rdbg(("search object %p (%s) for %s", elm->obj, elm->obj->path,
 		    name));
 		symp = _rtld_symlook_obj(name, hash, elm->obj, flags, ventry);
 		if (symp != NULL) {
 			if ((def == NULL) ||
 			    (ELF_ST_BIND(symp->st_info) != STB_WEAK)) {
 				def = symp;
 				defobj = elm->obj;
 				if (ELF_ST_BIND(def->st_info) != STB_WEAK)
 					break;
+			}
+		}
+	}
 	if (def != NULL)
 		*defobj_out = defobj;
 	return def;
+}
 /*
  * Search the symbol table of a shared object and all objects needed by it for
  * a symbol of the given name. Search order is breadth-first. Returns a pointer
  * to the symbol, or NULL if no definition was found.
  */
 const Elf_Sym *
 _rtld_symlook_needed(const char *name, unsigned long hash,
     const Needed_Entry *needed, const Obj_Entry **defobj_out, u_int flags,
     const Ver_Entry *ventry, DoneList *breadth, DoneList *depth)
+{
 	const Elf_Sym *def, *def_w;
 	const Needed_Entry *n;
 	const Obj_Entry *obj, *defobj, *defobj1;
 	def = def_w = NULL;
 	defobj = NULL;
 	for (n = needed; n != NULL; n = n->next) {
 		if ((obj = n->obj) == NULL)
 			continue;
 		if (_rtld_donelist_check(breadth, obj))
 			continue;
 		def = _rtld_symlook_obj(name, hash, obj, flags, ventry);
 		if (def == NULL)
 			continue;
 		defobj = obj;
 		if (ELF_ST_BIND(def->st_info) != STB_WEAK) {
 			*defobj_out = defobj;
 			return (def);
+		}
+	}
 	/*
 	 * Either the symbol definition has not been found in directly needed
 	 * objects, or the found symbol is weak.
 	 */
 	for (n = needed; n != NULL; n = n->next) {
 		if ((obj = n->obj) == NULL)
 			continue;
 		if (_rtld_donelist_check(depth, obj))
 			continue;
 		def_w = _rtld_symlook_needed(name, hash, obj->needed, &defobj1,
 		    flags, ventry, breadth, depth);
 		if (def_w == NULL)
 			continue;
 		if (def == NULL || ELF_ST_BIND(def_w->st_info) != STB_WEAK) {
 			def = def_w;
 			defobj = defobj1;
 			if (ELF_ST_BIND(def_w->st_info) != STB_WEAK)
 				break;
+		}
+	}
 	if (def != NULL)
 		*defobj_out = defobj;
 	return def;
+}
 /*
  * Search the symbol table of a single shared object for a symbol of
  * the given name.  Returns a pointer to the symbol, or NULL if no
  * definition was found.
+ *
  * The symbol's hash value is passed in for efficiency reasons; that
  * eliminates many recomputations of the hash value.
  */
 const Elf_Sym *
 _rtld_symlook_obj(const char *name, unsigned long hash,
     const Obj_Entry *obj, u_int flags, const Ver_Entry *ventry)
+{
 	unsigned long symnum;
 	const Elf_Sym *vsymp = NULL;
 	Elf_Half verndx;
 	int vcount = 0;
 	for (symnum = obj->buckets[fast_remainder32(hash, obj->nbuckets,
 	     obj->nbuckets_m, obj->nbuckets_s1, obj->nbuckets_s2)];
 	     symnum != ELF_SYM_UNDEFINED;
 	     symnum = obj->chains[symnum]) {
 		const Elf_Sym  *symp;
 		const char     *strp;
 		assert(symnum < obj->nchains);
 		symp = obj->symtab + symnum;
 		strp = obj->strtab + symp->st_name;
 		rdbg(("check \"%s\" vs \"%s\" in %s", name, strp, obj->path));
 		if (name[1] != strp[1] || strcmp(name, strp))
 			continue;
 #ifdef __mips__
 		if (symp->st_shndx == SHN_UNDEF)
 			continue;
 #else
 		/*
 		 * XXX DANGER WILL ROBINSON!
 		 * If we have a function pointer in the executable's
 		 * data section, it points to the executable's PLT
 		 * slot, and there is NO relocation emitted.  To make
 		 * the function pointer comparable to function pointers
 		 * in shared libraries, we must resolve data references
 		 * in the libraries to point to PLT slots in the
 		 * executable, if they exist.
 		 */
 		if (symp->st_shndx == SHN_UNDEF &&
 		    ((flags & SYMLOOK_IN_PLT) ||
 		    symp->st_value == 0 ||
 		    ELF_ST_TYPE(symp->st_info) != STT_FUNC))
 			continue;
 #endif
 		if (ventry == NULL) {
 			if (obj->versyms != NULL) {
 				verndx = VER_NDX(obj->versyms[symnum].vs_vers);
 				if (verndx > obj->vertabnum) {
 					_rtld_error("%s: symbol %s references "
 					    "wrong version %d", obj->path,
 					    &obj->strtab[symnum], verndx);
 					continue;
+				}
 				/*
 				 * If we are not called from dlsym (i.e. this
 				 * is a normal relocation from unversioned
 				 * binary), accept the symbol immediately
 				 * if it happens to have first version after
 				 * this shared object became versioned.
 				 * Otherwise, if symbol is versioned and not
 				 * hidden, remember it. If it is the only
 				 * symbol with this name exported by the shared
 				 * object, it will be returned as a match at the
 				 * end of the function. If symbol is global
 				 * (verndx < 2) accept it unconditionally.
 				 */
 				if (!(flags & SYMLOOK_DLSYM) &&
 				    verndx == VER_NDX_GIVEN) {
 					return symp;
 				} else if (verndx >= VER_NDX_GIVEN) {
 					if (!(obj->versyms[symnum].vs_vers & VER_NDX_HIDDEN)) {
 						if (vsymp == NULL)
 							vsymp = symp;
 						vcount++;
+					}
 					continue;
+				}
+			}
 			return symp;
 		} else {
 			if (obj->versyms == NULL) {
 				if (_rtld_object_match_name(obj, ventry->name)){
 					_rtld_error("%s: object %s should "
 					    "provide version %s for symbol %s",
 					    _rtld_objself.path, obj->path,
 					    ventry->name, &obj->strtab[symnum]);
 					continue;
+				}
 			} else {
 				verndx = VER_NDX(obj->versyms[symnum].vs_vers);
 				if (verndx > obj->vertabnum) {
 					_rtld_error("%s: symbol %s references "
 					    "wrong version %d", obj->path,
 					    &obj->strtab[symnum], verndx);
 					continue;
+				}
 				if (obj->vertab[verndx].hash != ventry->hash ||
 				    strcmp(obj->vertab[verndx].name, ventry->name)) {
 					/*
 					* Version does not match. Look if this
 					* is a global symbol and if it is not
 					* hidden. If global symbol (verndx < 2)
 					* is available, use it. Do not return
 					* symbol if we are called by dlvsym,
 					* because dlvsym looks for a specific
 					* version and default one is not what
 					* dlvsym wants.
 					*/
 					if ((flags & SYMLOOK_DLSYM) ||
 					    (obj->versyms[symnum].vs_vers & VER_NDX_HIDDEN) ||
 					    (verndx >= VER_NDX_GIVEN))
 						continue;
+				}
+			}
 			return symp;
+		}
+	}
 	if (vcount == 1)
 		return vsymp;
 	return NULL;
+}
 #ifdef COMBRELOC
 static const Obj_Entry *_rtld_last_refobj;
 /*
  * Called when an object is freed. Reset the cached symbol look up if
  * our last referencing or definition object just got unloaded.
  */
 void
 _rtld_combreloc_reset(const Obj_Entry *obj)
+{
 	if (_rtld_last_refobj == obj)
 		_rtld_last_refobj = NULL;
+}
 #endif
 /*
  * Given a symbol number in a referencing object, find the corresponding
  * definition of the symbol.  Returns a pointer to the symbol, or NULL if
  * no definition was found.  Returns a pointer to the Obj_Entry of the
  * defining object via the reference parameter DEFOBJ_OUT.
  */
 const Elf_Sym *
 _rtld_find_symdef(unsigned long symnum, const Obj_Entry *refobj,
     const Obj_Entry **defobj_out, u_int flags)
+{
 	const Elf_Sym  *ref;
 	const Elf_Sym  *def;
 	const Obj_Entry *defobj;
 	const char     *name;
 	unsigned long   hash;
 #ifdef COMBRELOC
 	/*
 	 * COMBRELOC combines multiple reloc sections and sorts them to make
 	 * dynamic symbol lookup caching possible.
+	 *
 	 * So if the lookup we are doing is the same as the previous lookup
 	 * return the cached results.
 	 */
 	static unsigned long last_symnum;
 	static const Obj_Entry *last_defobj;
 	static const Elf_Sym *last_def;
 	if (symnum == last_symnum && refobj == _rtld_last_refobj
 	    && !(flags & SYMLOOK_IN_PLT)) {
 		*defobj_out = last_defobj;
 		return last_def;
+	}
 #endif
 	ref = refobj->symtab + symnum;
 	name = refobj->strtab + ref->st_name;
 	/*
 	 * We don't have to do a full scale lookup if the symbol is local.
 	 * We know it will bind to the instance in this load module; to
 	 * which we already have a pointer (ie ref).
 	 */
 	if (ELF_ST_BIND(ref->st_info) != STB_LOCAL) {
 		if (ELF_ST_TYPE(ref->st_info) == STT_SECTION) {
 			_rtld_error("%s: Bogus symbol table entry %lu",
 			    refobj->path, symnum);
+        	}
 		hash = _rtld_elf_hash(name);
 		defobj = NULL;
 		def = _rtld_symlook_default(name, hash, refobj, &defobj, flags,
 		    _rtld_fetch_ventry(refobj, symnum));
 	} else {
 		rdbg(("STB_LOCAL symbol %s in %s", name, refobj->path));
 		def = ref;
 		defobj = refobj;
+	}
 	/*
 	 * If we found no definition and the reference is weak, treat the
 	 * symbol as having the value zero.
 	 */
 	if (def == NULL && ELF_ST_BIND(ref->st_info) == STB_WEAK) {
 		rdbg(("  returning _rtld_sym_zero@_rtld_objself"));
 		def = &_rtld_sym_zero;
 		defobj = &_rtld_objself;
+	}
 	if (def != NULL) {
 		*defobj_out = defobj;
 #ifdef COMBRELOC
 		if (!(flags & SYMLOOK_IN_PLT)) {
 			/*
 			 * Cache the lookup arguments and results if this was
 			 * non-PLT lookup.
 			 */
 			last_symnum = symnum;
 			_rtld_last_refobj = refobj;
 			last_def = def;
 			last_defobj = defobj;
+		}
 #endif
 	} else {
 		rdbg(("lookup failed"));
 		_rtld_error("%s: Undefined %ssymbol \"%s\" (symnum = %ld)",
 		    refobj->path, (flags & SYMLOOK_IN_PLT) ? "PLT " : "",
 		    name, symnum);
+	}
 	return def;
+}
 const Elf_Sym *
 _rtld_find_plt_symdef(unsigned long symnum, const Obj_Entry *obj,
     const Obj_Entry **defobj, bool imm)
+{
  	const Elf_Sym  *def = _rtld_find_symdef(symnum, obj, defobj,
 	    SYMLOOK_IN_PLT);
 	if (__predict_false(def == NULL))
  		return NULL;
 	if (__predict_false(def == &_rtld_sym_zero)) {
 		/* tp is set during lazy binding. */
 		if (imm) {
 			const Elf_Sym	*ref = obj->symtab + symnum;
 			const char	*name = obj->strtab + ref->st_name;
 			_rtld_error(
 			    "%s: Trying to call undefined weak symbol `%s'",
 			    obj->path, name);
 			return NULL;
+		}
+	}
 	return def;
+}
 /*
  * Given a symbol name in a referencing object, find the corresponding
  * definition of the symbol.  Returns a pointer to the symbol, or NULL if
  * no definition was found.  Returns a pointer to the Obj_Entry of the
  * defining object via the reference parameter DEFOBJ_OUT.
  */
 const Elf_Sym *
 _rtld_symlook_default(const char *name, unsigned long hash,
     const Obj_Entry *refobj, const Obj_Entry **defobj_out, u_int flags,
     const Ver_Entry *ventry)
+{
 	const Elf_Sym *def;
 	const Elf_Sym *symp;
 	const Obj_Entry *obj;
 	const Obj_Entry *defobj;
 	const Objlist_Entry *elm;
 	def = NULL;
 	defobj = NULL;
 	DoneList donelist;
 	_rtld_donelist_init(&donelist);
 	/* Look first in the referencing object if linked symbolically. */
 	if (refobj->symbolic && !_rtld_donelist_check(&donelist, refobj)) {
 		rdbg(("search referencing object for %s", name));
 		symp = _rtld_symlook_obj(name, hash, refobj, flags, ventry);
 		if (symp != NULL) {
 			def = symp;
 			defobj = refobj;
+		}
+	}
 	/* Search all objects loaded at program start up. */
 	if (def == NULL || ELF_ST_BIND(def->st_info) == STB_WEAK) {
 		rdbg(("search _rtld_list_main for %s", name));
 		symp = _rtld_symlook_list(name, hash, &_rtld_list_main, &obj,
 		    flags, ventry, &donelist);
 		if (symp != NULL &&
 		    (def == NULL || ELF_ST_BIND(symp->st_info) != STB_WEAK)) {
 			def = symp;
 			defobj = obj;
+		}
+	}
 	/* Search all RTLD_GLOBAL objects. */
 	if (def == NULL || ELF_ST_BIND(def->st_info) == STB_WEAK) {
 		rdbg(("search _rtld_list_global for %s", name));
 		symp = _rtld_symlook_list(name, hash, &_rtld_list_global,
 		    &obj, flags, ventry, &donelist);
 		if (symp != NULL &&
 		    (def == NULL || ELF_ST_BIND(symp->st_info) != STB_WEAK)) {
 			def = symp;
 			defobj = obj;
+		}
+	}
 	/* Search all dlopened DAGs containing the referencing object. */
 	SIMPLEQ_FOREACH(elm, &refobj->dldags, link) {
 		if (def != NULL && ELF_ST_BIND(def->st_info) != STB_WEAK)
 			break;
 		rdbg(("search DAG with root %p (%s) for %s", elm->obj,
 		    elm->obj->path, name));
 		symp = _rtld_symlook_list(name, hash, &elm->obj->dagmembers,
 		    &obj, flags, ventry, &donelist);
 		if (symp != NULL &&
 		    (def == NULL || ELF_ST_BIND(symp->st_info) != STB_WEAK)) {
 			def = symp;
 			defobj = obj;
+		}
+	}
 	/*
 	 * Search the dynamic linker itself, and possibly resolve the
 	 * symbol from there.  This is how the application links to
 	 * dynamic linker services such as dlopen.  Only the values listed
 	 * in the "_rtld_exports" array can be resolved from the dynamic
 	 * linker.
 	 */
 	if (def == NULL || ELF_ST_BIND(def->st_info) == STB_WEAK) {
 		rdbg(("Search the dynamic linker itself."));
 		symp = _rtld_symlook_obj(name, hash, &_rtld_objself, flags,
 		    ventry);
 		if (symp != NULL && _rtld_is_exported(symp)) {
 			def = symp;
 			defobj = &_rtld_objself;
+		}
+	}
 	if (def != NULL)
 		*defobj_out = defobj;
 	return def;
+}

 @@ -1,146 +1,146 @@
-#	$NetBSD: Makefile,v 1.110 2011/10/07 09:15:21 mrg Exp $
+#	$NetBSD: Makefile,v 1.110.6.1 2013/01/22 21:47:27 matt Exp $
+#
 # NOTE: when changing ld.so, ensure that ldd still compiles.
+#
 WARNS?=4
 # This needs to be before bsd.init.mk
 .if defined(BSD_MK_COMPAT_FILE)
 .include <${BSD_MK_COMPAT_FILE}>
 .endif
 # We are not building this with PIE
 PIE_CFLAGS=
 PIE_LDFLAGS=
 .include <bsd.init.mk>			# for MKPIC definition
 .include <bsd.shlib.mk>			# for SHLINKINSTALLDIR definition
 .if defined(LDELFSO_MACHINE_CPU) && !empty(LDELFSO_MACHINE_CPU) && \
     exists(${.CURDIR}/arch/${LDELFSO_MACHINE_CPU})
 ARCHSUBDIR=	${LDELFSO_MACHINE_CPU}
 .else
 ARCHSUBDIR=	${MACHINE_CPU}
 .endif
 M=		${.CURDIR}/arch/${ARCHSUBDIR}
 .if ((${MACHINE_ARCH} == "alpha") ||					\
      (${MACHINE_CPU} == "arm") ||					\
      (${MACHINE_ARCH} == "hppa") ||					\
      (${MACHINE_ARCH} == "i386") ||					\
      (${MACHINE_ARCH} == "m68k") ||					\
      (${MACHINE_CPU} == "mips") ||					\
      (${MACHINE_ARCH} == "powerpc") ||					\
      (${MACHINE_CPU} == "sh3") ||					\
      (${MACHINE_ARCH} == "sparc") ||					\
      (${MACHINE_ARCH} == "sparc64") ||					\
      (${MACHINE_ARCH} == "x86_64") ||					\
      (${MACHINE_ARCH} == "vax")) &&					\
     ${MKPIC} != "no"
 LDFLAGS+=	${${ACTIVE_CC} == "clang":? -Wl,-Bsymbolic : -symbolic} \
 		-shared -nostartfiles -nodefaultlibs
 LDFLAGS+=	-Wl,-static
 LDFLAGS+=	-Wl,--warn-shared-textrel
-CFLAGS+=	-fvisibility=hidden
+COPTS+=		-fvisibility=hidden
 # Adds SRCS, CPPFLAGS, LDFLAGS, etc.  Must go first so MD startup source
 # is first.
 .if exists($M/Makefile.inc)
 .include "$M/Makefile.inc"
 .endif
 # Support compat ld.elf_so.
 .if defined(MLIBDIR)
 PROG=		ld.elf_so-${MLIBDIR}
 CPPFLAGS+=	-DRTLD_ARCH_SUBDIR=\"${MLIBDIR}\"
 .else
 PROG=		ld.elf_so
 .endif
 CLIBOBJ!=	cd ${NETBSDSRCDIR}/lib/libc && ${PRINTOBJDIR}
 SRCS+=		rtld.c reloc.c symbol.c xmalloc.c xprintf.c debug.c \
 		map_object.c load.c search.c headers.c paths.c expand.c \
 		tls.c symver.c
 .if ${USE_FORT} == "yes"
 .PATH.c: ${NETBSDSRCDIR}/lib/libc/misc
 SRCS+=		stack_protector.c
 .endif
 .PATH.c: ${NETBSDSRCDIR}/lib/libc/stdlib
 SRCS+=		exit.c
 errlist_concat.h: ${NETBSDSRCDIR}/lib/libc/gen/errlist.awk ${NETBSDSRCDIR}/sys/sys/errno.h
 	${TOOL_AWK} -v concat=1 -f ${.ALLSRC} > ${.TARGET}.tmp && \
 	mv -f ${.TARGET}.tmp ${.TARGET}
 xprintf.c: errlist_concat.h
 CLEANFILES+=	errlist_concat.h
 BINDIR=		${SHLINKINSTALLDIR}
 CPPFLAGS+=	-DLIBDIR=\"${LIBDIR}\" -D_PATH_RTLD=\"${BINDIR}/${PROG}\"
 CPPFLAGS+=	-I${.CURDIR} -I.
 CPPFLAGS+=	-DRTLD_LOADER
 CPPFLAGS+=	-D_RTLD_SOURCE
 CPPFLAGS+=	-DCOMBRELOC
 #CPPFLAGS+=	-DDEBUG
 #CPPFLAGS+=	-DRTLD_DEBUG
 #CPPFLAGS+=	-DRTLD_DEBUG_RELOC
 #DBG=		-g
-DBG=		-O3 -fomit-frame-pointer
+COPTS=		-O3 -fomit-frame-pointer
 .if ${MACHINE_ARCH} == "i386" || ${MACHINE_ARCH} == "x86_64"
-DBG+=		-mno-3dnow -mno-mmx -mno-sse -mno-sse2 -mno-sse3
+COPTS+=		-mno-3dnow -mno-mmx -mno-sse -mno-sse2 -mno-sse3
 .endif
 .if ${SHLIBDIR} != ${LIBDIR}
 CPPFLAGS+=	-DRTLD_DEFAULT_LIBRARY_PATH=\"${SHLIBDIR}:${LIBDIR}\"
 .endif
 # rtld.c and symbol.c use alloca, so disable SSP warnings.
 COPTS.rtld.c+=	-Wno-stack-protector
 COPTS.symbol.c+=-Wno-stack-protector
 LDADD+=		-L${CLIBOBJ} -L${DESTDIR}${LIBDIR}
 .if ${MKPICLIB} != "no"
 LDADD+=		-lc_pic
 .if ${MKPICINSTALL} != "no"
 DPADD+=		${LIBC_PIC}
 .endif
 DPADD+=		${CLIBOBJ}/libc_pic.a
 .else
 LDADD+=		-lc
 DPADD+=		${CLIBOBJ}/libc.a
 .endif
 .if ${MACHINE_CPU} == "hppa" || ${MACHINE_CPU} == "sh3"
 # for $$divU, $$remU etc. (millicode)
 LDADD+=		-lgcc
 DPADD+=		${LIBGCC}
 .endif
 STRIPFLAG=
 .PATH: $M
 ${PROG}: ${OBJS} ${DPADD}
 	${_MKMSG_LINK} ${PROG}
 	${CC} ${LDFLAGS} -o ${PROG} ${OBJS} ${LDADD}
 .if ${SHLINKINSTALLDIR} != "/usr/libexec"
 SYMLINKS+=	${SHLINKINSTALLDIR}/${PROG} /usr/libexec/${PROG}
 .endif
 .include <bsd.prog.mk>
 .else
 MAN=		ld.elf_so.1
 .include <bsd.man.mk>
 .endif

 @@ -1,10 +1,13 @@
-#	$NetBSD: Makefile.inc,v 1.11 2005/06/04 16:17:17 lukem Exp $
+#	$NetBSD: Makefile.inc,v 1.11.46.1 2013/01/22 21:47:28 matt Exp $
 SRCS+=		rtld_start.S mdreloc.c
 # XXX Should not be in CPPFLAGS!
 CPPFLAGS+=	-fpic
 CPPFLAGS+=	-DELFSIZE=32
 .if ${MACHINE_ARCH} == "earm" || ${MACHINE_ARCH} == "earmeb"
 CPPFLAGS+=	-DHAVE_INITFINI_ARRAY
 .endif
 LDFLAGS+=	-Wl,-e,_rtld_start

 @@ -1,104 +1,103 @@
-/*	$NetBSD: rtld_start.S,v 1.10 2009/11/11 14:15:41 skrll Exp $	*/
+/*	$NetBSD: rtld_start.S,v 1.10.10.1 2013/01/22 21:47:28 matt Exp $	*/
 /*-
  * Copyright (c) 1998, 2002 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Matt Thomas and by Charles M. Hannum.
+ *
  * 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. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND 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 FOUNDATION OR 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.
  */
 #include <machine/asm.h>
-RCSID("$NetBSD: rtld_start.S,v 1.10 2009/11/11 14:15:41 skrll Exp $")
+RCSID("$NetBSD: rtld_start.S,v 1.10.10.1 2013/01/22 21:47:28 matt Exp $")
 	.text
 	.align	0
 	.globl	_rtld_start
 	.type	_rtld_start,%function
 _rtld_start:
 	sub	sp, sp, #8		/* make room for obj_main & exit proc */
 	mov	r4, r0			/* save ps_strings */
 	ldr	sl, .L2
 	ldr	r5, .L2+4
 	ldr	r0, .L2+8
 .L1:
 	add	sl, pc, sl
 	ldr	r5, [sl, r5]
 	ldr	r0, [sl, r0]
 	sub	r1, sl, r5		/* relocbase */
 	add	r0, r1, r0		/* &_DYNAMIC */
 	bl	_rtld_relocate_nonplt_self
 	sub	r1, sl, r5		/* relocbase */
 	mov	r0, sp			/* sp */
 	bl	_rtld			/* call the shared loader */
 	mov	r3, r0			/* save entry point */
-	ldr	r2, [sp, #0]		/* r2 = cleanup */
+	ldr	r2, [sp], #4		/* pop r2 = cleanup */
-	ldr	r1, [sp, #4]		/* r1 = obj_main */
+	ldr	r1, [sp], #4		/* pop r1 = obj_main */
 	add	sp, sp, #8		/* restore stack */
 	mov	r0, r4			/* restore ps_strings */
 #ifdef _ARM_ARCH_4T
 	bx	r3			/* jump to the entry point */
 #else
 	mov	pc, r3			/* jump to the entry point */
 #endif
 .L2:
 	.word	_GLOBAL_OFFSET_TABLE_ - (.L1+8)
 	.word	_GLOBAL_OFFSET_TABLE_(GOT)
 	.word	_DYNAMIC(GOT)
 	.align	0
 	.globl	_rtld_bind_start
 	.type	_rtld_bind_start,%function
 /*
  *	stack[0] = RA
  *	ip = &GOT[n+3]
  *	lr = &GOT[2]
  */
 _rtld_bind_start:
-	stmdb	sp!,{r0-r4,sl,fp}
+	stmdb	sp!,{r0-r4,sl,fp}	/* 8 byte aligned (lr already saved) */
 	sub	r1, ip, lr		/* r1 = 4 * (n + 1) */
 	sub	r1, r1, #4		/* r1 = 4 * n */
 	add	r1, r1, r1		/* r1 = 8 * n */
 	ldr	r0, [lr, #-4]		/* get obj ptr from GOT[1] */
 	mov	r4, ip			/* save GOT location */
 	bl	_rtld_bind		/* Call the binder */
 	str	r0, [r4]		/* save address in GOT */
 	mov	ip, r0			/* save new address */
 	ldmia	sp!,{r0-r4,sl,fp,lr}	/* restore the stack */
 #ifdef _ARM_ARCH_4T
 	bx	ip			/* jump to the new address */
 #else
 	mov	pc, ip			/* jump to the new address */
 #endif