Skip site navigation (1)Skip section navigation (2)
Date:      Mon, 11 Feb 2019 15:02:03 +0000 (UTC)
From:      Konstantin Belousov <kib@FreeBSD.org>
To:        src-committers@freebsd.org, svn-src-all@freebsd.org, svn-src-stable@freebsd.org, svn-src-stable-12@freebsd.org
Subject:   svn commit: r344011 - in stable/12: lib/libthr lib/libthr/thread libexec/rtld-elf libexec/rtld-elf/aarch64 libexec/rtld-elf/amd64 libexec/rtld-elf/arm libexec/rtld-elf/i386 libexec/rtld-elf/mips li...
Message-ID:  <201902111502.x1BF23Rv025647@repo.freebsd.org>

next in thread | raw e-mail | index | archive | help
Author: kib
Date: Mon Feb 11 15:02:02 2019
New Revision: 344011
URL: https://svnweb.freebsd.org/changeset/base/344011

Log:
  MFC r339877-r339879,r343564-r343566,r343580,r343754:
  Untangle jemalloc and mutexes initialization.
  
  The merge includes required warnings cleanup by arichardson, both to
  avoid conflicts and to make rtld_malloc.c compilable with the libthr
  WARNS settings.

Added:
  stable/12/lib/libthr/thread/thr_malloc.c
     - copied, changed from r343566, head/lib/libthr/thread/thr_malloc.c
  stable/12/libexec/rtld-elf/rtld_malloc.c
     - copied unchanged from r343580, head/libexec/rtld-elf/rtld_malloc.c
  stable/12/libexec/rtld-elf/rtld_malloc.h
     - copied unchanged from r343565, head/libexec/rtld-elf/rtld_malloc.h
Deleted:
  stable/12/libexec/rtld-elf/malloc.c
Modified:
  stable/12/lib/libthr/Makefile
  stable/12/lib/libthr/thread/Makefile.inc
  stable/12/lib/libthr/thread/thr_fork.c
  stable/12/lib/libthr/thread/thr_init.c
  stable/12/lib/libthr/thread/thr_mutex.c
  stable/12/lib/libthr/thread/thr_private.h
  stable/12/lib/libthr/thread/thr_spec.c
  stable/12/libexec/rtld-elf/Makefile
  stable/12/libexec/rtld-elf/aarch64/reloc.c
  stable/12/libexec/rtld-elf/amd64/reloc.c
  stable/12/libexec/rtld-elf/arm/reloc.c
  stable/12/libexec/rtld-elf/i386/reloc.c
  stable/12/libexec/rtld-elf/i386/rtld_machdep.h
  stable/12/libexec/rtld-elf/libmap.c
  stable/12/libexec/rtld-elf/libmap.h
  stable/12/libexec/rtld-elf/map_object.c
  stable/12/libexec/rtld-elf/mips/reloc.c
  stable/12/libexec/rtld-elf/mips/rtld_machdep.h
  stable/12/libexec/rtld-elf/paths.h
  stable/12/libexec/rtld-elf/powerpc/reloc.c
  stable/12/libexec/rtld-elf/powerpc/rtld_machdep.h
  stable/12/libexec/rtld-elf/powerpc64/reloc.c
  stable/12/libexec/rtld-elf/powerpc64/rtld_machdep.h
  stable/12/libexec/rtld-elf/riscv/reloc.c
  stable/12/libexec/rtld-elf/rtld.c
  stable/12/libexec/rtld-elf/rtld.h
  stable/12/libexec/rtld-elf/rtld_lock.c
  stable/12/libexec/rtld-elf/rtld_printf.c
  stable/12/libexec/rtld-elf/sparc64/reloc.c
  stable/12/libexec/rtld-elf/xmalloc.c
Directory Properties:
  stable/12/   (props changed)

Modified: stable/12/lib/libthr/Makefile
==============================================================================
--- stable/12/lib/libthr/Makefile	Mon Feb 11 14:57:29 2019	(r344010)
+++ stable/12/lib/libthr/Makefile	Mon Feb 11 15:02:02 2019	(r344011)
@@ -26,6 +26,7 @@ CFLAGS+=-I${SRCTOP}/lib/libthread_db
 CFLAGS+=-Winline
 
 CFLAGS.thr_stack.c+=	-Wno-cast-align
+CFLAGS.rtld_malloc.c+=	-Wno-cast-align
 .include <bsd.compiler.mk>
 .if !(${COMPILER_TYPE} == "gcc" && ${COMPILER_VERSION} < 40300)
 CFLAGS.thr_symbols.c+=	-Wno-missing-variable-declarations
@@ -49,12 +50,14 @@ CFLAGS+=-D_PTHREADS_INVARIANTS
 PRECIOUSLIB=
 
 .PATH: ${.CURDIR}/arch/${MACHINE_CPUARCH}/${MACHINE_CPUARCH}
+.PATH: ${SRCTOP}/libexec/rtld-elf
 
 .if exists(${.CURDIR}/arch/${MACHINE_CPUARCH}/Makefile.inc)
 .include "${.CURDIR}/arch/${MACHINE_CPUARCH}/Makefile.inc"
 .endif
 .include "${.CURDIR}/sys/Makefile.inc"
 .include "${.CURDIR}/thread/Makefile.inc"
+SRCS+= rtld_malloc.c
 
 .if ${MK_INSTALLLIB} != "no"
 SYMLINKS+=lib${LIB}.a ${LIBDIR}/libpthread.a

Modified: stable/12/lib/libthr/thread/Makefile.inc
==============================================================================
--- stable/12/lib/libthr/thread/Makefile.inc	Mon Feb 11 14:57:29 2019	(r344010)
+++ stable/12/lib/libthr/thread/Makefile.inc	Mon Feb 11 15:02:02 2019	(r344011)
@@ -31,6 +31,7 @@ SRCS+= \
 	thr_kern.c \
 	thr_kill.c \
 	thr_main_np.c \
+	thr_malloc.c \
 	thr_multi_np.c \
 	thr_mutex.c \
 	thr_mutexattr.c \

Modified: stable/12/lib/libthr/thread/thr_fork.c
==============================================================================
--- stable/12/lib/libthr/thread/thr_fork.c	Mon Feb 11 14:57:29 2019	(r344010)
+++ stable/12/lib/libthr/thread/thr_fork.c	Mon Feb 11 15:02:02 2019	(r344011)
@@ -170,6 +170,7 @@ __thr_fork(void)
 	 */
 	if (_thr_isthreaded() != 0) {
 		was_threaded = 1;
+		__thr_malloc_prefork(curthread);
 		_malloc_prefork();
 		__thr_pshared_atfork_pre();
 		_rtld_atfork_pre(rtld_locks);
@@ -197,6 +198,10 @@ __thr_fork(void)
 		 */
 		curthread->tlflags &= ~TLFLAGS_IN_TDLIST;
 
+		/* before thr_self() */
+		if (was_threaded)
+			__thr_malloc_postfork(curthread);
+
 		/* child is a new kernel thread. */
 		thr_self(&curthread->tid);
 
@@ -241,6 +246,7 @@ __thr_fork(void)
 		_thr_signal_postfork();
 
 		if (was_threaded) {
+			__thr_malloc_postfork(curthread);
 			_rtld_atfork_post(rtld_locks);
 			__thr_pshared_atfork_post();
 			_malloc_postfork();

Modified: stable/12/lib/libthr/thread/thr_init.c
==============================================================================
--- stable/12/lib/libthr/thread/thr_init.c	Mon Feb 11 14:57:29 2019	(r344010)
+++ stable/12/lib/libthr/thread/thr_init.c	Mon Feb 11 15:02:02 2019	(r344011)
@@ -461,6 +461,7 @@ init_private(void)
 	 */
 	if (init_once == 0) {
 		__thr_pshared_init();
+		__thr_malloc_init();
 		/* Find the stack top */
 		mib[0] = CTL_KERN;
 		mib[1] = KERN_USRSTACK;

Copied and modified: stable/12/lib/libthr/thread/thr_malloc.c (from r343566, head/lib/libthr/thread/thr_malloc.c)
==============================================================================
--- head/lib/libthr/thread/thr_malloc.c	Tue Jan 29 22:46:44 2019	(r343566, copy source)
+++ stable/12/lib/libthr/thread/thr_malloc.c	Mon Feb 11 15:02:02 2019	(r344011)
@@ -46,6 +46,8 @@ void
 __thr_malloc_init(void)
 {
 
+	if (npagesizes != 0)
+		return;
 	npagesizes = getpagesizes(pagesizes_d, nitems(pagesizes_d));
 	if (npagesizes == -1) {
 		npagesizes = 1;
@@ -59,6 +61,8 @@ static void
 thr_malloc_lock(struct pthread *curthread)
 {
 
+	if (curthread == NULL)
+		return;
 	curthread->locklevel++;
 	_thr_umutex_lock(&thr_malloc_umtx, TID(curthread));
 }
@@ -67,6 +71,8 @@ static void
 thr_malloc_unlock(struct pthread *curthread)
 {
 
+	if (curthread == NULL)
+		return;
 	_thr_umutex_unlock(&thr_malloc_umtx, TID(curthread));
 	curthread->locklevel--;
 	_thr_ast(curthread);

Modified: stable/12/lib/libthr/thread/thr_mutex.c
==============================================================================
--- stable/12/lib/libthr/thread/thr_mutex.c	Mon Feb 11 14:57:29 2019	(r344010)
+++ stable/12/lib/libthr/thread/thr_mutex.c	Mon Feb 11 15:02:02 2019	(r344011)
@@ -306,10 +306,11 @@ init_static(struct pthread *thread, pthread_mutex_t *m
 	THR_LOCK_ACQUIRE(thread, &_mutex_static_lock);
 
 	if (*mutex == THR_MUTEX_INITIALIZER)
-		ret = mutex_init(mutex, &_pthread_mutexattr_default, calloc);
+		ret = mutex_init(mutex, &_pthread_mutexattr_default,
+		    __thr_calloc);
 	else if (*mutex == THR_ADAPTIVE_MUTEX_INITIALIZER)
 		ret = mutex_init(mutex, &_pthread_mutexattr_adaptive_default,
-		    calloc);
+		    __thr_calloc);
 	else
 		ret = 0;
 	THR_LOCK_RELEASE(thread, &_mutex_static_lock);
@@ -389,8 +390,9 @@ __pthread_mutex_init(pthread_mutex_t * __restrict mute
 	}
 	if (mutex_attr == NULL ||
 	    (*mutex_attr)->m_pshared == PTHREAD_PROCESS_PRIVATE) {
+		__thr_malloc_init();
 		return (mutex_init(mutex, mutex_attr ? *mutex_attr : NULL,
-		    calloc));
+		    __thr_calloc));
 	}
 	pmtx = __thr_pshared_offpage(__DECONST(void *, mutex), 1);
 	if (pmtx == NULL)
@@ -483,7 +485,7 @@ _pthread_mutex_destroy(pthread_mutex_t *mutex)
 		} else {
 			*mutex = THR_MUTEX_DESTROYED;
 			mutex_assert_not_owned(_get_curthread(), m);
-			free(m);
+			__thr_free(m);
 			ret = 0;
 		}
 	}

Modified: stable/12/lib/libthr/thread/thr_private.h
==============================================================================
--- stable/12/lib/libthr/thread/thr_private.h	Mon Feb 11 14:57:29 2019	(r344010)
+++ stable/12/lib/libthr/thread/thr_private.h	Mon Feb 11 15:02:02 2019	(r344011)
@@ -1009,6 +1009,14 @@ void __thr_pshared_destroy(void *key) __hidden;
 void __thr_pshared_atfork_pre(void) __hidden;
 void __thr_pshared_atfork_post(void) __hidden;
 
+void *__thr_calloc(size_t num, size_t size);
+void __thr_free(void *cp);
+void *__thr_malloc(size_t nbytes);
+void *__thr_realloc(void *cp, size_t nbytes);
+void __thr_malloc_init(void);
+void __thr_malloc_prefork(struct pthread *curthread);
+void __thr_malloc_postfork(struct pthread *curthread);
+
 __END_DECLS
 __NULLABILITY_PRAGMA_POP
 

Modified: stable/12/lib/libthr/thread/thr_spec.c
==============================================================================
--- stable/12/lib/libthr/thread/thr_spec.c	Mon Feb 11 14:57:29 2019	(r344010)
+++ stable/12/lib/libthr/thread/thr_spec.c	Mon Feb 11 15:02:02 2019	(r344011)
@@ -155,8 +155,7 @@ _thread_cleanupspecific(void)
 		}
 	}
 	THR_LOCK_RELEASE(curthread, &_keytable_lock);
-	munmap(curthread->specific, PTHREAD_KEYS_MAX * sizeof(struct
-	    pthread_specific_elem));
+	__thr_free(curthread->specific);
 	curthread->specific = NULL;
 	if (curthread->specific_data_count > 0) {
 		stderr_debug("Thread %p has exited with leftover "
@@ -179,10 +178,9 @@ _pthread_setspecific(pthread_key_t userkey, const void
 
 	pthread = _get_curthread();
 	if (pthread->specific == NULL) {
-		tmp = mmap(NULL, PTHREAD_KEYS_MAX *
-		    sizeof(struct pthread_specific_elem),
-		    PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
-		if (tmp == MAP_FAILED)
+		tmp = __thr_calloc(PTHREAD_KEYS_MAX,
+		    sizeof(struct pthread_specific_elem));
+		if (tmp == NULL)
 			return (ENOMEM);
 		pthread->specific = tmp;
 	}

Modified: stable/12/libexec/rtld-elf/Makefile
==============================================================================
--- stable/12/libexec/rtld-elf/Makefile	Mon Feb 11 14:57:29 2019	(r344010)
+++ stable/12/libexec/rtld-elf/Makefile	Mon Feb 11 15:02:02 2019	(r344011)
@@ -13,9 +13,17 @@ PROG?=		ld-elf.so.1
 .if (${PROG:M*ld-elf32*} != "")
 TAGS+=		lib32
 .endif
-SRCS=		rtld_start.S \
-		reloc.c rtld.c rtld_lock.c rtld_printf.c map_object.c \
-		malloc.c xmalloc.c debug.c libmap.c
+SRCS= \
+	rtld_start.S \
+	reloc.c \
+	rtld.c \
+	rtld_lock.c \
+	rtld_malloc.c \
+	rtld_printf.c \
+	map_object.c \
+	xmalloc.c \
+	debug.c \
+	libmap.c
 MAN=		rtld.1
 CSTD?=		gnu99
 CFLAGS+=	-Wall -DFREEBSD_ELF -DIN_RTLD -ffreestanding
@@ -31,7 +39,9 @@ LDFLAGS+=	-nostdlib -e _rtld_start
 .else
 LDFLAGS+=	-nostdlib -e .rtld_start
 .endif
-WARNS?=		2
+
+NO_WCAST_ALIGN=	yes
+WARNS?=		6
 INSTALLFLAGS=	-C -b
 PRECIOUSPROG=
 BINDIR=		/libexec
@@ -95,3 +105,13 @@ SUBDIR.${MK_TESTS}+= tests
 .include <bsd.prog.mk>
 ${PROG_FULL}:	${VERSION_MAP}
 .include <bsd.symver.mk>
+
+.if ${COMPILER_TYPE} == "gcc"
+# GCC warns about redeclarations even though they have __exported
+# and are therefore not identical to the ones from the system headers.
+CFLAGS+=	-Wno-redundant-decls
+.if ${COMPILER_VERSION} < 40300
+# Silence -Wshadow false positives in ancient GCC
+CFLAGS+=	-Wno-shadow
+.endif
+.endif

Modified: stable/12/libexec/rtld-elf/aarch64/reloc.c
==============================================================================
--- stable/12/libexec/rtld-elf/aarch64/reloc.c	Mon Feb 11 14:57:29 2019	(r344010)
+++ stable/12/libexec/rtld-elf/aarch64/reloc.c	Mon Feb 11 15:02:02 2019	(r344011)
@@ -85,7 +85,7 @@ do_copy_relocations(Obj_Entry *dstobj)
 	 */
 	assert(dstobj->mainprog);
 
-	relalim = (const Elf_Rela *)((char *)dstobj->rela +
+	relalim = (const Elf_Rela *)((const char *)dstobj->rela +
 	    dstobj->relasize);
 	for (rela = dstobj->rela; rela < relalim; rela++) {
 		if (ELF_R_TYPE(rela->r_info) != R_AARCH64_COPY)
@@ -128,6 +128,8 @@ struct tls_data {
 	Elf_Addr	tls_offs;
 };
 
+int64_t rtld_tlsdesc_handle(struct tls_data *tlsdesc, int flags);
+
 static Elf_Addr
 reloc_tlsdesc_alloc(int tlsindex, Elf_Addr tlsoffs)
 {
@@ -187,7 +189,7 @@ reloc_plt(Obj_Entry *obj, int flags, RtldLockState *lo
 	const Elf_Rela *relalim;
 	const Elf_Rela *rela;
 
-	relalim = (const Elf_Rela *)((char *)obj->pltrela + obj->pltrelasize);
+	relalim = (const Elf_Rela *)((const char *)obj->pltrela + obj->pltrelasize);
 	for (rela = obj->pltrela; rela < relalim; rela++) {
 		Elf_Addr *where;
 
@@ -230,7 +232,7 @@ reloc_jmpslots(Obj_Entry *obj, int flags, RtldLockStat
 	if (obj->jmpslots_done)
 		return (0);
 
-	relalim = (const Elf_Rela *)((char *)obj->pltrela + obj->pltrelasize);
+	relalim = (const Elf_Rela *)((const char *)obj->pltrela + obj->pltrelasize);
 	for (rela = obj->pltrela; rela < relalim; rela++) {
 		Elf_Addr *where, target;
 
@@ -265,7 +267,7 @@ reloc_iresolve(Obj_Entry *obj, struct Struct_RtldLockS
 
 	if (!obj->irelative)
 		return (0);
-	relalim = (const Elf_Rela *)((char *)obj->pltrela + obj->pltrelasize);
+	relalim = (const Elf_Rela *)((const char *)obj->pltrela + obj->pltrelasize);
 	for (rela = obj->pltrela;  rela < relalim;  rela++) {
 		if (ELF_R_TYPE(rela->r_info) == R_AARCH64_IRELATIVE) {
 			ptr = (Elf_Addr *)(obj->relocbase + rela->r_addend);
@@ -292,7 +294,7 @@ reloc_gnu_ifunc(Obj_Entry *obj, int flags,
 
 	if (!obj->gnu_ifunc)
 		return (0);
-	relalim = (const Elf_Rela *)((char *)obj->pltrela + obj->pltrelasize);
+	relalim = (const Elf_Rela *)((const char *)obj->pltrela + obj->pltrelasize);
 	for (rela = obj->pltrela;  rela < relalim;  rela++) {
 		if (ELF_R_TYPE(rela->r_info) == R_AARCH64_JUMP_SLOT) {
 			where = (Elf_Addr *)(obj->relocbase + rela->r_offset);
@@ -314,8 +316,9 @@ reloc_gnu_ifunc(Obj_Entry *obj, int flags,
 }
 
 Elf_Addr
-reloc_jmpslot(Elf_Addr *where, Elf_Addr target, const Obj_Entry *defobj,
-    const Obj_Entry *obj, const Elf_Rel *rel)
+reloc_jmpslot(Elf_Addr *where, Elf_Addr target,
+    const Obj_Entry *defobj __unused, const Obj_Entry *obj __unused,
+    const Elf_Rel *rel)
 {
 
 	assert(ELF_R_TYPE(rel->r_info) == R_AARCH64_JUMP_SLOT ||
@@ -362,7 +365,7 @@ reloc_non_plt(Obj_Entry *obj, Obj_Entry *obj_rtld, int
 		cache = calloc(obj->dynsymcount, sizeof(SymCache));
 		/* No need to check for NULL here */
 
-	relalim = (const Elf_Rela *)((caddr_t)obj->rela + obj->relasize);
+	relalim = (const Elf_Rela *)((const char *)obj->rela + obj->relasize);
 	for (rela = obj->rela; rela < relalim; rela++) {
 		/*
 		 * First, resolve symbol for relocations which
@@ -449,7 +452,8 @@ reloc_non_plt(Obj_Entry *obj, Obj_Entry *obj_rtld, int
 			 * error.
 			 */
 			if (!defobj->tls_done) {
-				if (!allocate_tls_offset((Obj_Entry*) defobj)) {
+				if (!allocate_tls_offset(
+				    __DECONST(Obj_Entry *, defobj))) {
 					_rtld_error(
 					    "%s: No space available for static "
 					    "Thread Local Storage", obj->path);

Modified: stable/12/libexec/rtld-elf/amd64/reloc.c
==============================================================================
--- stable/12/libexec/rtld-elf/amd64/reloc.c	Mon Feb 11 14:57:29 2019	(r344010)
+++ stable/12/libexec/rtld-elf/amd64/reloc.c	Mon Feb 11 15:02:02 2019	(r344011)
@@ -68,7 +68,7 @@ do_copy_relocations(Obj_Entry *dstobj)
 
     assert(dstobj->mainprog);	/* COPY relocations are invalid elsewhere */
 
-    relalim = (const Elf_Rela *) ((caddr_t) dstobj->rela + dstobj->relasize);
+    relalim = (const Elf_Rela *)((const char *) dstobj->rela + dstobj->relasize);
     for (rela = dstobj->rela;  rela < relalim;  rela++) {
 	if (ELF_R_TYPE(rela->r_info) == R_X86_64_COPY) {
 	    void *dstaddr;
@@ -81,7 +81,7 @@ do_copy_relocations(Obj_Entry *dstobj)
 	    SymLook req;
 	    int res;
 
-	    dstaddr = (void *) (dstobj->relocbase + rela->r_offset);
+	    dstaddr = (void *)(dstobj->relocbase + rela->r_offset);
 	    dstsym = dstobj->symtab + ELF_R_SYM(rela->r_info);
 	    name = dstobj->strtab + dstsym->st_name;
 	    size = dstsym->st_size;
@@ -105,7 +105,7 @@ do_copy_relocations(Obj_Entry *dstobj)
 		return -1;
 	    }
 
-	    srcaddr = (const void *) (defobj->relocbase + srcsym->st_value);
+	    srcaddr = (const void *)(defobj->relocbase + srcsym->st_value);
 	    memcpy(dstaddr, srcaddr, size);
 	}
     }
@@ -151,7 +151,7 @@ reloc_non_plt(Obj_Entry *obj, Obj_Entry *obj_rtld, int
 	} else
 		cache = NULL;
 
-	relalim = (const Elf_Rela *)((caddr_t)obj->rela + obj->relasize);
+	relalim = (const Elf_Rela *)((const char*)obj->rela + obj->relasize);
 	for (rela = obj->rela;  rela < relalim;  rela++) {
 		/*
 		 * First, resolve symbol for relocations which
@@ -258,7 +258,8 @@ reloc_non_plt(Obj_Entry *obj, Obj_Entry *obj_rtld, int
 			 * of space, we generate an error.
 			 */
 			if (!defobj->tls_done) {
-				if (!allocate_tls_offset((Obj_Entry*) defobj)) {
+				if (!allocate_tls_offset(
+				    __DECONST(Obj_Entry *, defobj))) {
 					_rtld_error("%s: No space available "
 					    "for static Thread Local Storage",
 					    obj->path);
@@ -278,7 +279,8 @@ reloc_non_plt(Obj_Entry *obj, Obj_Entry *obj_rtld, int
 			 * of space, we generate an error.
 			 */
 			if (!defobj->tls_done) {
-				if (!allocate_tls_offset((Obj_Entry*) defobj)) {
+				if (!allocate_tls_offset(
+				    __DECONST(Obj_Entry *, defobj))) {
 					_rtld_error("%s: No space available "
 					    "for static Thread Local Storage",
 					    obj->path);
@@ -326,7 +328,7 @@ reloc_plt(Obj_Entry *obj, int flags __unused, RtldLock
     const Elf_Rela *relalim;
     const Elf_Rela *rela;
 
-    relalim = (const Elf_Rela *)((char *)obj->pltrela + obj->pltrelasize);
+    relalim = (const Elf_Rela *)((const char *)obj->pltrela + obj->pltrelasize);
     for (rela = obj->pltrela;  rela < relalim;  rela++) {
 	Elf_Addr *where;
 
@@ -359,7 +361,7 @@ reloc_jmpslots(Obj_Entry *obj, int flags, RtldLockStat
 
     if (obj->jmpslots_done)
 	return 0;
-    relalim = (const Elf_Rela *)((char *)obj->pltrela + obj->pltrelasize);
+    relalim = (const Elf_Rela *)((const char *)obj->pltrela + obj->pltrelasize);
     for (rela = obj->pltrela;  rela < relalim;  rela++) {
 	Elf_Addr *where, target;
 	const Elf_Sym *def;
@@ -396,8 +398,9 @@ reloc_jmpslots(Obj_Entry *obj, int flags, RtldLockStat
 /* Fixup the jump slot at "where" to transfer control to "target". */
 Elf_Addr
 reloc_jmpslot(Elf_Addr *where, Elf_Addr target,
-    const struct Struct_Obj_Entry *obj, const struct Struct_Obj_Entry *refobj,
-    const Elf_Rel *rel)
+    const struct Struct_Obj_Entry *obj  __unused,
+    const struct Struct_Obj_Entry *refobj  __unused,
+    const Elf_Rel *rel  __unused)
 {
 #ifdef dbg
 	dbg("reloc_jmpslot: *%p = %p", where, (void *)target);
@@ -415,7 +418,7 @@ reloc_iresolve(Obj_Entry *obj, RtldLockState *lockstat
 
     if (!obj->irelative)
 	return (0);
-    relalim = (const Elf_Rela *)((char *)obj->pltrela + obj->pltrelasize);
+    relalim = (const Elf_Rela *)((const char *)obj->pltrela + obj->pltrelasize);
     for (rela = obj->pltrela;  rela < relalim;  rela++) {
 	Elf_Addr *where, target, *ptr;
 
@@ -445,7 +448,7 @@ reloc_gnu_ifunc(Obj_Entry *obj, int flags, RtldLockSta
 
     if (!obj->gnu_ifunc)
 	return (0);
-    relalim = (const Elf_Rela *)((char *)obj->pltrela + obj->pltrelasize);
+    relalim = (const Elf_Rela *)((const char *)obj->pltrela + obj->pltrelasize);
     for (rela = obj->pltrela;  rela < relalim;  rela++) {
 	Elf_Addr *where, target;
 	const Elf_Sym *def;

Modified: stable/12/libexec/rtld-elf/arm/reloc.c
==============================================================================
--- stable/12/libexec/rtld-elf/arm/reloc.c	Mon Feb 11 14:57:29 2019	(r344010)
+++ stable/12/libexec/rtld-elf/arm/reloc.c	Mon Feb 11 15:02:02 2019	(r344011)
@@ -75,7 +75,7 @@ do_copy_relocations(Obj_Entry *dstobj)
 
 	assert(dstobj->mainprog);	/* COPY relocations are invalid elsewhere */
 
-   	rellim = (const Elf_Rel *) ((caddr_t) dstobj->rel + dstobj->relsize);
+	rellim = (const Elf_Rel *)((const char *) dstobj->rel + dstobj->relsize);
 	for (rel = dstobj->rel;  rel < rellim;  rel++) {
 		if (ELF_R_TYPE(rel->r_info) == R_ARM_COPY) {
 	    		void *dstaddr;
@@ -88,7 +88,7 @@ do_copy_relocations(Obj_Entry *dstobj)
 			SymLook req;
 			int res;
 			
-			dstaddr = (void *) (dstobj->relocbase + rel->r_offset);
+			dstaddr = (void *)(dstobj->relocbase + rel->r_offset);
 			dstsym = dstobj->symtab + ELF_R_SYM(rel->r_info);
 			name = dstobj->strtab + dstsym->st_name;
 			size = dstsym->st_size;
@@ -125,8 +125,6 @@ do_copy_relocations(Obj_Entry *dstobj)
 void _rtld_bind_start(void);
 void _rtld_relocate_nonplt_self(Elf_Dyn *, Elf_Addr);
 
-int open();
-int _open();
 void
 _rtld_relocate_nonplt_self(Elf_Dyn *dynp, Elf_Addr relocbase)
 {
@@ -145,7 +143,7 @@ _rtld_relocate_nonplt_self(Elf_Dyn *dynp, Elf_Addr rel
 			break;
 		}
 	}
-	rellim = (const Elf_Rel *)((caddr_t)rel + relsz);
+	rellim = (const Elf_Rel *)((const char *)rel + relsz);
 	size = (rellim - 1)->r_offset - rel->r_offset;
 	for (; rel < rellim; rel++) {
 		where = (Elf_Addr *)(relocbase + rel->r_offset);
@@ -375,7 +373,7 @@ reloc_non_plt(Obj_Entry *obj, Obj_Entry *obj_rtld, int
 	cache = calloc(obj->dynsymcount, sizeof(SymCache));
 	/* No need to check for NULL here */
 
-	rellim = (const Elf_Rel *)((caddr_t)obj->rel + obj->relsize);
+	rellim = (const Elf_Rel *)((const char *)obj->rel + obj->relsize);
 	for (rel = obj->rel; rel < rellim; rel++) {
 		if (reloc_nonplt_object(obj, rel, cache, flags, lockstate) < 0)
 			goto done;
@@ -396,7 +394,7 @@ reloc_plt(Obj_Entry *obj, int flags __unused, RtldLock
 	const Elf_Rel *rellim;
 	const Elf_Rel *rel;
 		
-	rellim = (const Elf_Rel *)((char *)obj->pltrel +
+	rellim = (const Elf_Rel *)((const char *)obj->pltrel +
 	    obj->pltrelsize);
 	for (rel = obj->pltrel;  rel < rellim;  rel++) {
 		Elf_Addr *where;
@@ -423,7 +421,7 @@ reloc_jmpslots(Obj_Entry *obj, int flags, RtldLockStat
 	Elf_Addr *where;
 	Elf_Addr target;
 	
-	rellim = (const Elf_Rel *)((char *)obj->pltrel + obj->pltrelsize);
+	rellim = (const Elf_Rel *)((const char *)obj->pltrel + obj->pltrelsize);
 	for (rel = obj->pltrel; rel < rellim; rel++) {
 		assert(ELF_R_TYPE(rel->r_info) == R_ARM_JUMP_SLOT);
 		where = (Elf_Addr *)(obj->relocbase + rel->r_offset);
@@ -445,7 +443,8 @@ reloc_jmpslots(Obj_Entry *obj, int flags, RtldLockStat
 }
 
 int
-reloc_iresolve(Obj_Entry *obj, struct Struct_RtldLockState *lockstate)
+reloc_iresolve(Obj_Entry *obj __unused,
+    struct Struct_RtldLockState *lockstate __unused)
 {
 
 	/* XXX not implemented */
@@ -453,8 +452,8 @@ reloc_iresolve(Obj_Entry *obj, struct Struct_RtldLockS
 }
 
 int
-reloc_gnu_ifunc(Obj_Entry *obj, int flags,
-    struct Struct_RtldLockState *lockstate)
+reloc_gnu_ifunc(Obj_Entry *obj __unused, int flags __unused,
+    struct Struct_RtldLockState *lockstate __unused)
 {
 
 	/* XXX not implemented */
@@ -462,8 +461,9 @@ reloc_gnu_ifunc(Obj_Entry *obj, int flags,
 }
 
 Elf_Addr
-reloc_jmpslot(Elf_Addr *where, Elf_Addr target, const Obj_Entry *defobj,
-    const Obj_Entry *obj, const Elf_Rel *rel)
+reloc_jmpslot(Elf_Addr *where, Elf_Addr target,
+    const Obj_Entry *defobj __unused, const Obj_Entry *obj __unused,
+    const Elf_Rel *rel)
 {
 
 	assert(ELF_R_TYPE(rel->r_info) == R_ARM_JUMP_SLOT);

Modified: stable/12/libexec/rtld-elf/i386/reloc.c
==============================================================================
--- stable/12/libexec/rtld-elf/i386/reloc.c	Mon Feb 11 14:57:29 2019	(r344010)
+++ stable/12/libexec/rtld-elf/i386/reloc.c	Mon Feb 11 15:02:02 2019	(r344011)
@@ -67,7 +67,7 @@ do_copy_relocations(Obj_Entry *dstobj)
 
     assert(dstobj->mainprog);	/* COPY relocations are invalid elsewhere */
 
-    rellim = (const Elf_Rel *) ((caddr_t) dstobj->rel + dstobj->relsize);
+    rellim = (const Elf_Rel *)((const char *)dstobj->rel + dstobj->relsize);
     for (rel = dstobj->rel;  rel < rellim;  rel++) {
 	if (ELF_R_TYPE(rel->r_info) == R_386_COPY) {
 	    void *dstaddr;
@@ -80,7 +80,7 @@ do_copy_relocations(Obj_Entry *dstobj)
 	    SymLook req;
 	    int res;
 
-	    dstaddr = (void *) (dstobj->relocbase + rel->r_offset);
+	    dstaddr = (void *)(dstobj->relocbase + rel->r_offset);
 	    dstsym = dstobj->symtab + ELF_R_SYM(rel->r_info);
 	    name = dstobj->strtab + dstsym->st_name;
 	    size = dstsym->st_size;
@@ -104,7 +104,7 @@ do_copy_relocations(Obj_Entry *dstobj)
 		return -1;
 	    }
 
-	    srcaddr = (const void *) (defobj->relocbase + srcsym->st_value);
+	    srcaddr = (const void *)(defobj->relocbase + srcsym->st_value);
 	    memcpy(dstaddr, srcaddr, size);
 	}
     }
@@ -146,7 +146,7 @@ reloc_non_plt(Obj_Entry *obj, Obj_Entry *obj_rtld, int
 	} else
 		cache = NULL;
 
-	rellim = (const Elf_Rel *)((caddr_t) obj->rel + obj->relsize);
+	rellim = (const Elf_Rel *)((const char *)obj->rel + obj->relsize);
 	for (rel = obj->rel;  rel < rellim;  rel++) {
 		switch (ELF_R_TYPE(rel->r_info)) {
 		case R_386_32:
@@ -239,7 +239,8 @@ reloc_non_plt(Obj_Entry *obj, Obj_Entry *obj_rtld, int
 			 * of space, we generate an error.
 			 */
 			if (!defobj->tls_done) {
-				if (!allocate_tls_offset((Obj_Entry*) defobj)) {
+				if (!allocate_tls_offset(
+				    __DECONST(Obj_Entry *, defobj))) {
 					_rtld_error("%s: No space available "
 					    "for static Thread Local Storage",
 					    obj->path);
@@ -278,7 +279,7 @@ reloc_plt(Obj_Entry *obj, int flags __unused, RtldLock
     const Elf_Rel *rellim;
     const Elf_Rel *rel;
 
-    rellim = (const Elf_Rel *)((char *)obj->pltrel + obj->pltrelsize);
+    rellim = (const Elf_Rel *)((const char *)obj->pltrel + obj->pltrelsize);
     for (rel = obj->pltrel;  rel < rellim;  rel++) {
 	Elf_Addr *where/*, val*/;
 
@@ -311,7 +312,7 @@ reloc_jmpslots(Obj_Entry *obj, int flags, RtldLockStat
 
     if (obj->jmpslots_done)
 	return 0;
-    rellim = (const Elf_Rel *)((char *)obj->pltrel + obj->pltrelsize);
+    rellim = (const Elf_Rel *)((const char *)obj->pltrel + obj->pltrelsize);
     for (rel = obj->pltrel;  rel < rellim;  rel++) {
 	Elf_Addr *where, target;
 	const Elf_Sym *def;
@@ -349,8 +350,8 @@ reloc_jmpslots(Obj_Entry *obj, int flags, RtldLockStat
 /* Fixup the jump slot at "where" to transfer control to "target". */
 Elf_Addr
 reloc_jmpslot(Elf_Addr *where, Elf_Addr target,
-    const struct Struct_Obj_Entry *obj, const struct Struct_Obj_Entry *refobj,
-    const Elf_Rel *rel)
+    const Obj_Entry *obj __unused, const Obj_Entry *refobj __unused,
+    const Elf_Rel *rel __unused)
 {
 #ifdef dbg
 	dbg("reloc_jmpslot: *%p = %p", where, (void *)target);
@@ -369,7 +370,7 @@ reloc_iresolve(Obj_Entry *obj, RtldLockState *lockstat
 
     if (!obj->irelative)
 	return (0);
-    rellim = (const Elf_Rel *)((char *)obj->pltrel + obj->pltrelsize);
+    rellim = (const Elf_Rel *)((const char *)obj->pltrel + obj->pltrelsize);
     for (rel = obj->pltrel;  rel < rellim;  rel++) {
 	switch (ELF_R_TYPE(rel->r_info)) {
 	case R_386_IRELATIVE:
@@ -393,7 +394,7 @@ reloc_gnu_ifunc(Obj_Entry *obj, int flags, RtldLockSta
 
     if (!obj->gnu_ifunc)
 	return (0);
-    rellim = (const Elf_Rel *)((char *)obj->pltrel + obj->pltrelsize);
+    rellim = (const Elf_Rel *)((const char *)obj->pltrel + obj->pltrelsize);
     for (rel = obj->pltrel;  rel < rellim;  rel++) {
 	Elf_Addr *where, target;
 	const Elf_Sym *def;

Modified: stable/12/libexec/rtld-elf/i386/rtld_machdep.h
==============================================================================
--- stable/12/libexec/rtld-elf/i386/rtld_machdep.h	Mon Feb 11 14:57:29 2019	(r344010)
+++ stable/12/libexec/rtld-elf/i386/rtld_machdep.h	Mon Feb 11 15:02:02 2019	(r344011)
@@ -58,7 +58,7 @@ extern uint32_t cpu_feature2;
 extern uint32_t cpu_stdext_feature;
 extern uint32_t cpu_stdext_feature2;
 #define	call_ifunc_resolver(ptr) \
-	(((Elf_Addr (*)(uint32_t, uint32_t, uint32_t, uint32_t))ptr)( \
+	(((Elf_Addr (*)(uint32_t, uint32_t, uint32_t, uint32_t))(ptr))( \
 	    cpu_feature, cpu_feature2, cpu_stdext_feature, cpu_stdext_feature2))
 
 #define round(size, align) \

Modified: stable/12/libexec/rtld-elf/libmap.c
==============================================================================
--- stable/12/libexec/rtld-elf/libmap.c	Mon Feb 11 14:57:29 2019	(r344010)
+++ stable/12/libexec/rtld-elf/libmap.c	Mon Feb 11 15:02:02 2019	(r344011)
@@ -25,7 +25,7 @@ struct lm {
 	TAILQ_ENTRY(lm)	lm_link;
 };
 
-TAILQ_HEAD(lmp_list, lmp) lmp_head = TAILQ_HEAD_INITIALIZER(lmp_head);
+static TAILQ_HEAD(lmp_list, lmp) lmp_head = TAILQ_HEAD_INITIALIZER(lmp_head);
 struct lmp {
 	char *p;
 	enum { T_EXACT=0, T_BASENAME, T_DIRECTORY } type;
@@ -44,8 +44,8 @@ struct lmc {
 static int lm_count;
 
 static void lmc_parse(char *, size_t);
-static void lmc_parse_file(char *);
-static void lmc_parse_dir(char *);
+static void lmc_parse_file(const char *);
+static void lmc_parse_dir(const char *);
 static void lm_add(const char *, const char *, const char *);
 static void lm_free(struct lm_list *);
 static char *lml_find(struct lm_list *, const char *);
@@ -96,7 +96,7 @@ lm_init(char *libmap_override)
 }
 
 static void
-lmc_parse_file(char *path)
+lmc_parse_file(const char *path)
 {
 	struct lmc *p;
 	char *lm_map;
@@ -149,7 +149,7 @@ lmc_parse_file(char *path)
 }
 
 static void
-lmc_parse_dir(char *idir)
+lmc_parse_dir(const char *idir)
 {
 	DIR *d;
 	struct dirent *dp;
@@ -199,8 +199,7 @@ lmc_parse(char *lm_p, size_t lm_len)
 	char prog[MAXPATHLEN];
 	/* allow includedir + full length path */
 	char line[MAXPATHLEN + 13];
-	size_t cnt;
-	int i;
+	size_t cnt, i;
 
 	cnt = 0;
 	p = NULL;
@@ -403,7 +402,7 @@ lm_find(const char *p, const char *f)
  * replacement library, or NULL.
  */
 char *
-lm_findn(const char *p, const char *f, const int n)
+lm_findn(const char *p, const char *f, const size_t n)
 {
 	char pathbuf[64], *s, *t;
 

Modified: stable/12/libexec/rtld-elf/libmap.h
==============================================================================
--- stable/12/libexec/rtld-elf/libmap.h	Mon Feb 11 14:57:29 2019	(r344010)
+++ stable/12/libexec/rtld-elf/libmap.h	Mon Feb 11 15:02:02 2019	(r344011)
@@ -5,4 +5,4 @@
 int	lm_init (char *);
 void	lm_fini (void);
 char *	lm_find (const char *, const char *);
-char *	lm_findn (const char *, const char *, const int);
+char *	lm_findn (const char *, const char *, const size_t);

Modified: stable/12/libexec/rtld-elf/map_object.c
==============================================================================
--- stable/12/libexec/rtld-elf/map_object.c	Mon Feb 11 14:57:29 2019	(r344010)
+++ stable/12/libexec/rtld-elf/map_object.c	Mon Feb 11 15:02:02 2019	(r344011)
@@ -103,7 +103,7 @@ map_object(int fd, const char *path, const struct stat
      *
      * We expect that the loadable segments are ordered by load address.
      */
-    phdr = (Elf_Phdr *) ((char *)hdr + hdr->e_phoff);
+    phdr = (Elf_Phdr *)((char *)hdr + hdr->e_phoff);
     phsize  = hdr->e_phnum * sizeof (phdr[0]);
     phlimit = phdr + hdr->e_phnum;
     nsegs = -1;
@@ -114,6 +114,7 @@ map_object(int fd, const char *path, const struct stat
     note_start = 0;
     note_end = 0;
     note_map = NULL;
+    note_map_len = 0;
     segs = alloca(sizeof(segs[0]) * hdr->e_phnum);
     stack_flags = RTLD_DEFAULT_STACK_PF_EXEC | PF_R | PF_W;
     while (phdr < phlimit) {
@@ -284,11 +285,11 @@ map_object(int fd, const char *path, const struct stat
       base_vaddr;
     obj->vaddrbase = base_vaddr;
     obj->relocbase = mapbase - base_vaddr;
-    obj->dynamic = (const Elf_Dyn *) (obj->relocbase + phdyn->p_vaddr);
+    obj->dynamic = (const Elf_Dyn *)(obj->relocbase + phdyn->p_vaddr);
     if (hdr->e_entry != 0)
-	obj->entry = (caddr_t) (obj->relocbase + hdr->e_entry);
+	obj->entry = (caddr_t)(obj->relocbase + hdr->e_entry);
     if (phdr_vaddr != 0) {
-	obj->phdr = (const Elf_Phdr *) (obj->relocbase + phdr_vaddr);
+	obj->phdr = (const Elf_Phdr *)(obj->relocbase + phdr_vaddr);
     } else {
 	obj->phdr = malloc(phsize);
 	if (obj->phdr == NULL) {
@@ -296,12 +297,12 @@ map_object(int fd, const char *path, const struct stat
 	    _rtld_error("%s: cannot allocate program header", path);
 	    goto error1;
 	}
-	memcpy((char *)obj->phdr, (char *)hdr + hdr->e_phoff, phsize);
+	memcpy(__DECONST(char *, obj->phdr), (char *)hdr + hdr->e_phoff, phsize);
 	obj->phdr_alloc = true;
     }
     obj->phsize = phsize;
     if (phinterp != NULL)
-	obj->interp = (const char *) (obj->relocbase + phinterp->p_vaddr);
+	obj->interp = (const char *)(obj->relocbase + phinterp->p_vaddr);
     if (phtls != NULL) {
 	tls_dtv_generation++;
 	obj->tlsindex = ++tls_max_index;
@@ -335,7 +336,7 @@ get_elf_header(int fd, const char *path, const struct 
 	Elf_Ehdr *hdr;
 
 	/* Make sure file has enough data for the ELF header */
-	if (sbp != NULL && sbp->st_size < sizeof(Elf_Ehdr)) {
+	if (sbp != NULL && sbp->st_size < (off_t)sizeof(Elf_Ehdr)) {
 		_rtld_error("%s: invalid file format", path);
 		return (NULL);
 	}
@@ -425,13 +426,13 @@ obj_free(Obj_Entry *obj)
     if (obj->origin_path)
 	free(obj->origin_path);
     if (obj->z_origin)
-	free(obj->rpath);
+	free(__DECONST(void*, obj->rpath));
     if (obj->priv)
 	free(obj->priv);
     if (obj->path)
 	free(obj->path);
     if (obj->phdr_alloc)
-	free((void *)obj->phdr);
+	free(__DECONST(void *, obj->phdr));
     free(obj);
 }
 

Modified: stable/12/libexec/rtld-elf/mips/reloc.c
==============================================================================
--- stable/12/libexec/rtld-elf/mips/reloc.c	Mon Feb 11 14:57:29 2019	(r344010)
+++ stable/12/libexec/rtld-elf/mips/reloc.c	Mon Feb 11 15:02:02 2019	(r344011)
@@ -126,7 +126,7 @@ do_copy_relocations(Obj_Entry *dstobj)
 	 */
 	assert(dstobj->mainprog);
 
-	rellim = (const Elf_Rel *)((caddr_t)dstobj->rel + dstobj->relsize);
+	rellim = (const Elf_Rel *)((const char *)dstobj->rel + dstobj->relsize);
 	for (rel = dstobj->rel; rel < rellim; rel++) {
 		if (ELF_R_TYPE(rel->r_info) != R_MIPS_COPY)
 			continue;
@@ -265,7 +265,7 @@ _rtld_relocate_nonplt_self(Elf_Dyn *dynp, Elf_Addr rel
 		++got;
 	}
 
-	rellim = (const Elf_Rel *)((caddr_t)rel + relsz);
+	rellim = (const Elf_Rel *)((const char *)rel + relsz);
 	for (; rel < rellim; rel++) {
 		Elf_Word r_symndx, r_type;
 
@@ -469,7 +469,7 @@ reloc_non_plt(Obj_Entry *obj, Obj_Entry *obj_rtld, int
 	}
 
 	got = obj->pltgot;
-	rellim = (const Elf_Rel *)((caddr_t)obj->rel + obj->relsize);
+	rellim = (const Elf_Rel *)((const char *)obj->rel + obj->relsize);
 	for (rel = obj->rel; rel < rellim; rel++) {
 		Elf_Word	r_symndx, r_type;
 		void		*where;
@@ -657,7 +657,7 @@ reloc_plt(Obj_Entry *obj, int flags __unused, RtldLock
 	const Elf_Rel *rellim;
 	const Elf_Rel *rel;
 
-	rellim = (const Elf_Rel *)((char *)obj->pltrel + obj->pltrelsize);
+	rellim = (const Elf_Rel *)((const char *)obj->pltrel + obj->pltrelsize);
 	for (rel = obj->pltrel; rel < rellim; rel++) {
 		Elf_Addr *where;
 
@@ -687,7 +687,7 @@ reloc_jmpslots(Obj_Entry *obj, int flags, RtldLockStat
 	const Elf_Rel *rel;
 	const Elf_Sym *def;
 
-	rellim = (const Elf_Rel *)((char *)obj->pltrel + obj->pltrelsize);
+	rellim = (const Elf_Rel *)((const char *)obj->pltrel + obj->pltrelsize);
 	for (rel = obj->pltrel; rel < rellim; rel++) {
 		Elf_Addr *where;
 
@@ -714,7 +714,8 @@ reloc_jmpslots(Obj_Entry *obj, int flags, RtldLockStat
 }
 
 int
-reloc_iresolve(Obj_Entry *obj, struct Struct_RtldLockState *lockstate)
+reloc_iresolve(Obj_Entry *obj __unused,
+    struct Struct_RtldLockState *lockstate __unused)
 {
 
 	/* XXX not implemented */
@@ -722,8 +723,8 @@ reloc_iresolve(Obj_Entry *obj, struct Struct_RtldLockS
 }
 
 int
-reloc_gnu_ifunc(Obj_Entry *obj, int flags,
-    struct Struct_RtldLockState *lockstate)
+reloc_gnu_ifunc(Obj_Entry *obj __unused, int flags __unused,
+    struct Struct_RtldLockState *lockstate __unused)
 {
 
 	/* XXX not implemented */
@@ -731,8 +732,9 @@ reloc_gnu_ifunc(Obj_Entry *obj, int flags,
 }
 
 Elf_Addr
-reloc_jmpslot(Elf_Addr *where, Elf_Addr target, const Obj_Entry *defobj,
-    		const Obj_Entry *obj, const Elf_Rel *rel)
+reloc_jmpslot(Elf_Addr *where, Elf_Addr target,
+    const Obj_Entry *defobj __unused, const Obj_Entry *obj __unused,
+    const Elf_Rel *rel)
 {
 
 	assert(ELF_R_TYPE(rel->r_info) == R_MIPS_JUMP_SLOT);

Modified: stable/12/libexec/rtld-elf/mips/rtld_machdep.h
==============================================================================
--- stable/12/libexec/rtld-elf/mips/rtld_machdep.h	Mon Feb 11 14:57:29 2019	(r344010)
+++ stable/12/libexec/rtld-elf/mips/rtld_machdep.h	Mon Feb 11 15:02:02 2019	(r344011)
@@ -43,6 +43,9 @@ struct Struct_Obj_Entry;
 Elf_Addr reloc_jmpslot(Elf_Addr *where, Elf_Addr target,
     const struct Struct_Obj_Entry *defobj, const struct Struct_Obj_Entry *obj,
     const Elf_Rel *rel);
+Elf_Addr _mips_rtld_bind(struct Struct_Obj_Entry *obj, Elf_Size reloff);
+void *_mips_get_tls(void);
+
 
 #define make_function_pointer(def, defobj) \
 	((defobj)->relocbase + (def)->st_value)

Modified: stable/12/libexec/rtld-elf/paths.h
==============================================================================
--- stable/12/libexec/rtld-elf/paths.h	Mon Feb 11 14:57:29 2019	(r344010)
+++ stable/12/libexec/rtld-elf/paths.h	Mon Feb 11 15:02:02 2019	(r344011)
@@ -69,10 +69,10 @@
 #define	SOFT_STANDARD_LIBRARY_PATH "/usr/libsoft"
 #define	LD_SOFT_		"LD_SOFT_"
 
-extern char *ld_elf_hints_default;
-extern char *ld_path_libmap_conf;
-extern char *ld_path_rtld;
-extern char *ld_standard_library_path;
-extern char *ld_env_prefix;
+extern const char *ld_elf_hints_default;
+extern const char *ld_path_libmap_conf;
+extern const char *ld_path_rtld;
+extern const char *ld_standard_library_path;
+extern const char *ld_env_prefix;
 
 #endif /* PATHS_H */

Modified: stable/12/libexec/rtld-elf/powerpc/reloc.c
==============================================================================
--- stable/12/libexec/rtld-elf/powerpc/reloc.c	Mon Feb 11 14:57:29 2019	(r344010)
+++ stable/12/libexec/rtld-elf/powerpc/reloc.c	Mon Feb 11 15:02:02 2019	(r344011)
@@ -71,7 +71,7 @@ do_copy_relocations(Obj_Entry *dstobj)
 	 */
 	assert(dstobj->mainprog);
 
-	relalim = (const Elf_Rela *) ((caddr_t) dstobj->rela +
+	relalim = (const Elf_Rela *)((const char *) dstobj->rela +
 	    dstobj->relasize);
 	for (rela = dstobj->rela;  rela < relalim;  rela++) {
 		void *dstaddr;
@@ -88,7 +88,7 @@ do_copy_relocations(Obj_Entry *dstobj)
 			continue;
 		}
 
-		dstaddr = (void *) (dstobj->relocbase + rela->r_offset);
+		dstaddr = (void *)(dstobj->relocbase + rela->r_offset);
 		dstsym = dstobj->symtab + ELF_R_SYM(rela->r_info);
 		name = dstobj->strtab + dstsym->st_name;
 		size = dstsym->st_size;
@@ -113,7 +113,7 @@ do_copy_relocations(Obj_Entry *dstobj)
 			return (-1);
 		}
 
-		srcaddr = (const void *) (defobj->relocbase+srcsym->st_value);
+		srcaddr = (const void *)(defobj->relocbase+srcsym->st_value);
 		memcpy(dstaddr, srcaddr, size);
 		dbg("copy_reloc: src=%p,dst=%p,size=%d\n",srcaddr,dstaddr,size);
 	}
@@ -149,7 +149,7 @@ reloc_non_plt_self(Elf_Dyn *dynp, Elf_Addr relocbase)
 	/*
 	 * Relocate these values
 	 */
-	relalim = (const Elf_Rela *)((caddr_t)rela + relasz);
+	relalim = (const Elf_Rela *)((const char *)rela + relasz);
 	for (; rela < relalim; rela++) {
 		where = (Elf_Addr *)(relocbase + rela->r_offset);
 		*where = (Elf_Addr)(relocbase + rela->r_addend);
@@ -161,8 +161,8 @@ reloc_non_plt_self(Elf_Dyn *dynp, Elf_Addr relocbase)
  * Relocate a non-PLT object with addend.
  */
 static int
-reloc_nonplt_object(Obj_Entry *obj_rtld, Obj_Entry *obj, const Elf_Rela *rela,
-    SymCache *cache, int flags, RtldLockState *lockstate)
+reloc_nonplt_object(Obj_Entry *obj_rtld __unused, Obj_Entry *obj,
+    const Elf_Rela *rela, SymCache *cache, int flags, RtldLockState *lockstate)
 {
 	Elf_Addr        *where = (Elf_Addr *)(obj->relocbase + rela->r_offset);
 	const Elf_Sym   *def;
@@ -249,7 +249,8 @@ reloc_nonplt_object(Obj_Entry *obj_rtld, Obj_Entry *ob
 		 * error.
 		 */
 		if (!defobj->tls_done) {
-			if (!allocate_tls_offset((Obj_Entry*) defobj)) {
+			if (!allocate_tls_offset(
+				    __DECONST(Obj_Entry *, defobj))) {
 				_rtld_error("%s: No space available for static "
 				    "Thread Local Storage", obj->path);
 				return (-1);
@@ -315,7 +316,7 @@ reloc_non_plt(Obj_Entry *obj, Obj_Entry *obj_rtld, int
 	 * "The PowerPC family uses only the Elf32_Rela relocation
 	 *  entries with explicit addends."
 	 */
-	relalim = (const Elf_Rela *)((caddr_t)obj->rela + obj->relasize);
+	relalim = (const Elf_Rela *)((const char *)obj->rela + obj->relasize);
 	for (rela = obj->rela; rela < relalim; rela++) {
 		if (reloc_nonplt_object(obj_rtld, obj, rela, cache, flags,
 		    lockstate) < 0)
@@ -398,7 +399,7 @@ reloc_plt(Obj_Entry *obj, int flags __unused, RtldLock
 
 	if (obj->pltrelasize != 0) {
 
-		relalim = (const Elf_Rela *)((char *)obj->pltrela +
+		relalim = (const Elf_Rela *)((const char *)obj->pltrela +
 		    obj->pltrelasize);
 		for (rela = obj->pltrela;  rela < relalim;  rela++) {
 			assert(ELF_R_TYPE(rela->r_info) == R_PPC_JMP_SLOT);
@@ -433,7 +434,8 @@ reloc_jmpslots(Obj_Entry *obj, int flags, RtldLockStat
 	Elf_Addr *where;
 	Elf_Addr target;
 
-	relalim = (const Elf_Rela *)((char *)obj->pltrela + obj->pltrelasize);
+	relalim = (const Elf_Rela *)((const char *)obj->pltrela +
+	    obj->pltrelasize);
 	for (rela = obj->pltrela; rela < relalim; rela++) {
 		assert(ELF_R_TYPE(rela->r_info) == R_PPC_JMP_SLOT);
 		where = (Elf_Addr *)(obj->relocbase + rela->r_offset);
@@ -469,8 +471,8 @@ reloc_jmpslots(Obj_Entry *obj, int flags, RtldLockStat
  * trampoline call and jump table.
  */
 Elf_Addr
-reloc_jmpslot(Elf_Addr *wherep, Elf_Addr target, const Obj_Entry *defobj,
-    const Obj_Entry *obj, const Elf_Rel *rel)
+reloc_jmpslot(Elf_Addr *wherep, Elf_Addr target,
+    const Obj_Entry *defobj __unused, const Obj_Entry *obj, const Elf_Rel *rel)
 {
 	Elf_Addr offset;
 	const Elf_Rela *rela = (const Elf_Rela *) rel;
@@ -529,7 +531,8 @@ out:
 }
 
 int
-reloc_iresolve(Obj_Entry *obj, struct Struct_RtldLockState *lockstate)
+reloc_iresolve(Obj_Entry *obj __unused,
+    struct Struct_RtldLockState *lockstate __unused)
 {
 
 	/* XXX not implemented */
@@ -537,8 +540,8 @@ reloc_iresolve(Obj_Entry *obj, struct Struct_RtldLockS
 }
 
 int
-reloc_gnu_ifunc(Obj_Entry *obj, int flags,
-    struct Struct_RtldLockState *lockstate)
+reloc_gnu_ifunc(Obj_Entry *obj __unused, int flags __unused,
+    struct Struct_RtldLockState *lockstate __unused)
 {
 
 	/* XXX not implemented */
@@ -650,7 +653,7 @@ allocate_initial_tls(Obj_Entry *list)
 
 	tls_static_space = tls_last_offset + tls_last_size + RTLD_STATIC_TLS_EXTRA;

*** DIFF OUTPUT TRUNCATED AT 1000 LINES ***



Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?201902111502.x1BF23Rv025647>