toolchain/musl/patches/000-update-to-git-2016-01-22.patch

   1 --- a/.gitignore
   2 +++ b/.gitignore
   3 @@ -5,9 +5,6 @@
   4  *.so.1
   5  arch/*/bits/alltypes.h
   6  config.mak
   7 -include/bits
   8 -tools/musl-gcc
   9 -tools/musl-clang
  10 -tools/ld.musl-clang
  11  lib/musl-gcc.specs
  12  src/internal/version.h
  13 +/obj/
  14 --- a/Makefile
  15 +++ b/Makefile
  16 @@ -8,6 +8,7 @@
  17  # Do not make changes here.
  18  #
  19
  20 +srcdir = .
  21  exec_prefix = /usr/local
  22  bindir = $(exec_prefix)/bin
  23
  24 @@ -16,31 +17,38 @@ includedir = $(prefix)/include
  25  libdir = $(prefix)/lib
  26  syslibdir = /lib
  27
  28 -SRCS = $(sort $(wildcard src/*/*.c arch/$(ARCH)/src/*.c))
  29 -OBJS = $(SRCS:.c=.o)
  30 +BASE_SRCS = $(sort $(wildcard $(srcdir)/src/*/*.c $(srcdir)/arch/$(ARCH)/src/*.[csS]))
  31 +BASE_OBJS = $(patsubst $(srcdir)/%,%.o,$(basename $(BASE_SRCS)))
  32 +ARCH_SRCS = $(wildcard $(srcdir)/src/*/$(ARCH)/*.[csS])
  33 +ARCH_OBJS = $(patsubst $(srcdir)/%,%.o,$(basename $(ARCH_SRCS)))
  34 +REPLACED_OBJS = $(sort $(subst /$(ARCH)/,/,$(ARCH_OBJS)))
  35 +OBJS = $(addprefix obj/, $(filter-out $(REPLACED_OBJS), $(sort $(BASE_OBJS) $(ARCH_OBJS))))
  36  LOBJS = $(OBJS:.o=.lo)
  37 -GENH = include/bits/alltypes.h
  38 -GENH_INT = src/internal/version.h
  39 -IMPH = src/internal/stdio_impl.h src/internal/pthread_impl.h src/internal/libc.h
  40 +GENH = obj/include/bits/alltypes.h
  41 +GENH_INT = obj/src/internal/version.h
  42 +IMPH = $(addprefix $(srcdir)/, src/internal/stdio_impl.h src/internal/pthread_impl.h src/internal/libc.h)
  43
  44 -LDFLAGS =
  45 +LDFLAGS =
  46 +LDFLAGS_AUTO =
  47  LIBCC = -lgcc
  48  CPPFLAGS =
  49 -CFLAGS = -Os -pipe
  50 +CFLAGS =
  51 +CFLAGS_AUTO = -Os -pipe
  52  CFLAGS_C99FSE = -std=c99 -ffreestanding -nostdinc
  53
  54  CFLAGS_ALL = $(CFLAGS_C99FSE)
  55 -CFLAGS_ALL += -D_XOPEN_SOURCE=700 -I./arch/$(ARCH) -I./src/internal -I./include
  56 -CFLAGS_ALL += $(CPPFLAGS) $(CFLAGS)
  57 -CFLAGS_ALL_STATIC = $(CFLAGS_ALL)
  58 -CFLAGS_ALL_SHARED = $(CFLAGS_ALL) -fPIC -DSHARED
  59 +CFLAGS_ALL += -D_XOPEN_SOURCE=700 -I$(srcdir)/arch/$(ARCH) -Iobj/src/internal -I$(srcdir)/src/internal -Iobj/include -I$(srcdir)/include
  60 +CFLAGS_ALL += $(CPPFLAGS) $(CFLAGS_AUTO) $(CFLAGS)
  61 +
  62 +LDFLAGS_ALL = $(LDFLAGS_AUTO) $(LDFLAGS)
  63
  64  AR      = $(CROSS_COMPILE)ar
  65  RANLIB  = $(CROSS_COMPILE)ranlib
  66 -INSTALL = ./tools/install.sh
  67 +INSTALL = $(srcdir)/tools/install.sh
  68
  69 -ARCH_INCLUDES = $(wildcard arch/$(ARCH)/bits/*.h)
  70 -ALL_INCLUDES = $(sort $(wildcard include/*.h include/*/*.h) $(GENH) $(ARCH_INCLUDES:arch/$(ARCH)/%=include/%))
  71 +ARCH_INCLUDES = $(wildcard $(srcdir)/arch/$(ARCH)/bits/*.h)
  72 +INCLUDES = $(wildcard $(srcdir)/include/*.h $(srcdir)/include/*/*.h)
  73 +ALL_INCLUDES = $(sort $(INCLUDES:$(srcdir)/%=%) $(GENH:obj/%=%) $(ARCH_INCLUDES:$(srcdir)/arch/$(ARCH)/%=include/%))
  74
  75  EMPTY_LIB_NAMES = m rt pthread crypt util xnet resolv dl
  76  EMPTY_LIBS = $(EMPTY_LIB_NAMES:%=lib/lib%.a)
  77 @@ -49,7 +57,7 @@ STATIC_LIBS = lib/libc.a
  78  SHARED_LIBS = lib/libc.so
  79  TOOL_LIBS = lib/musl-gcc.specs
  80  ALL_LIBS = $(CRT_LIBS) $(STATIC_LIBS) $(SHARED_LIBS) $(EMPTY_LIBS) $(TOOL_LIBS)
  81 -ALL_TOOLS = tools/musl-gcc
  82 +ALL_TOOLS = obj/musl-gcc
  83
  84  WRAPCC_GCC = gcc
  85  WRAPCC_CLANG = clang
  86 @@ -58,95 +66,93 @@ LDSO_PATHNAME = $(syslibdir)/ld-musl-$(A
  87
  88  -include config.mak
  89
  90 +ifeq ($(ARCH),)
  91 +$(error Please set ARCH in config.mak before running make.)
  92 +endif
  93 +
  94  all: $(ALL_LIBS) $(ALL_TOOLS)
  95
  96 +OBJ_DIRS = $(sort $(patsubst %/,%,$(dir $(ALL_LIBS) $(ALL_TOOLS) $(OBJS) $(GENH) $(GENH_INT))) $(addprefix obj/, crt crt/$(ARCH) include))
  97 +
  98 +$(ALL_LIBS) $(ALL_TOOLS) $(CRT_LIBS:lib/%=obj/crt/%) $(OBJS) $(LOBJS) $(GENH) $(GENH_INT): | $(OBJ_DIRS)
  99 +
 100 +$(OBJ_DIRS):
 101 +       mkdir -p $@
 102 +
 103  install: install-libs install-headers install-tools
 104
 105  clean:
 106 -       rm -f crt/*.o
 107 -       rm -f $(OBJS)
 108 -       rm -f $(LOBJS)
 109 -       rm -f $(ALL_LIBS) lib/*.[ao] lib/*.so
 110 -       rm -f $(ALL_TOOLS)
 111 -       rm -f $(GENH) $(GENH_INT)
 112 -       rm -f include/bits
 113 +       rm -rf obj lib
 114
 115  distclean: clean
 116         rm -f config.mak
 117
 118 -include/bits:
 119 -       @test "$(ARCH)" || { echo "Please set ARCH in config.mak before running make." ; exit 1 ; }
 120 -       ln -sf ../arch/$(ARCH)/bits $@
 121 +obj/include/bits/alltypes.h: $(srcdir)/arch/$(ARCH)/bits/alltypes.h.in $(srcdir)/include/alltypes.h.in $(srcdir)/tools/mkalltypes.sed
 122 +       sed -f $(srcdir)/tools/mkalltypes.sed $(srcdir)/arch/$(ARCH)/bits/alltypes.h.in $(srcdir)/include/alltypes.h.in > $@
 123
 124 -include/bits/alltypes.h.in: include/bits
 125 +obj/src/internal/version.h: $(wildcard $(srcdir)/VERSION $(srcdir)/.git)
 126 +       printf '#define VERSION "%s"\n' "$$(cd $(srcdir); sh tools/version.sh)" > $@
 127
 128 -include/bits/alltypes.h: include/bits/alltypes.h.in include/alltypes.h.in tools/mkalltypes.sed
 129 -       sed -f tools/mkalltypes.sed include/bits/alltypes.h.in include/alltypes.h.in > $@
 130 +obj/src/internal/version.o obj/src/internal/version.lo: obj/src/internal/version.h
 131
 132 -src/internal/version.h: $(wildcard VERSION .git)
 133 -       printf '#define VERSION "%s"\n' "$$(sh tools/version.sh)" > $@
 134 +obj/crt/rcrt1.o obj/src/ldso/dlstart.lo obj/src/ldso/dynlink.lo: $(srcdir)/src/internal/dynlink.h $(srcdir)/arch/$(ARCH)/reloc.h
 135
 136 -src/internal/version.lo: src/internal/version.h
 137 +obj/crt/crt1.o obj/crt/scrt1.o obj/crt/rcrt1.o obj/src/ldso/dlstart.lo: $(srcdir)/arch/$(ARCH)/crt_arch.h
 138
 139 -crt/rcrt1.o src/ldso/dlstart.lo src/ldso/dynlink.lo: src/internal/dynlink.h arch/$(ARCH)/reloc.h
 140 +obj/crt/rcrt1.o: $(srcdir)/src/ldso/dlstart.c
 141
 142 -crt/crt1.o crt/Scrt1.o crt/rcrt1.o src/ldso/dlstart.lo: $(wildcard arch/$(ARCH)/crt_arch.h)
 143 +obj/crt/Scrt1.o obj/crt/rcrt1.o: CFLAGS_ALL += -fPIC
 144
 145 -crt/rcrt1.o: src/ldso/dlstart.c
 146 +obj/crt/$(ARCH)/crti.o: $(srcdir)/crt/$(ARCH)/crti.s
 147
 148 -crt/Scrt1.o crt/rcrt1.o: CFLAGS += -fPIC
 149 +obj/crt/$(ARCH)/crtn.o: $(srcdir)/crt/$(ARCH)/crtn.s
 150
 151 -OPTIMIZE_SRCS = $(wildcard $(OPTIMIZE_GLOBS:%=src/%))
 152 -$(OPTIMIZE_SRCS:%.c=%.o) $(OPTIMIZE_SRCS:%.c=%.lo): CFLAGS += -O3
 153 +OPTIMIZE_SRCS = $(wildcard $(OPTIMIZE_GLOBS:%=$(srcdir)/src/%))
 154 +$(OPTIMIZE_SRCS:$(srcdir)/%.c=obj/%.o) $(OPTIMIZE_SRCS:$(srcdir)/%.c=obj/%.lo): CFLAGS += -O3
 155
 156  MEMOPS_SRCS = src/string/memcpy.c src/string/memmove.c src/string/memcmp.c src/string/memset.c
 157 -$(MEMOPS_SRCS:%.c=%.o) $(MEMOPS_SRCS:%.c=%.lo): CFLAGS += $(CFLAGS_MEMOPS)
 158 +$(MEMOPS_SRCS:%.c=obj/%.o) $(MEMOPS_SRCS:%.c=obj/%.lo): CFLAGS_ALL += $(CFLAGS_MEMOPS)
 159
 160  NOSSP_SRCS = $(wildcard crt/*.c) \
 161         src/env/__libc_start_main.c src/env/__init_tls.c \
 162         src/thread/__set_thread_area.c src/env/__stack_chk_fail.c \
 163         src/string/memset.c src/string/memcpy.c \
 164         src/ldso/dlstart.c src/ldso/dynlink.c
 165 -$(NOSSP_SRCS:%.c=%.o) $(NOSSP_SRCS:%.c=%.lo): CFLAGS += $(CFLAGS_NOSSP)
 166 +$(NOSSP_SRCS:%.c=obj/%.o) $(NOSSP_SRCS:%.c=obj/%.lo): CFLAGS_ALL += $(CFLAGS_NOSSP)
 167 +
 168 +$(CRT_LIBS:lib/%=obj/crt/%): CFLAGS_ALL += -DCRT
 169
 170 -$(CRT_LIBS:lib/%=crt/%): CFLAGS += -DCRT
 171 +$(LOBJS): CFLAGS_ALL += -fPIC -DSHARED
 172
 173 -# This incantation ensures that changes to any subarch asm files will
 174 -# force the corresponding object file to be rebuilt, even if the implicit
 175 -# rule below goes indirectly through a .sub file.
 176 -define mkasmdep
 177 -$(dir $(patsubst %/,%,$(dir $(1))))$(notdir $(1:.s=.o)): $(1)
 178 -endef
 179 -$(foreach s,$(wildcard src/*/$(ARCH)*/*.s),$(eval $(call mkasmdep,$(s))))
 180 +CC_CMD = $(CC) $(CFLAGS_ALL) -c -o $@ $<
 181
 182  # Choose invocation of assembler to be used
 183 -# $(1) is input file, $(2) is output file, $(3) is assembler flags
 184  ifeq ($(ADD_CFI),yes)
 185 -       AS_CMD = LC_ALL=C awk -f tools/add-cfi.common.awk -f tools/add-cfi.$(ARCH).awk $< | $(CC) -x assembler -c -o $@ -
 186 +       AS_CMD = LC_ALL=C awk -f $(srcdir)/tools/add-cfi.common.awk -f $(srcdir)/tools/add-cfi.$(ARCH).awk $< | $(CC) $(CFLAGS_ALL) -x assembler -c -o $@ -
 187  else
 188 -       AS_CMD = $(CC) -c -o $@ $<
 189 +       AS_CMD = $(CC_CMD)
 190  endif
 191
 192 -%.o: $(ARCH)$(ASMSUBARCH)/%.sub
 193 -       $(CC) $(CFLAGS_ALL_STATIC) -c -o $@ $(dir $<)$(shell cat $<)
 194 +obj/%.o: $(srcdir)/%.s
 195 +       $(AS_CMD)
 196
 197 -%.o: $(ARCH)/%.s
 198 -       $(AS_CMD) $(CFLAGS_ALL_STATIC)
 199 +obj/%.o: $(srcdir)/%.S
 200 +       $(CC_CMD)
 201
 202 -%.o: %.c $(GENH) $(IMPH)
 203 -       $(CC) $(CFLAGS_ALL_STATIC) -c -o $@ $<
 204 +obj/%.o: $(srcdir)/%.c $(GENH) $(IMPH)
 205 +       $(CC_CMD)
 206
 207 -%.lo: $(ARCH)$(ASMSUBARCH)/%.sub
 208 -       $(CC) $(CFLAGS_ALL_SHARED) -c -o $@ $(dir $<)$(shell cat $<)
 209 +obj/%.lo: $(srcdir)/%.s
 210 +       $(AS_CMD)
 211
 212 -%.lo: $(ARCH)/%.s
 213 -       $(AS_CMD) $(CFLAGS_ALL_SHARED)
 214 +obj/%.lo: $(srcdir)/%.S
 215 +       $(CC_CMD)
 216
 217 -%.lo: %.c $(GENH) $(IMPH)
 218 -       $(CC) $(CFLAGS_ALL_SHARED) -c -o $@ $<
 219 +obj/%.lo: $(srcdir)/%.c $(GENH) $(IMPH)
 220 +       $(CC_CMD)
 221
 222  lib/libc.so: $(LOBJS)
 223 -       $(CC) $(CFLAGS_ALL_SHARED) $(LDFLAGS) -nostdlib -shared \
 224 +       $(CC) $(CFLAGS_ALL) $(LDFLAGS_ALL) -nostdlib -shared \
 225         -Wl,-e,_dlstart -Wl,-Bsymbolic-functions \
 226         -o $@ $(LOBJS) $(LIBCC)
 227
 228 @@ -159,21 +165,27 @@ $(EMPTY_LIBS):
 229         rm -f $@
 230         $(AR) rc $@
 231
 232 -lib/%.o: crt/%.o
 233 +lib/%.o: obj/crt/%.o
 234         cp $< $@
 235
 236 -lib/musl-gcc.specs: tools/musl-gcc.specs.sh config.mak
 237 +lib/crti.o: obj/crt/$(ARCH)/crti.o
 238 +       cp $< $@
 239 +
 240 +lib/crtn.o: obj/crt/$(ARCH)/crtn.o
 241 +       cp $< $@
 242 +
 243 +lib/musl-gcc.specs: $(srcdir)/tools/musl-gcc.specs.sh config.mak
 244         sh $< "$(includedir)" "$(libdir)" "$(LDSO_PATHNAME)" > $@
 245
 246 -tools/musl-gcc: config.mak
 247 +obj/musl-gcc: config.mak
 248         printf '#!/bin/sh\nexec "$${REALGCC:-$(WRAPCC_GCC)}" "$$@" -specs "%s/musl-gcc.specs"\n' "$(libdir)" > $@
 249         chmod +x $@
 250
 251 -tools/%-clang: tools/%-clang.in config.mak
 252 +obj/%-clang: $(srcdir)/tools/%-clang.in config.mak
 253         sed -e 's!@CC@!$(WRAPCC_CLANG)!g' -e 's!@PREFIX@!$(prefix)!g' -e 's!@INCDIR@!$(includedir)!g' -e 's!@LIBDIR@!$(libdir)!g' -e 's!@LDSO@!$(LDSO_PATHNAME)!g' $< > $@
 254         chmod +x $@
 255
 256 -$(DESTDIR)$(bindir)/%: tools/%
 257 +$(DESTDIR)$(bindir)/%: obj/%
 258         $(INSTALL) -D $< $@
 259
 260  $(DESTDIR)$(libdir)/%.so: lib/%.so
 261 @@ -182,10 +194,13 @@ $(DESTDIR)$(libdir)/%.so: lib/%.so
 262  $(DESTDIR)$(libdir)/%: lib/%
 263         $(INSTALL) -D -m 644 $< $@
 264
 265 -$(DESTDIR)$(includedir)/bits/%: arch/$(ARCH)/bits/%
 266 +$(DESTDIR)$(includedir)/bits/%: $(srcdir)/arch/$(ARCH)/bits/%
 267 +       $(INSTALL) -D -m 644 $< $@
 268 +
 269 +$(DESTDIR)$(includedir)/bits/%: obj/include/bits/%
 270         $(INSTALL) -D -m 644 $< $@
 271
 272 -$(DESTDIR)$(includedir)/%: include/%
 273 +$(DESTDIR)$(includedir)/%: $(srcdir)/include/%
 274         $(INSTALL) -D -m 644 $< $@
 275
 276  $(DESTDIR)$(LDSO_PATHNAME): $(DESTDIR)$(libdir)/libc.so
 277 @@ -195,12 +210,12 @@ install-libs: $(ALL_LIBS:lib/%=$(DESTDIR
 278
 279  install-headers: $(ALL_INCLUDES:include/%=$(DESTDIR)$(includedir)/%)
 280
 281 -install-tools: $(ALL_TOOLS:tools/%=$(DESTDIR)$(bindir)/%)
 282 +install-tools: $(ALL_TOOLS:obj/%=$(DESTDIR)$(bindir)/%)
 283
 284  musl-git-%.tar.gz: .git
 285 -        git archive --format=tar.gz --prefix=$(patsubst %.tar.gz,%,$@)/ -o $@ $(patsubst musl-git-%.tar.gz,%,$@)
 286 +        git --git-dir=$(srcdir)/.git archive --format=tar.gz --prefix=$(patsubst %.tar.gz,%,$@)/ -o $@ $(patsubst musl-git-%.tar.gz,%,$@)
 287
 288  musl-%.tar.gz: .git
 289 -        git archive --format=tar.gz --prefix=$(patsubst %.tar.gz,%,$@)/ -o $@ v$(patsubst musl-%.tar.gz,%,$@)
 290 +        git --git-dir=$(srcdir)/.git archive --format=tar.gz --prefix=$(patsubst %.tar.gz,%,$@)/ -o $@ v$(patsubst musl-%.tar.gz,%,$@)
 291
 292  .PHONY: all clean install install-libs install-headers install-tools
 293 --- a/arch/aarch64/atomic.h
 294 +++ /dev/null
 295 @@ -1,206 +0,0 @@
 296 -#ifndef _INTERNAL_ATOMIC_H
 297 -#define _INTERNAL_ATOMIC_H
 298 -
 299 -#include <stdint.h>
 300 -
 301 -static inline int a_ctz_64(uint64_t x)
 302 -{
 303 -       __asm__(
 304 -               "       rbit %0, %1\n"
 305 -               "       clz %0, %0\n"
 306 -               : "=r"(x) : "r"(x));
 307 -       return x;
 308 -}
 309 -
 310 -static inline int a_ctz_l(unsigned long x)
 311 -{
 312 -       return a_ctz_64(x);
 313 -}
 314 -
 315 -static inline void a_barrier()
 316 -{
 317 -       __asm__ __volatile__("dmb ish");
 318 -}
 319 -
 320 -static inline void *a_cas_p(volatile void *p, void *t, void *s)
 321 -{
 322 -       void *old;
 323 -       __asm__ __volatile__(
 324 -               "       dmb ish\n"
 325 -               "1:     ldxr %0,%3\n"
 326 -               "       cmp %0,%1\n"
 327 -               "       b.ne 1f\n"
 328 -               "       stxr %w0,%2,%3\n"
 329 -               "       cbnz %w0,1b\n"
 330 -               "       mov %0,%1\n"
 331 -               "1:     dmb ish\n"
 332 -               : "=&r"(old)
 333 -               : "r"(t), "r"(s), "Q"(*(long*)p)
 334 -               : "memory", "cc");
 335 -       return old;
 336 -}
 337 -
 338 -static inline int a_cas(volatile int *p, int t, int s)
 339 -{
 340 -       int old;
 341 -       __asm__ __volatile__(
 342 -               "       dmb ish\n"
 343 -               "1:     ldxr %w0,%3\n"
 344 -               "       cmp %w0,%w1\n"
 345 -               "       b.ne 1f\n"
 346 -               "       stxr %w0,%w2,%3\n"
 347 -               "       cbnz %w0,1b\n"
 348 -               "       mov %w0,%w1\n"
 349 -               "1:     dmb ish\n"
 350 -               : "=&r"(old)
 351 -               : "r"(t), "r"(s), "Q"(*p)
 352 -               : "memory", "cc");
 353 -       return old;
 354 -}
 355 -
 356 -static inline int a_swap(volatile int *x, int v)
 357 -{
 358 -       int old, tmp;
 359 -       __asm__ __volatile__(
 360 -               "       dmb ish\n"
 361 -               "1:     ldxr %w0,%3\n"
 362 -               "       stxr %w1,%w2,%3\n"
 363 -               "       cbnz %w1,1b\n"
 364 -               "       dmb ish\n"
 365 -               : "=&r"(old), "=&r"(tmp)
 366 -               : "r"(v), "Q"(*x)
 367 -               : "memory", "cc" );
 368 -       return old;
 369 -}
 370 -
 371 -static inline int a_fetch_add(volatile int *x, int v)
 372 -{
 373 -       int old, tmp;
 374 -       __asm__ __volatile__(
 375 -               "       dmb ish\n"
 376 -               "1:     ldxr %w0,%3\n"
 377 -               "       add %w0,%w0,%w2\n"
 378 -               "       stxr %w1,%w0,%3\n"
 379 -               "       cbnz %w1,1b\n"
 380 -               "       dmb ish\n"
 381 -               : "=&r"(old), "=&r"(tmp)
 382 -               : "r"(v), "Q"(*x)
 383 -               : "memory", "cc" );
 384 -       return old-v;
 385 -}
 386 -
 387 -static inline void a_inc(volatile int *x)
 388 -{
 389 -       int tmp, tmp2;
 390 -       __asm__ __volatile__(
 391 -               "       dmb ish\n"
 392 -               "1:     ldxr %w0,%2\n"
 393 -               "       add %w0,%w0,#1\n"
 394 -               "       stxr %w1,%w0,%2\n"
 395 -               "       cbnz %w1,1b\n"
 396 -               "       dmb ish\n"
 397 -               : "=&r"(tmp), "=&r"(tmp2)
 398 -               : "Q"(*x)
 399 -               : "memory", "cc" );
 400 -}
 401 -
 402 -static inline void a_dec(volatile int *x)
 403 -{
 404 -       int tmp, tmp2;
 405 -       __asm__ __volatile__(
 406 -               "       dmb ish\n"
 407 -               "1:     ldxr %w0,%2\n"
 408 -               "       sub %w0,%w0,#1\n"
 409 -               "       stxr %w1,%w0,%2\n"
 410 -               "       cbnz %w1,1b\n"
 411 -               "       dmb ish\n"
 412 -               : "=&r"(tmp), "=&r"(tmp2)
 413 -               : "Q"(*x)
 414 -               : "memory", "cc" );
 415 -}
 416 -
 417 -static inline void a_and_64(volatile uint64_t *p, uint64_t v)
 418 -{
 419 -       int tmp, tmp2;
 420 -       __asm__ __volatile__(
 421 -               "       dmb ish\n"
 422 -               "1:     ldxr %0,%3\n"
 423 -               "       and %0,%0,%2\n"
 424 -               "       stxr %w1,%0,%3\n"
 425 -               "       cbnz %w1,1b\n"
 426 -               "       dmb ish\n"
 427 -               : "=&r"(tmp), "=&r"(tmp2)
 428 -               : "r"(v), "Q"(*p)
 429 -               : "memory", "cc" );
 430 -}
 431 -
 432 -static inline void a_and(volatile int *p, int v)
 433 -{
 434 -       int tmp, tmp2;
 435 -       __asm__ __volatile__(
 436 -               "       dmb ish\n"
 437 -               "1:     ldxr %w0,%3\n"
 438 -               "       and %w0,%w0,%w2\n"
 439 -               "       stxr %w1,%w0,%3\n"
 440 -               "       cbnz %w1,1b\n"
 441 -               "       dmb ish\n"
 442 -               : "=&r"(tmp), "=&r"(tmp2)
 443 -               : "r"(v), "Q"(*p)
 444 -               : "memory", "cc" );
 445 -}
 446 -
 447 -static inline void a_or_64(volatile uint64_t *p, uint64_t v)
 448 -{
 449 -       int tmp, tmp2;
 450 -       __asm__ __volatile__(
 451 -               "       dmb ish\n"
 452 -               "1:     ldxr %0,%3\n"
 453 -               "       orr %0,%0,%2\n"
 454 -               "       stxr %w1,%0,%3\n"
 455 -               "       cbnz %w1,1b\n"
 456 -               "       dmb ish\n"
 457 -               : "=&r"(tmp), "=&r"(tmp2)
 458 -               : "r"(v), "Q"(*p)
 459 -               : "memory", "cc" );
 460 -}
 461 -
 462 -static inline void a_or_l(volatile void *p, long v)
 463 -{
 464 -       return a_or_64(p, v);
 465 -}
 466 -
 467 -static inline void a_or(volatile int *p, int v)
 468 -{
 469 -       int tmp, tmp2;
 470 -       __asm__ __volatile__(
 471 -               "       dmb ish\n"
 472 -               "1:     ldxr %w0,%3\n"
 473 -               "       orr %w0,%w0,%w2\n"
 474 -               "       stxr %w1,%w0,%3\n"
 475 -               "       cbnz %w1,1b\n"
 476 -               "       dmb ish\n"
 477 -               : "=&r"(tmp), "=&r"(tmp2)
 478 -               : "r"(v), "Q"(*p)
 479 -               : "memory", "cc" );
 480 -}
 481 -
 482 -static inline void a_store(volatile int *p, int x)
 483 -{
 484 -       __asm__ __volatile__(
 485 -               "       dmb ish\n"
 486 -               "       str %w1,%0\n"
 487 -               "       dmb ish\n"
 488 -               : "=m"(*p)
 489 -               : "r"(x)
 490 -               : "memory", "cc" );
 491 -}
 492 -
 493 -#define a_spin a_barrier
 494 -
 495 -static inline void a_crash()
 496 -{
 497 -       *(volatile char *)0=0;
 498 -}
 499 -
 500 -
 501 -#endif
 502 --- /dev/null
 503 +++ b/arch/aarch64/atomic_arch.h
 504 @@ -0,0 +1,53 @@
 505 +#define a_ll a_ll
 506 +static inline int a_ll(volatile int *p)
 507 +{
 508 +       int v;
 509 +       __asm__ __volatile__ ("ldxr %0, %1" : "=r"(v) : "Q"(*p));
 510 +       return v;
 511 +}
 512 +
 513 +#define a_sc a_sc
 514 +static inline int a_sc(volatile int *p, int v)
 515 +{
 516 +       int r;
 517 +       __asm__ __volatile__ ("stxr %w0,%1,%2" : "=&r"(r) : "r"(v), "Q"(*p) : "memory");
 518 +       return !r;
 519 +}
 520 +
 521 +#define a_barrier a_barrier
 522 +static inline void a_barrier()
 523 +{
 524 +       __asm__ __volatile__ ("dmb ish" : : : "memory");
 525 +}
 526 +
 527 +#define a_pre_llsc a_barrier
 528 +#define a_post_llsc a_barrier
 529 +
 530 +#define a_cas_p a_cas_p
 531 +static inline void *a_cas_p(volatile void *p, void *t, void *s)
 532 +{
 533 +       void *old;
 534 +       __asm__ __volatile__(
 535 +               "       dmb ish\n"
 536 +               "1:     ldxr %0,%3\n"
 537 +               "       cmp %0,%1\n"
 538 +               "       b.ne 1f\n"
 539 +               "       stxr %w0,%2,%3\n"
 540 +               "       cbnz %w0,1b\n"
 541 +               "       mov %0,%1\n"
 542 +               "1:     dmb ish\n"
 543 +               : "=&r"(old)
 544 +               : "r"(t), "r"(s), "Q"(*(void *volatile *)p)
 545 +               : "memory", "cc");
 546 +       return old;
 547 +}
 548 +
 549 +#define a_ctz_64 a_ctz_64
 550 +static inline int a_ctz_64(uint64_t x)
 551 +{
 552 +       __asm__(
 553 +               "       rbit %0, %1\n"
 554 +               "       clz %0, %0\n"
 555 +               : "=r"(x) : "r"(x));
 556 +       return x;
 557 +}
 558 --- a/arch/aarch64/pthread_arch.h
 559 +++ b/arch/aarch64/pthread_arch.h
 560 @@ -8,4 +8,4 @@ static inline struct pthread *__pthread_
 561  #define TLS_ABOVE_TP
 562  #define TP_ADJ(p) ((char *)(p) + sizeof(struct pthread) - 16)
 563
 564 -#define CANCEL_REG_IP 33
 565 +#define MC_PC pc
 566 --- a/arch/arm/atomic.h
 567 +++ /dev/null
 568 @@ -1,261 +0,0 @@
 569 -#ifndef _INTERNAL_ATOMIC_H
 570 -#define _INTERNAL_ATOMIC_H
 571 -
 572 -#include <stdint.h>
 573 -
 574 -static inline int a_ctz_l(unsigned long x)
 575 -{
 576 -       static const char debruijn32[32] = {
 577 -               0, 1, 23, 2, 29, 24, 19, 3, 30, 27, 25, 11, 20, 8, 4, 13,
 578 -               31, 22, 28, 18, 26, 10, 7, 12, 21, 17, 9, 6, 16, 5, 15, 14
 579 -       };
 580 -       return debruijn32[(x&-x)*0x076be629 >> 27];
 581 -}
 582 -
 583 -static inline int a_ctz_64(uint64_t x)
 584 -{
 585 -       uint32_t y = x;
 586 -       if (!y) {
 587 -               y = x>>32;
 588 -               return 32 + a_ctz_l(y);
 589 -       }
 590 -       return a_ctz_l(y);
 591 -}
 592 -
 593 -#if __ARM_ARCH_7A__ || __ARM_ARCH_7R__ ||  __ARM_ARCH >= 7
 594 -
 595 -static inline void a_barrier()
 596 -{
 597 -       __asm__ __volatile__("dmb ish");
 598 -}
 599 -
 600 -static inline int a_cas(volatile int *p, int t, int s)
 601 -{
 602 -       int old;
 603 -       __asm__ __volatile__(
 604 -               "       dmb ish\n"
 605 -               "1:     ldrex %0,%3\n"
 606 -               "       cmp %0,%1\n"
 607 -               "       bne 1f\n"
 608 -               "       strex %0,%2,%3\n"
 609 -               "       cmp %0, #0\n"
 610 -               "       bne 1b\n"
 611 -               "       mov %0, %1\n"
 612 -               "1:     dmb ish\n"
 613 -               : "=&r"(old)
 614 -               : "r"(t), "r"(s), "Q"(*p)
 615 -               : "memory", "cc" );
 616 -       return old;
 617 -}
 618 -
 619 -static inline int a_swap(volatile int *x, int v)
 620 -{
 621 -       int old, tmp;
 622 -       __asm__ __volatile__(
 623 -               "       dmb ish\n"
 624 -               "1:     ldrex %0,%3\n"
 625 -               "       strex %1,%2,%3\n"
 626 -               "       cmp %1, #0\n"
 627 -               "       bne 1b\n"
 628 -               "       dmb ish\n"
 629 -               : "=&r"(old), "=&r"(tmp)
 630 -               : "r"(v), "Q"(*x)
 631 -               : "memory", "cc" );
 632 -       return old;
 633 -}
 634 -
 635 -static inline int a_fetch_add(volatile int *x, int v)
 636 -{
 637 -       int old, tmp;
 638 -       __asm__ __volatile__(
 639 -               "       dmb ish\n"
 640 -               "1:     ldrex %0,%3\n"
 641 -               "       add %0,%0,%2\n"
 642 -               "       strex %1,%0,%3\n"
 643 -               "       cmp %1, #0\n"
 644 -               "       bne 1b\n"
 645 -               "       dmb ish\n"
 646 -               : "=&r"(old), "=&r"(tmp)
 647 -               : "r"(v), "Q"(*x)
 648 -               : "memory", "cc" );
 649 -       return old-v;
 650 -}
 651 -
 652 -static inline void a_inc(volatile int *x)
 653 -{
 654 -       int tmp, tmp2;
 655 -       __asm__ __volatile__(
 656 -               "       dmb ish\n"
 657 -               "1:     ldrex %0,%2\n"
 658 -               "       add %0,%0,#1\n"
 659 -               "       strex %1,%0,%2\n"
 660 -               "       cmp %1, #0\n"
 661 -               "       bne 1b\n"
 662 -               "       dmb ish\n"
 663 -               : "=&r"(tmp), "=&r"(tmp2)
 664 -               : "Q"(*x)
 665 -               : "memory", "cc" );
 666 -}
 667 -
 668 -static inline void a_dec(volatile int *x)
 669 -{
 670 -       int tmp, tmp2;
 671 -       __asm__ __volatile__(
 672 -               "       dmb ish\n"
 673 -               "1:     ldrex %0,%2\n"
 674 -               "       sub %0,%0,#1\n"
 675 -               "       strex %1,%0,%2\n"
 676 -               "       cmp %1, #0\n"
 677 -               "       bne 1b\n"
 678 -               "       dmb ish\n"
 679 -               : "=&r"(tmp), "=&r"(tmp2)
 680 -               : "Q"(*x)
 681 -               : "memory", "cc" );
 682 -}
 683 -
 684 -static inline void a_and(volatile int *x, int v)
 685 -{
 686 -       int tmp, tmp2;
 687 -       __asm__ __volatile__(
 688 -               "       dmb ish\n"
 689 -               "1:     ldrex %0,%3\n"
 690 -               "       and %0,%0,%2\n"
 691 -               "       strex %1,%0,%3\n"
 692 -               "       cmp %1, #0\n"
 693 -               "       bne 1b\n"
 694 -               "       dmb ish\n"
 695 -               : "=&r"(tmp), "=&r"(tmp2)
 696 -               : "r"(v), "Q"(*x)
 697 -               : "memory", "cc" );
 698 -}
 699 -
 700 -static inline void a_or(volatile int *x, int v)
 701 -{
 702 -       int tmp, tmp2;
 703 -       __asm__ __volatile__(
 704 -               "       dmb ish\n"
 705 -               "1:     ldrex %0,%3\n"
 706 -               "       orr %0,%0,%2\n"
 707 -               "       strex %1,%0,%3\n"
 708 -               "       cmp %1, #0\n"
 709 -               "       bne 1b\n"
 710 -               "       dmb ish\n"
 711 -               : "=&r"(tmp), "=&r"(tmp2)
 712 -               : "r"(v), "Q"(*x)
 713 -               : "memory", "cc" );
 714 -}
 715 -
 716 -static inline void a_store(volatile int *p, int x)
 717 -{
 718 -       __asm__ __volatile__(
 719 -               "       dmb ish\n"
 720 -               "       str %1,%0\n"
 721 -               "       dmb ish\n"
 722 -               : "=m"(*p)
 723 -               : "r"(x)
 724 -               : "memory", "cc" );
 725 -}
 726 -
 727 -#else
 728 -
 729 -int __a_cas(int, int, volatile int *) __attribute__((__visibility__("hidden")));
 730 -#define __k_cas __a_cas
 731 -
 732 -static inline void a_barrier()
 733 -{
 734 -       __asm__ __volatile__("bl __a_barrier"
 735 -               : : : "memory", "cc", "ip", "lr" );
 736 -}
 737 -
 738 -static inline int a_cas(volatile int *p, int t, int s)
 739 -{
 740 -       int old;
 741 -       for (;;) {
 742 -               if (!__k_cas(t, s, p))
 743 -                       return t;
 744 -               if ((old=*p) != t)
 745 -                       return old;
 746 -       }
 747 -}
 748 -
 749 -static inline int a_swap(volatile int *x, int v)
 750 -{
 751 -       int old;
 752 -       do old = *x;
 753 -       while (__k_cas(old, v, x));
 754 -       return old;
 755 -}
 756 -
 757 -static inline int a_fetch_add(volatile int *x, int v)
 758 -{
 759 -       int old;
 760 -       do old = *x;
 761 -       while (__k_cas(old, old+v, x));
 762 -       return old;
 763 -}
 764 -
 765 -static inline void a_inc(volatile int *x)
 766 -{
 767 -       a_fetch_add(x, 1);
 768 -}
 769 -
 770 -static inline void a_dec(volatile int *x)
 771 -{
 772 -       a_fetch_add(x, -1);
 773 -}
 774 -
 775 -static inline void a_store(volatile int *p, int x)
 776 -{
 777 -       a_barrier();
 778 -       *p = x;
 779 -       a_barrier();
 780 -}
 781 -
 782 -static inline void a_and(volatile int *p, int v)
 783 -{
 784 -       int old;
 785 -       do old = *p;
 786 -       while (__k_cas(old, old&v, p));
 787 -}
 788 -
 789 -static inline void a_or(volatile int *p, int v)
 790 -{
 791 -       int old;
 792 -       do old = *p;
 793 -       while (__k_cas(old, old|v, p));
 794 -}
 795 -
 796 -#endif
 797 -
 798 -static inline void *a_cas_p(volatile void *p, void *t, void *s)
 799 -{
 800 -       return (void *)a_cas(p, (int)t, (int)s);
 801 -}
 802 -
 803 -#define a_spin a_barrier
 804 -
 805 -static inline void a_crash()
 806 -{
 807 -       *(volatile char *)0=0;
 808 -}
 809 -
 810 -static inline void a_or_l(volatile void *p, long v)
 811 -{
 812 -       a_or(p, v);
 813 -}
 814 -
 815 -static inline void a_and_64(volatile uint64_t *p, uint64_t v)
 816 -{
 817 -       union { uint64_t v; uint32_t r[2]; } u = { v };
 818 -       a_and((int *)p, u.r[0]);
 819 -       a_and((int *)p+1, u.r[1]);
 820 -}
 821 -
 822 -static inline void a_or_64(volatile uint64_t *p, uint64_t v)
 823 -{
 824 -       union { uint64_t v; uint32_t r[2]; } u = { v };
 825 -       a_or((int *)p, u.r[0]);
 826 -       a_or((int *)p+1, u.r[1]);
 827 -}
 828 -
 829 -#endif
 830 --- /dev/null
 831 +++ b/arch/arm/atomic_arch.h
 832 @@ -0,0 +1,64 @@
 833 +__attribute__((__visibility__("hidden")))
 834 +extern const void *__arm_atomics[3]; /* gettp, cas, barrier */
 835 +
 836 +#if ((__ARM_ARCH_6__ || __ARM_ARCH_6K__ || __ARM_ARCH_6ZK__) && !__thumb__) \
 837 + || __ARM_ARCH_7A__ || __ARM_ARCH_7R__ ||  __ARM_ARCH >= 7
 838 +
 839 +#define a_ll a_ll
 840 +static inline int a_ll(volatile int *p)
 841 +{
 842 +       int v;
 843 +       __asm__ __volatile__ ("ldrex %0, %1" : "=r"(v) : "Q"(*p));
 844 +       return v;
 845 +}
 846 +
 847 +#define a_sc a_sc
 848 +static inline int a_sc(volatile int *p, int v)
 849 +{
 850 +       int r;
 851 +       __asm__ __volatile__ ("strex %0,%1,%2" : "=&r"(r) : "r"(v), "Q"(*p) : "memory");
 852 +       return !r;
 853 +}
 854 +
 855 +#if __ARM_ARCH_7A__ || __ARM_ARCH_7R__ ||  __ARM_ARCH >= 7
 856 +
 857 +#define a_barrier a_barrier
 858 +static inline void a_barrier()
 859 +{
 860 +       __asm__ __volatile__ ("dmb ish" : : : "memory");
 861 +}
 862 +
 863 +#endif
 864 +
 865 +#define a_pre_llsc a_barrier
 866 +#define a_post_llsc a_barrier
 867 +
 868 +#else
 869 +
 870 +#define a_cas a_cas
 871 +static inline int a_cas(volatile int *p, int t, int s)
 872 +{
 873 +       for (;;) {
 874 +               register int r0 __asm__("r0") = t;
 875 +               register int r1 __asm__("r1") = s;
 876 +               register volatile int *r2 __asm__("r2") = p;
 877 +               int old;
 878 +               __asm__ __volatile__ (
 879 +                       "bl __a_cas"
 880 +                       : "+r"(r0) : "r"(r1), "r"(r2)
 881 +                       : "memory", "r3", "lr", "ip", "cc" );
 882 +               if (!r0) return t;
 883 +               if ((old=*p)!=t) return old;
 884 +       }
 885 +}
 886 +
 887 +#endif
 888 +
 889 +#ifndef a_barrier
 890 +#define a_barrier a_barrier
 891 +static inline void a_barrier()
 892 +{
 893 +       __asm__ __volatile__("bl __a_barrier"
 894 +               : : : "memory", "cc", "ip", "lr" );
 895 +}
 896 +#endif
 897 --- a/arch/arm/pthread_arch.h
 898 +++ b/arch/arm/pthread_arch.h
 899 @@ -27,4 +27,4 @@ static inline pthread_t __pthread_self()
 900  #define TLS_ABOVE_TP
 901  #define TP_ADJ(p) ((char *)(p) + sizeof(struct pthread) - 8)
 902
 903 -#define CANCEL_REG_IP 18
 904 +#define MC_PC arm_pc
 905 --- a/arch/arm/reloc.h
 906 +++ b/arch/arm/reloc.h
 907 @@ -6,10 +6,10 @@
 908  #define ENDIAN_SUFFIX ""
 909  #endif
 910
 911 -#if __SOFTFP__
 912 -#define FP_SUFFIX ""
 913 -#else
 914 +#if __ARM_PCS_VFP
 915  #define FP_SUFFIX "hf"
 916 +#else
 917 +#define FP_SUFFIX ""
 918  #endif
 919
 920  #define LDSO_ARCH "arm" ENDIAN_SUFFIX FP_SUFFIX
 921 @@ -28,10 +28,5 @@
 922  #define REL_TPOFF       R_ARM_TLS_TPOFF32
 923  //#define REL_TLSDESC     R_ARM_TLS_DESC
 924
 925 -#ifdef __thumb__
 926  #define CRTJMP(pc,sp) __asm__ __volatile__( \
 927         "mov sp,%1 ; bx %0" : : "r"(pc), "r"(sp) : "memory" )
 928 -#else
 929 -#define CRTJMP(pc,sp) __asm__ __volatile__( \
 930 -       "mov sp,%1 ; tst %0,#1 ; moveq pc,%0 ; bx %0" : : "r"(pc), "r"(sp) : "memory" )
 931 -#endif
 932 --- a/arch/arm/src/__aeabi_atexit.c
 933 +++ /dev/null
 934 @@ -1,6 +0,0 @@
 935 -int __cxa_atexit(void (*func)(void *), void *arg, void *dso);
 936 -
 937 -int __aeabi_atexit (void *obj, void (*func) (void *), void *d)
 938 -{
 939 -       return __cxa_atexit (func, obj, d);
 940 -}
 941 --- a/arch/arm/src/__aeabi_memclr.c
 942 +++ /dev/null
 943 @@ -1,9 +0,0 @@
 944 -#include <string.h>
 945 -#include "libc.h"
 946 -
 947 -void __aeabi_memclr(void *dest, size_t n)
 948 -{
 949 -       memset(dest, 0, n);
 950 -}
 951 -weak_alias(__aeabi_memclr, __aeabi_memclr4);
 952 -weak_alias(__aeabi_memclr, __aeabi_memclr8);
 953 --- a/arch/arm/src/__aeabi_memcpy.c
 954 +++ /dev/null
 955 @@ -1,9 +0,0 @@
 956 -#include <string.h>
 957 -#include "libc.h"
 958 -
 959 -void __aeabi_memcpy(void *restrict dest, const void *restrict src, size_t n)
 960 -{
 961 -       memcpy(dest, src, n);
 962 -}
 963 -weak_alias(__aeabi_memcpy, __aeabi_memcpy4);
 964 -weak_alias(__aeabi_memcpy, __aeabi_memcpy8);
 965 --- a/arch/arm/src/__aeabi_memmove.c
 966 +++ /dev/null
 967 @@ -1,9 +0,0 @@
 968 -#include <string.h>
 969 -#include "libc.h"
 970 -
 971 -void __aeabi_memmove(void *dest, const void *src, size_t n)
 972 -{
 973 -       memmove(dest, src, n);
 974 -}
 975 -weak_alias(__aeabi_memmove, __aeabi_memmove4);
 976 -weak_alias(__aeabi_memmove, __aeabi_memmove8);
 977 --- a/arch/arm/src/__aeabi_memset.c
 978 +++ /dev/null
 979 @@ -1,9 +0,0 @@
 980 -#include <string.h>
 981 -#include "libc.h"
 982 -
 983 -void __aeabi_memset(void *dest, size_t n, int c)
 984 -{
 985 -       memset(dest, c, n);
 986 -}
 987 -weak_alias(__aeabi_memset, __aeabi_memset4);
 988 -weak_alias(__aeabi_memset, __aeabi_memset8);
 989 --- a/arch/arm/src/__set_thread_area.c
 990 +++ /dev/null
 991 @@ -1,49 +0,0 @@
 992 -#include <stdint.h>
 993 -#include <elf.h>
 994 -#include "pthread_impl.h"
 995 -#include "libc.h"
 996 -
 997 -#define HWCAP_TLS (1 << 15)
 998 -
 999 -extern const unsigned char __attribute__((__visibility__("hidden")))
1000 -       __a_barrier_dummy[], __a_barrier_oldkuser[],
1001 -       __a_barrier_v6[], __a_barrier_v7[],
1002 -       __a_cas_dummy[], __a_cas_v6[], __a_cas_v7[],
1003 -       __a_gettp_dummy[];
1004 -
1005 -#define __a_barrier_kuser 0xffff0fa0
1006 -#define __a_cas_kuser 0xffff0fc0
1007 -#define __a_gettp_kuser 0xffff0fe0
1008 -
1009 -extern uintptr_t __attribute__((__visibility__("hidden")))
1010 -       __a_barrier_ptr, __a_cas_ptr, __a_gettp_ptr;
1011 -
1012 -#define SET(op,ver) (__a_##op##_ptr = \
1013 -       (uintptr_t)__a_##op##_##ver - (uintptr_t)__a_##op##_dummy)
1014 -
1015 -int __set_thread_area(void *p)
1016 -{
1017 -#if !__ARM_ARCH_7A__ && !__ARM_ARCH_7R__ && __ARM_ARCH < 7
1018 -       if (__hwcap & HWCAP_TLS) {
1019 -               size_t *aux;
1020 -               SET(cas, v7);
1021 -               SET(barrier, v7);
1022 -               for (aux=libc.auxv; *aux; aux+=2) {
1023 -                       if (*aux != AT_PLATFORM) continue;
1024 -                       const char *s = (void *)aux[1];
1025 -                       if (s[0]!='v' || s[1]!='6' || s[2]-'0'<10u) break;
1026 -                       SET(cas, v6);
1027 -                       SET(barrier, v6);
1028 -                       break;
1029 -               }
1030 -       } else {
1031 -               int ver = *(int *)0xffff0ffc;
1032 -               SET(gettp, kuser);
1033 -               SET(cas, kuser);
1034 -               SET(barrier, kuser);
1035 -               if (ver < 2) a_crash();
1036 -               if (ver < 3) SET(barrier, oldkuser);
1037 -       }
1038 -#endif
1039 -       return __syscall(0xf0005, p);
1040 -}
1041 --- a/arch/arm/src/arm/atomics.s
1042 +++ /dev/null
1043 @@ -1,116 +0,0 @@
1044 -.text
1045 -
1046 -.global __a_barrier
1047 -.hidden __a_barrier
1048 -.type __a_barrier,%function
1049 -__a_barrier:
1050 -       ldr ip,1f
1051 -       ldr ip,[pc,ip]
1052 -       add pc,pc,ip
1053 -1:     .word __a_barrier_ptr-1b
1054 -.global __a_barrier_dummy
1055 -.hidden __a_barrier_dummy
1056 -__a_barrier_dummy:
1057 -       tst lr,#1
1058 -       moveq pc,lr
1059 -       bx lr
1060 -.global __a_barrier_oldkuser
1061 -.hidden __a_barrier_oldkuser
1062 -__a_barrier_oldkuser:
1063 -       push {r0,r1,r2,r3,ip,lr}
1064 -       mov r1,r0
1065 -       mov r2,sp
1066 -       ldr ip,=0xffff0fc0
1067 -       mov lr,pc
1068 -       mov pc,ip
1069 -       pop {r0,r1,r2,r3,ip,lr}
1070 -       tst lr,#1
1071 -       moveq pc,lr
1072 -       bx lr
1073 -.global __a_barrier_v6
1074 -.hidden __a_barrier_v6
1075 -__a_barrier_v6:
1076 -       mcr p15,0,r0,c7,c10,5
1077 -       bx lr
1078 -.global __a_barrier_v7
1079 -.hidden __a_barrier_v7
1080 -__a_barrier_v7:
1081 -       .word 0xf57ff05b        /* dmb ish */
1082 -       bx lr
1083 -
1084 -.global __a_cas
1085 -.hidden __a_cas
1086 -.type __a_cas,%function
1087 -__a_cas:
1088 -       ldr ip,1f
1089 -       ldr ip,[pc,ip]
1090 -       add pc,pc,ip
1091 -1:     .word __a_cas_ptr-1b
1092 -.global __a_cas_dummy
1093 -.hidden __a_cas_dummy
1094 -__a_cas_dummy:
1095 -       mov r3,r0
1096 -       ldr r0,[r2]
1097 -       subs r0,r3,r0
1098 -       streq r1,[r2]
1099 -       tst lr,#1
1100 -       moveq pc,lr
1101 -       bx lr
1102 -.global __a_cas_v6
1103 -.hidden __a_cas_v6
1104 -__a_cas_v6:
1105 -       mov r3,r0
1106 -       mcr p15,0,r0,c7,c10,5
1107 -1:     .word 0xe1920f9f        /* ldrex r0,[r2] */
1108 -       subs r0,r3,r0
1109 -       .word 0x01820f91        /* strexeq r0,r1,[r2] */
1110 -       teqeq r0,#1
1111 -       beq 1b
1112 -       mcr p15,0,r0,c7,c10,5
1113 -       bx lr
1114 -.global __a_cas_v7
1115 -.hidden __a_cas_v7
1116 -__a_cas_v7:
1117 -       mov r3,r0
1118 -       .word 0xf57ff05b        /* dmb ish */
1119 -1:     .word 0xe1920f9f        /* ldrex r0,[r2] */
1120 -       subs r0,r3,r0
1121 -       .word 0x01820f91        /* strexeq r0,r1,[r2] */
1122 -       teqeq r0,#1
1123 -       beq 1b
1124 -       .word 0xf57ff05b        /* dmb ish */
1125 -       bx lr
1126 -
1127 -.global __aeabi_read_tp
1128 -.type __aeabi_read_tp,%function
1129 -__aeabi_read_tp:
1130 -
1131 -.global __a_gettp
1132 -.hidden __a_gettp
1133 -.type __a_gettp,%function
1134 -__a_gettp:
1135 -       ldr r0,1f
1136 -       ldr r0,[pc,r0]
1137 -       add pc,pc,r0
1138 -1:     .word __a_gettp_ptr-1b
1139 -.global __a_gettp_dummy
1140 -.hidden __a_gettp_dummy
1141 -__a_gettp_dummy:
1142 -       mrc p15,0,r0,c13,c0,3
1143 -       bx lr
1144 -
1145 -.data
1146 -.global __a_barrier_ptr
1147 -.hidden __a_barrier_ptr
1148 -__a_barrier_ptr:
1149 -       .word 0
1150 -
1151 -.global __a_cas_ptr
1152 -.hidden __a_cas_ptr
1153 -__a_cas_ptr:
1154 -       .word 0
1155 -
1156 -.global __a_gettp_ptr
1157 -.hidden __a_gettp_ptr
1158 -__a_gettp_ptr:
1159 -       .word 0
1160 --- a/arch/arm/src/find_exidx.c
1161 +++ /dev/null
1162 @@ -1,42 +0,0 @@
1163 -#define _GNU_SOURCE
1164 -#include <link.h>
1165 -#include <stdint.h>
1166 -
1167 -struct find_exidx_data {
1168 -       uintptr_t pc, exidx_start;
1169 -       int exidx_len;
1170 -};
1171 -
1172 -static int find_exidx(struct dl_phdr_info *info, size_t size, void *ptr)
1173 -{
1174 -       struct find_exidx_data *data = ptr;
1175 -       const ElfW(Phdr) *phdr = info->dlpi_phdr;
1176 -       uintptr_t addr, exidx_start = 0;
1177 -       int i, match = 0, exidx_len = 0;
1178 -
1179 -       for (i = info->dlpi_phnum; i > 0; i--, phdr++) {
1180 -               addr = info->dlpi_addr + phdr->p_vaddr;
1181 -               switch (phdr->p_type) {
1182 -               case PT_LOAD:
1183 -                       match |= data->pc >= addr && data->pc < addr + phdr->p_memsz;
1184 -                       break;
1185 -               case PT_ARM_EXIDX:
1186 -                       exidx_start = addr;
1187 -                       exidx_len = phdr->p_memsz;
1188 -                       break;
1189 -               }
1190 -       }
1191 -       data->exidx_start = exidx_start;
1192 -       data->exidx_len = exidx_len;
1193 -       return match;
1194 -}
1195 -
1196 -uintptr_t __gnu_Unwind_Find_exidx(uintptr_t pc, int *pcount)
1197 -{
1198 -       struct find_exidx_data data;
1199 -       data.pc = pc;
1200 -       if (dl_iterate_phdr(find_exidx, &data) <= 0)
1201 -               return 0;
1202 -       *pcount = data.exidx_len / 8;
1203 -       return data.exidx_start;
1204 -}
1205 --- a/arch/i386/atomic.h
1206 +++ /dev/null
1207 @@ -1,110 +0,0 @@
1208 -#ifndef _INTERNAL_ATOMIC_H
1209 -#define _INTERNAL_ATOMIC_H
1210 -
1211 -#include <stdint.h>
1212 -
1213 -static inline int a_ctz_64(uint64_t x)
1214 -{
1215 -       int r;
1216 -       __asm__( "bsf %1,%0 ; jnz 1f ; bsf %2,%0 ; addl $32,%0\n1:"
1217 -               : "=&r"(r) : "r"((unsigned)x), "r"((unsigned)(x>>32)) );
1218 -       return r;
1219 -}
1220 -
1221 -static inline int a_ctz_l(unsigned long x)
1222 -{
1223 -       long r;
1224 -       __asm__( "bsf %1,%0" : "=r"(r) : "r"(x) );
1225 -       return r;
1226 -}
1227 -
1228 -static inline void a_and_64(volatile uint64_t *p, uint64_t v)
1229 -{
1230 -       __asm__( "lock ; andl %1, (%0) ; lock ; andl %2, 4(%0)"
1231 -               : : "r"((long *)p), "r"((unsigned)v), "r"((unsigned)(v>>32)) : "memory" );
1232 -}
1233 -
1234 -static inline void a_or_64(volatile uint64_t *p, uint64_t v)
1235 -{
1236 -       __asm__( "lock ; orl %1, (%0) ; lock ; orl %2, 4(%0)"
1237 -               : : "r"((long *)p), "r"((unsigned)v), "r"((unsigned)(v>>32)) : "memory" );
1238 -}
1239 -
1240 -static inline void a_or_l(volatile void *p, long v)
1241 -{
1242 -       __asm__( "lock ; orl %1, %0"
1243 -               : "=m"(*(long *)p) : "r"(v) : "memory" );
1244 -}
1245 -
1246 -static inline void *a_cas_p(volatile void *p, void *t, void *s)
1247 -{
1248 -       __asm__( "lock ; cmpxchg %3, %1"
1249 -               : "=a"(t), "=m"(*(long *)p) : "a"(t), "r"(s) : "memory" );
1250 -       return t;
1251 -}
1252 -
1253 -static inline int a_cas(volatile int *p, int t, int s)
1254 -{
1255 -       __asm__( "lock ; cmpxchg %3, %1"
1256 -               : "=a"(t), "=m"(*p) : "a"(t), "r"(s) : "memory" );
1257 -       return t;
1258 -}
1259 -
1260 -static inline void a_or(volatile int *p, int v)
1261 -{
1262 -       __asm__( "lock ; orl %1, %0"
1263 -               : "=m"(*p) : "r"(v) : "memory" );
1264 -}
1265 -
1266 -static inline void a_and(volatile int *p, int v)
1267 -{
1268 -       __asm__( "lock ; andl %1, %0"
1269 -               : "=m"(*p) : "r"(v) : "memory" );
1270 -}
1271 -
1272 -static inline int a_swap(volatile int *x, int v)
1273 -{
1274 -       __asm__( "xchg %0, %1" : "=r"(v), "=m"(*x) : "0"(v) : "memory" );
1275 -       return v;
1276 -}
1277 -
1278 -#define a_xchg a_swap
1279 -
1280 -static inline int a_fetch_add(volatile int *x, int v)
1281 -{
1282 -       __asm__( "lock ; xadd %0, %1" : "=r"(v), "=m"(*x) : "0"(v) : "memory" );
1283 -       return v;
1284 -}
1285 -
1286 -static inline void a_inc(volatile int *x)
1287 -{
1288 -       __asm__( "lock ; incl %0" : "=m"(*x) : "m"(*x) : "memory" );
1289 -}
1290 -
1291 -static inline void a_dec(volatile int *x)
1292 -{
1293 -       __asm__( "lock ; decl %0" : "=m"(*x) : "m"(*x) : "memory" );
1294 -}
1295 -
1296 -static inline void a_store(volatile int *p, int x)
1297 -{
1298 -       __asm__( "movl %1, %0 ; lock ; orl $0,(%%esp)" : "=m"(*p) : "r"(x) : "memory" );
1299 -}
1300 -
1301 -static inline void a_spin()
1302 -{
1303 -       __asm__ __volatile__( "pause" : : : "memory" );
1304 -}
1305 -
1306 -static inline void a_barrier()
1307 -{
1308 -       __asm__ __volatile__( "" : : : "memory" );
1309 -}
1310 -
1311 -static inline void a_crash()
1312 -{
1313 -       __asm__ __volatile__( "hlt" : : : "memory" );
1314 -}
1315 -
1316 -
1317 -#endif
1318 --- /dev/null
1319 +++ b/arch/i386/atomic_arch.h
1320 @@ -0,0 +1,109 @@
1321 +#define a_ctz_64 a_ctz_64
1322 +static inline int a_ctz_64(uint64_t x)
1323 +{
1324 +       int r;
1325 +       __asm__( "bsf %1,%0 ; jnz 1f ; bsf %2,%0 ; addl $32,%0\n1:"
1326 +               : "=&r"(r) : "r"((unsigned)x), "r"((unsigned)(x>>32)) );
1327 +       return r;
1328 +}
1329 +
1330 +#define a_ctz_l a_ctz_l
1331 +static inline int a_ctz_l(unsigned long x)
1332 +{
1333 +       long r;
1334 +       __asm__( "bsf %1,%0" : "=r"(r) : "r"(x) );
1335 +       return r;
1336 +}
1337 +
1338 +#define a_and_64 a_and_64
1339 +static inline void a_and_64(volatile uint64_t *p, uint64_t v)
1340 +{
1341 +       __asm__( "lock ; andl %1, (%0) ; lock ; andl %2, 4(%0)"
1342 +               : : "r"((long *)p), "r"((unsigned)v), "r"((unsigned)(v>>32)) : "memory" );
1343 +}
1344 +
1345 +#define a_or_64 a_or_64
1346 +static inline void a_or_64(volatile uint64_t *p, uint64_t v)
1347 +{
1348 +       __asm__( "lock ; orl %1, (%0) ; lock ; orl %2, 4(%0)"
1349 +               : : "r"((long *)p), "r"((unsigned)v), "r"((unsigned)(v>>32)) : "memory" );
1350 +}
1351 +
1352 +#define a_or_l a_or_l
1353 +static inline void a_or_l(volatile void *p, long v)
1354 +{
1355 +       __asm__( "lock ; orl %1, %0"
1356 +               : "=m"(*(long *)p) : "r"(v) : "memory" );
1357 +}
1358 +
1359 +#define a_cas a_cas
1360 +static inline int a_cas(volatile int *p, int t, int s)
1361 +{
1362 +       __asm__( "lock ; cmpxchg %3, %1"
1363 +               : "=a"(t), "=m"(*p) : "a"(t), "r"(s) : "memory" );
1364 +       return t;
1365 +}
1366 +
1367 +#define a_or a_or
1368 +static inline void a_or(volatile int *p, int v)
1369 +{
1370 +       __asm__( "lock ; orl %1, %0"
1371 +               : "=m"(*p) : "r"(v) : "memory" );
1372 +}
1373 +
1374 +#define a_and a_and
1375 +static inline void a_and(volatile int *p, int v)
1376 +{
1377 +       __asm__( "lock ; andl %1, %0"
1378 +               : "=m"(*p) : "r"(v) : "memory" );
1379 +}
1380 +
1381 +#define a_swap a_swap
1382 +static inline int a_swap(volatile int *x, int v)
1383 +{
1384 +       __asm__( "xchg %0, %1" : "=r"(v), "=m"(*x) : "0"(v) : "memory" );
1385 +       return v;
1386 +}
1387 +
1388 +#define a_fetch_add a_fetch_add
1389 +static inline int a_fetch_add(volatile int *x, int v)
1390 +{
1391 +       __asm__( "lock ; xadd %0, %1" : "=r"(v), "=m"(*x) : "0"(v) : "memory" );
1392 +       return v;
1393 +}
1394 +
1395 +#define a_inc a_inc
1396 +static inline void a_inc(volatile int *x)
1397 +{
1398 +       __asm__( "lock ; incl %0" : "=m"(*x) : "m"(*x) : "memory" );
1399 +}
1400 +
1401 +#define a_dec a_dec
1402 +static inline void a_dec(volatile int *x)
1403 +{
1404 +       __asm__( "lock ; decl %0" : "=m"(*x) : "m"(*x) : "memory" );
1405 +}
1406 +
1407 +#define a_store a_store
1408 +static inline void a_store(volatile int *p, int x)
1409 +{
1410 +       __asm__( "movl %1, %0 ; lock ; orl $0,(%%esp)" : "=m"(*p) : "r"(x) : "memory" );
1411 +}
1412 +
1413 +#define a_spin a_spin
1414 +static inline void a_spin()
1415 +{
1416 +       __asm__ __volatile__( "pause" : : : "memory" );
1417 +}
1418 +
1419 +#define a_barrier a_barrier
1420 +static inline void a_barrier()
1421 +{
1422 +       __asm__ __volatile__( "" : : : "memory" );
1423 +}
1424 +
1425 +#define a_crash a_crash
1426 +static inline void a_crash()
1427 +{
1428 +       __asm__ __volatile__( "hlt" : : : "memory" );
1429 +}
1430 --- a/arch/i386/bits/alltypes.h.in
1431 +++ b/arch/i386/bits/alltypes.h.in
1432 @@ -26,10 +26,12 @@ TYPEDEF long double float_t;
1433  TYPEDEF long double double_t;
1434  #endif
1435
1436 -#ifdef __cplusplus
1437 -TYPEDEF struct { alignas(8) long long __ll; long double __ld; } max_align_t;
1438 -#else
1439 +#if !defined(__cplusplus)
1440  TYPEDEF struct { _Alignas(8) long long __ll; long double __ld; } max_align_t;
1441 +#elif defined(__GNUC__)
1442 +TYPEDEF struct { __attribute__((__aligned__(8))) long long __ll; long double __ld; } max_align_t;
1443 +#else
1444 +TYPEDEF struct { alignas(8) long long __ll; long double __ld; } max_align_t;
1445  #endif
1446
1447  TYPEDEF long time_t;
1448 --- a/arch/i386/pthread_arch.h
1449 +++ b/arch/i386/pthread_arch.h
1450 @@ -7,4 +7,4 @@ static inline struct pthread *__pthread_
1451
1452  #define TP_ADJ(p) (p)
1453
1454 -#define CANCEL_REG_IP 14
1455 +#define MC_PC gregs[REG_EIP]
1456 --- a/arch/microblaze/atomic.h
1457 +++ /dev/null
1458 @@ -1,143 +0,0 @@
1459 -#ifndef _INTERNAL_ATOMIC_H
1460 -#define _INTERNAL_ATOMIC_H
1461 -
1462 -#include <stdint.h>
1463 -
1464 -static inline int a_ctz_l(unsigned long x)
1465 -{
1466 -       static const char debruijn32[32] = {
1467 -               0, 1, 23, 2, 29, 24, 19, 3, 30, 27, 25, 11, 20, 8, 4, 13,
1468 -               31, 22, 28, 18, 26, 10, 7, 12, 21, 17, 9, 6, 16, 5, 15, 14
1469 -       };
1470 -       return debruijn32[(x&-x)*0x076be629 >> 27];
1471 -}
1472 -
1473 -static inline int a_ctz_64(uint64_t x)
1474 -{
1475 -       uint32_t y = x;
1476 -       if (!y) {
1477 -               y = x>>32;
1478 -               return 32 + a_ctz_l(y);
1479 -       }
1480 -       return a_ctz_l(y);
1481 -}
1482 -
1483 -static inline int a_cas(volatile int *p, int t, int s)
1484 -{
1485 -       register int old, tmp;
1486 -       __asm__ __volatile__ (
1487 -               "       addi %0, r0, 0\n"
1488 -               "1:     lwx %0, %2, r0\n"
1489 -               "       rsubk %1, %0, %3\n"
1490 -               "       bnei %1, 1f\n"
1491 -               "       swx %4, %2, r0\n"
1492 -               "       addic %1, r0, 0\n"
1493 -               "       bnei %1, 1b\n"
1494 -               "1:     "
1495 -               : "=&r"(old), "=&r"(tmp)
1496 -               : "r"(p), "r"(t), "r"(s)
1497 -               : "cc", "memory" );
1498 -       return old;
1499 -}
1500 -
1501 -static inline void *a_cas_p(volatile void *p, void *t, void *s)
1502 -{
1503 -       return (void *)a_cas(p, (int)t, (int)s);
1504 -}
1505 -
1506 -static inline int a_swap(volatile int *x, int v)
1507 -{
1508 -       register int old, tmp;
1509 -       __asm__ __volatile__ (
1510 -               "       addi %0, r0, 0\n"
1511 -               "1:     lwx %0, %2, r0\n"
1512 -               "       swx %3, %2, r0\n"
1513 -               "       addic %1, r0, 0\n"
1514 -               "       bnei %1, 1b\n"
1515 -               "1:     "
1516 -               : "=&r"(old), "=&r"(tmp)
1517 -               : "r"(x), "r"(v)
1518 -               : "cc", "memory" );
1519 -       return old;
1520 -}
1521 -
1522 -static inline int a_fetch_add(volatile int *x, int v)
1523 -{
1524 -       register int new, tmp;
1525 -       __asm__ __volatile__ (
1526 -               "       addi %0, r0, 0\n"
1527 -               "1:     lwx %0, %2, r0\n"
1528 -               "       addk %0, %0, %3\n"
1529 -               "       swx %0, %2, r0\n"
1530 -               "       addic %1, r0, 0\n"
1531 -               "       bnei %1, 1b\n"
1532 -               "1:     "
1533 -               : "=&r"(new), "=&r"(tmp)
1534 -               : "r"(x), "r"(v)
1535 -               : "cc", "memory" );
1536 -       return new-v;
1537 -}
1538 -
1539 -static inline void a_inc(volatile int *x)
1540 -{
1541 -       a_fetch_add(x, 1);
1542 -}
1543 -
1544 -static inline void a_dec(volatile int *x)
1545 -{
1546 -       a_fetch_add(x, -1);
1547 -}
1548 -
1549 -static inline void a_store(volatile int *p, int x)
1550 -{
1551 -       __asm__ __volatile__ (
1552 -               "swi %1, %0"
1553 -               : "=m"(*p) : "r"(x) : "memory" );
1554 -}
1555 -
1556 -#define a_spin a_barrier
1557 -
1558 -static inline void a_barrier()
1559 -{
1560 -       a_cas(&(int){0}, 0, 0);
1561 -}
1562 -
1563 -static inline void a_crash()
1564 -{
1565 -       *(volatile char *)0=0;
1566 -}
1567 -
1568 -static inline void a_and(volatile int *p, int v)
1569 -{
1570 -       int old;
1571 -       do old = *p;
1572 -       while (a_cas(p, old, old&v) != old);
1573 -}
1574 -
1575 -static inline void a_or(volatile int *p, int v)
1576 -{
1577 -       int old;
1578 -       do old = *p;
1579 -       while (a_cas(p, old, old|v) != old);
1580 -}
1581 -
1582 -static inline void a_or_l(volatile void *p, long v)
1583 -{
1584 -       a_or(p, v);
1585 -}
1586 -
1587 -static inline void a_and_64(volatile uint64_t *p, uint64_t v)
1588 -{
1589 -       union { uint64_t v; uint32_t r[2]; } u = { v };
1590 -       a_and((int *)p, u.r[0]);
1591 -       a_and((int *)p+1, u.r[1]);
1592 -}
1593 -
1594 -static inline void a_or_64(volatile uint64_t *p, uint64_t v)
1595 -{
1596 -       union { uint64_t v; uint32_t r[2]; } u = { v };
1597 -       a_or((int *)p, u.r[0]);
1598 -       a_or((int *)p+1, u.r[1]);
1599 -}
1600 -
1601 -#endif
1602 --- /dev/null
1603 +++ b/arch/microblaze/atomic_arch.h
1604 @@ -0,0 +1,53 @@
1605 +#define a_cas a_cas
1606 +static inline int a_cas(volatile int *p, int t, int s)
1607 +{
1608 +       register int old, tmp;
1609 +       __asm__ __volatile__ (
1610 +               "       addi %0, r0, 0\n"
1611 +               "1:     lwx %0, %2, r0\n"
1612 +               "       rsubk %1, %0, %3\n"
1613 +               "       bnei %1, 1f\n"
1614 +               "       swx %4, %2, r0\n"
1615 +               "       addic %1, r0, 0\n"
1616 +               "       bnei %1, 1b\n"
1617 +               "1:     "
1618 +               : "=&r"(old), "=&r"(tmp)
1619 +               : "r"(p), "r"(t), "r"(s)
1620 +               : "cc", "memory" );
1621 +       return old;
1622 +}
1623 +
1624 +#define a_swap a_swap
1625 +static inline int a_swap(volatile int *x, int v)
1626 +{
1627 +       register int old, tmp;
1628 +       __asm__ __volatile__ (
1629 +               "       addi %0, r0, 0\n"
1630 +               "1:     lwx %0, %2, r0\n"
1631 +               "       swx %3, %2, r0\n"
1632 +               "       addic %1, r0, 0\n"
1633 +               "       bnei %1, 1b\n"
1634 +               "1:     "
1635 +               : "=&r"(old), "=&r"(tmp)
1636 +               : "r"(x), "r"(v)
1637 +               : "cc", "memory" );
1638 +       return old;
1639 +}
1640 +
1641 +#define a_fetch_add a_fetch_add
1642 +static inline int a_fetch_add(volatile int *x, int v)
1643 +{
1644 +       register int new, tmp;
1645 +       __asm__ __volatile__ (
1646 +               "       addi %0, r0, 0\n"
1647 +               "1:     lwx %0, %2, r0\n"
1648 +               "       addk %0, %0, %3\n"
1649 +               "       swx %0, %2, r0\n"
1650 +               "       addic %1, r0, 0\n"
1651 +               "       bnei %1, 1b\n"
1652 +               "1:     "
1653 +               : "=&r"(new), "=&r"(tmp)
1654 +               : "r"(x), "r"(v)
1655 +               : "cc", "memory" );
1656 +       return new-v;
1657 +}
1658 --- a/arch/microblaze/pthread_arch.h
1659 +++ b/arch/microblaze/pthread_arch.h
1660 @@ -7,4 +7,4 @@ static inline struct pthread *__pthread_
1661
1662  #define TP_ADJ(p) (p)
1663
1664 -#define CANCEL_REG_IP 32
1665 +#define MC_PC regs.pc
1666 --- a/arch/mips/atomic.h
1667 +++ /dev/null
1668 @@ -1,205 +0,0 @@
1669 -#ifndef _INTERNAL_ATOMIC_H
1670 -#define _INTERNAL_ATOMIC_H
1671 -
1672 -#include <stdint.h>
1673 -
1674 -static inline int a_ctz_l(unsigned long x)
1675 -{
1676 -       static const char debruijn32[32] = {
1677 -               0, 1, 23, 2, 29, 24, 19, 3, 30, 27, 25, 11, 20, 8, 4, 13,
1678 -               31, 22, 28, 18, 26, 10, 7, 12, 21, 17, 9, 6, 16, 5, 15, 14
1679 -       };
1680 -       return debruijn32[(x&-x)*0x076be629 >> 27];
1681 -}
1682 -
1683 -static inline int a_ctz_64(uint64_t x)
1684 -{
1685 -       uint32_t y = x;
1686 -       if (!y) {
1687 -               y = x>>32;
1688 -               return 32 + a_ctz_l(y);
1689 -       }
1690 -       return a_ctz_l(y);
1691 -}
1692 -
1693 -static inline int a_cas(volatile int *p, int t, int s)
1694 -{
1695 -       int dummy;
1696 -       __asm__ __volatile__(
1697 -               ".set push\n"
1698 -               ".set mips2\n"
1699 -               ".set noreorder\n"
1700 -               "       sync\n"
1701 -               "1:     ll %0, %2\n"
1702 -               "       bne %0, %3, 1f\n"
1703 -               "       addu %1, %4, $0\n"
1704 -               "       sc %1, %2\n"
1705 -               "       beq %1, $0, 1b\n"
1706 -               "       nop\n"
1707 -               "       sync\n"
1708 -               "1:     \n"
1709 -               ".set pop\n"
1710 -               : "=&r"(t), "=&r"(dummy), "+m"(*p) : "r"(t), "r"(s) : "memory" );
1711 -        return t;
1712 -}
1713 -
1714 -static inline void *a_cas_p(volatile void *p, void *t, void *s)
1715 -{
1716 -       return (void *)a_cas(p, (int)t, (int)s);
1717 -}
1718 -
1719 -static inline int a_swap(volatile int *x, int v)
1720 -{
1721 -       int old, dummy;
1722 -       __asm__ __volatile__(
1723 -               ".set push\n"
1724 -               ".set mips2\n"
1725 -               ".set noreorder\n"
1726 -               "       sync\n"
1727 -               "1:     ll %0, %2\n"
1728 -               "       addu %1, %3, $0\n"
1729 -               "       sc %1, %2\n"
1730 -               "       beq %1, $0, 1b\n"
1731 -               "       nop\n"
1732 -               "       sync\n"
1733 -               ".set pop\n"
1734 -               : "=&r"(old), "=&r"(dummy), "+m"(*x) : "r"(v) : "memory" );
1735 -        return old;
1736 -}
1737 -
1738 -static inline int a_fetch_add(volatile int *x, int v)
1739 -{
1740 -       int old, dummy;
1741 -       __asm__ __volatile__(
1742 -               ".set push\n"
1743 -               ".set mips2\n"
1744 -               ".set noreorder\n"
1745 -               "       sync\n"
1746 -               "1:     ll %0, %2\n"
1747 -               "       addu %1, %0, %3\n"
1748 -               "       sc %1, %2\n"
1749 -               "       beq %1, $0, 1b\n"
1750 -               "       nop\n"
1751 -               "       sync\n"
1752 -               ".set pop\n"
1753 -               : "=&r"(old), "=&r"(dummy), "+m"(*x) : "r"(v) : "memory" );
1754 -        return old;
1755 -}
1756 -
1757 -static inline void a_inc(volatile int *x)
1758 -{
1759 -       int dummy;
1760 -       __asm__ __volatile__(
1761 -               ".set push\n"
1762 -               ".set mips2\n"
1763 -               ".set noreorder\n"
1764 -               "       sync\n"
1765 -               "1:     ll %0, %1\n"
1766 -               "       addu %0, %0, 1\n"
1767 -               "       sc %0, %1\n"
1768 -               "       beq %0, $0, 1b\n"
1769 -               "       nop\n"
1770 -               "       sync\n"
1771 -               ".set pop\n"
1772 -               : "=&r"(dummy), "+m"(*x) : : "memory" );
1773 -}
1774 -
1775 -static inline void a_dec(volatile int *x)
1776 -{
1777 -       int dummy;
1778 -       __asm__ __volatile__(
1779 -               ".set push\n"
1780 -               ".set mips2\n"
1781 -               ".set noreorder\n"
1782 -               "       sync\n"
1783 -               "1:     ll %0, %1\n"
1784 -               "       subu %0, %0, 1\n"
1785 -               "       sc %0, %1\n"
1786 -               "       beq %0, $0, 1b\n"
1787 -               "       nop\n"
1788 -               "       sync\n"
1789 -               ".set pop\n"
1790 -               : "=&r"(dummy), "+m"(*x) : : "memory" );
1791 -}
1792 -
1793 -static inline void a_store(volatile int *p, int x)
1794 -{
1795 -       __asm__ __volatile__(
1796 -               ".set push\n"
1797 -               ".set mips2\n"
1798 -               ".set noreorder\n"
1799 -               "       sync\n"
1800 -               "       sw %1, %0\n"
1801 -               "       sync\n"
1802 -               ".set pop\n"
1803 -               : "+m"(*p) : "r"(x) : "memory" );
1804 -}
1805 -
1806 -#define a_spin a_barrier
1807 -
1808 -static inline void a_barrier()
1809 -{
1810 -       a_cas(&(int){0}, 0, 0);
1811 -}
1812 -
1813 -static inline void a_crash()
1814 -{
1815 -       *(volatile char *)0=0;
1816 -}
1817 -
1818 -static inline void a_and(volatile int *p, int v)
1819 -{
1820 -       int dummy;
1821 -       __asm__ __volatile__(
1822 -               ".set push\n"
1823 -               ".set mips2\n"
1824 -               ".set noreorder\n"
1825 -               "       sync\n"
1826 -               "1:     ll %0, %1\n"
1827 -               "       and %0, %0, %2\n"
1828 -               "       sc %0, %1\n"
1829 -               "       beq %0, $0, 1b\n"
1830 -               "       nop\n"
1831 -               "       sync\n"
1832 -               ".set pop\n"
1833 -               : "=&r"(dummy), "+m"(*p) : "r"(v) : "memory" );
1834 -}
1835 -
1836 -static inline void a_or(volatile int *p, int v)
1837 -{
1838 -       int dummy;
1839 -       __asm__ __volatile__(
1840 -               ".set push\n"
1841 -               ".set mips2\n"
1842 -               ".set noreorder\n"
1843 -               "       sync\n"
1844 -               "1:     ll %0, %1\n"
1845 -               "       or %0, %0, %2\n"
1846 -               "       sc %0, %1\n"
1847 -               "       beq %0, $0, 1b\n"
1848 -               "       nop\n"
1849 -               "       sync\n"
1850 -               ".set pop\n"
1851 -               : "=&r"(dummy), "+m"(*p) : "r"(v) : "memory" );
1852 -}
1853 -
1854 -static inline void a_or_l(volatile void *p, long v)
1855 -{
1856 -       a_or(p, v);
1857 -}
1858 -
1859 -static inline void a_and_64(volatile uint64_t *p, uint64_t v)
1860 -{
1861 -       union { uint64_t v; uint32_t r[2]; } u = { v };
1862 -       a_and((int *)p, u.r[0]);
1863 -       a_and((int *)p+1, u.r[1]);
1864 -}
1865 -
1866 -static inline void a_or_64(volatile uint64_t *p, uint64_t v)
1867 -{
1868 -       union { uint64_t v; uint32_t r[2]; } u = { v };
1869 -       a_or((int *)p, u.r[0]);
1870 -       a_or((int *)p+1, u.r[1]);
1871 -}
1872 -
1873 -#endif
1874 --- /dev/null
1875 +++ b/arch/mips/atomic_arch.h
1876 @@ -0,0 +1,39 @@
1877 +#define a_ll a_ll
1878 +static inline int a_ll(volatile int *p)
1879 +{
1880 +       int v;
1881 +       __asm__ __volatile__ (
1882 +               ".set push ; .set mips2\n\t"
1883 +               "ll %0, %1"
1884 +               "\n\t.set pop"
1885 +               : "=r"(v) : "m"(*p));
1886 +       return v;
1887 +}
1888 +
1889 +#define a_sc a_sc
1890 +static inline int a_sc(volatile int *p, int v)
1891 +{
1892 +       int r;
1893 +       __asm__ __volatile__ (
1894 +               ".set push ; .set mips2\n\t"
1895 +               "sc %0, %1"
1896 +               "\n\t.set pop"
1897 +               : "=r"(r), "=m"(*p) : "0"(v) : "memory");
1898 +       return r;
1899 +}
1900 +
1901 +#define a_barrier a_barrier
1902 +static inline void a_barrier()
1903 +{
1904 +       /* mips2 sync, but using too many directives causes
1905 +        * gcc not to inline it, so encode with .long instead. */
1906 +       __asm__ __volatile__ (".long 0xf" : : : "memory");
1907 +#if 0
1908 +       __asm__ __volatile__ (
1909 +               ".set push ; .set mips2 ; sync ; .set pop"
1910 +               : : : "memory");
1911 +#endif
1912 +}
1913 +
1914 +#define a_pre_llsc a_barrier
1915 +#define a_post_llsc a_barrier
1916 --- a/arch/mips/crt_arch.h
1917 +++ b/arch/mips/crt_arch.h
1918 @@ -4,13 +4,16 @@ __asm__(
1919  ".text \n"
1920  ".global _" START "\n"
1921  ".global " START "\n"
1922 +".global " START "_data\n"
1923  ".type   _" START ", @function\n"
1924  ".type   " START ", @function\n"
1925 +".type   " START "_data, @function\n"
1926  "_" START ":\n"
1927  "" START ":\n"
1928  "      bal 1f \n"
1929  "       move $fp, $0 \n"
1930 -"2:    .gpword 2b \n"
1931 +"" START "_data: \n"
1932 +"      .gpword " START "_data \n"
1933  "      .gpword " START "_c \n"
1934  ".weak _DYNAMIC \n"
1935  ".hidden _DYNAMIC \n"
1936 --- a/arch/mips/pthread_arch.h
1937 +++ b/arch/mips/pthread_arch.h
1938 @@ -16,4 +16,4 @@ static inline struct pthread *__pthread_
1939
1940  #define DTP_OFFSET 0x8000
1941
1942 -#define CANCEL_REG_IP (3-(union {int __i; char __b;}){1}.__b)
1943 +#define MC_PC pc
1944 --- a/arch/mips/syscall_arch.h
1945 +++ b/arch/mips/syscall_arch.h
1946 @@ -3,9 +3,7 @@
1947  ((union { long long ll; long l[2]; }){ .ll = x }).l[1]
1948  #define __SYSCALL_LL_O(x) 0, __SYSCALL_LL_E((x))
1949
1950 -#ifdef SHARED
1951  __attribute__((visibility("hidden")))
1952 -#endif
1953  long (__syscall)(long, ...);
1954
1955  #define SYSCALL_RLIM_INFINITY (-1UL/2)
1956 --- a/arch/or1k/atomic.h
1957 +++ /dev/null
1958 @@ -1,120 +0,0 @@
1959 -#ifndef _INTERNAL_ATOMIC_H
1960 -#define _INTERNAL_ATOMIC_H
1961 -
1962 -#include <stdint.h>
1963 -
1964 -static inline int a_ctz_l(unsigned long x)
1965 -{
1966 -       static const char debruijn32[32] = {
1967 -               0, 1, 23, 2, 29, 24, 19, 3, 30, 27, 25, 11, 20, 8, 4, 13,
1968 -               31, 22, 28, 18, 26, 10, 7, 12, 21, 17, 9, 6, 16, 5, 15, 14
1969 -       };
1970 -       return debruijn32[(x&-x)*0x076be629 >> 27];
1971 -}
1972 -
1973 -static inline int a_ctz_64(uint64_t x)
1974 -{
1975 -       uint32_t y = x;
1976 -       if (!y) {
1977 -               y = x>>32;
1978 -               return 32 + a_ctz_l(y);
1979 -       }
1980 -       return a_ctz_l(y);
1981 -}
1982 -
1983 -static inline int a_cas(volatile int *p, int t, int s)
1984 -{
1985 -       __asm__("1:     l.lwa %0, %1\n"
1986 -               "       l.sfeq %0, %2\n"
1987 -               "       l.bnf 1f\n"
1988 -               "        l.nop\n"
1989 -               "       l.swa %1, %3\n"
1990 -               "       l.bnf 1b\n"
1991 -               "        l.nop\n"
1992 -               "1:     \n"
1993 -               : "=&r"(t), "+m"(*p) : "r"(t), "r"(s) : "cc", "memory" );
1994 -        return t;
1995 -}
1996 -
1997 -static inline void *a_cas_p(volatile void *p, void *t, void *s)
1998 -{
1999 -       return (void *)a_cas(p, (int)t, (int)s);
2000 -}
2001 -
2002 -static inline int a_swap(volatile int *x, int v)
2003 -{
2004 -       int old;
2005 -       do old = *x;
2006 -       while (a_cas(x, old, v) != old);
2007 -       return old;
2008 -}
2009 -
2010 -static inline int a_fetch_add(volatile int *x, int v)
2011 -{
2012 -       int old;
2013 -       do old = *x;
2014 -       while (a_cas(x, old, old+v) != old);
2015 -       return old;
2016 -}
2017 -
2018 -static inline void a_inc(volatile int *x)
2019 -{
2020 -       a_fetch_add(x, 1);
2021 -}
2022 -
2023 -static inline void a_dec(volatile int *x)
2024 -{
2025 -       a_fetch_add(x, -1);
2026 -}
2027 -
2028 -static inline void a_store(volatile int *p, int x)
2029 -{
2030 -       a_swap(p, x);
2031 -}
2032 -
2033 -#define a_spin a_barrier
2034 -
2035 -static inline void a_barrier()
2036 -{
2037 -       a_cas(&(int){0}, 0, 0);
2038 -}
2039 -
2040 -static inline void a_crash()
2041 -{
2042 -       *(volatile char *)0=0;
2043 -}
2044 -
2045 -static inline void a_and(volatile int *p, int v)
2046 -{
2047 -       int old;
2048 -       do old = *p;
2049 -       while (a_cas(p, old, old&v) != old);
2050 -}
2051 -
2052 -static inline void a_or(volatile int *p, int v)
2053 -{
2054 -       int old;
2055 -       do old = *p;
2056 -       while (a_cas(p, old, old|v) != old);
2057 -}
2058 -
2059 -static inline void a_or_l(volatile void *p, long v)
2060 -{
2061 -       a_or(p, v);
2062 -}
2063 -
2064 -static inline void a_and_64(volatile uint64_t *p, uint64_t v)
2065 -{
2066 -       union { uint64_t v; uint32_t r[2]; } u = { v };
2067 -       a_and((int *)p, u.r[0]);
2068 -       a_and((int *)p+1, u.r[1]);
2069 -}
2070 -
2071 -static inline void a_or_64(volatile uint64_t *p, uint64_t v)
2072 -{
2073 -       union { uint64_t v; uint32_t r[2]; } u = { v };
2074 -       a_or((int *)p, u.r[0]);
2075 -       a_or((int *)p+1, u.r[1]);
2076 -}
2077 -
2078 -#endif
2079 --- /dev/null
2080 +++ b/arch/or1k/atomic_arch.h
2081 @@ -0,0 +1,14 @@
2082 +#define a_cas a_cas
2083 +static inline int a_cas(volatile int *p, int t, int s)
2084 +{
2085 +       __asm__("1:     l.lwa %0, %1\n"
2086 +               "       l.sfeq %0, %2\n"
2087 +               "       l.bnf 1f\n"
2088 +               "        l.nop\n"
2089 +               "       l.swa %1, %3\n"
2090 +               "       l.bnf 1b\n"
2091 +               "        l.nop\n"
2092 +               "1:     \n"
2093 +               : "=&r"(t), "+m"(*p) : "r"(t), "r"(s) : "cc", "memory" );
2094 +        return t;
2095 +}
2096 --- a/arch/or1k/pthread_arch.h
2097 +++ b/arch/or1k/pthread_arch.h
2098 @@ -14,5 +14,4 @@ static inline struct pthread *__pthread_
2099  #define TLS_ABOVE_TP
2100  #define TP_ADJ(p) ((char *)(p) + sizeof(struct pthread))
2101
2102 -/* word-offset to 'pc' in mcontext_t */
2103 -#define CANCEL_REG_IP 32
2104 +#define MC_PC regs.pc
2105 --- a/arch/powerpc/atomic.h
2106 +++ /dev/null
2107 @@ -1,126 +0,0 @@
2108 -#ifndef _INTERNAL_ATOMIC_H
2109 -#define _INTERNAL_ATOMIC_H
2110 -
2111 -#include <stdint.h>
2112 -#include <endian.h>
2113 -
2114 -static inline int a_ctz_l(unsigned long x)
2115 -{
2116 -       static const char debruijn32[32] = {
2117 -               0, 1, 23, 2, 29, 24, 19, 3, 30, 27, 25, 11, 20, 8, 4, 13,
2118 -               31, 22, 28, 18, 26, 10, 7, 12, 21, 17, 9, 6, 16, 5, 15, 14
2119 -       };
2120 -       return debruijn32[(x&-x)*0x076be629 >> 27];
2121 -}
2122 -
2123 -static inline int a_ctz_64(uint64_t x)
2124 -{
2125 -       uint32_t y = x;
2126 -       if (!y) {
2127 -               y = x>>32;
2128 -               return 32 + a_ctz_l(y);
2129 -       }
2130 -       return a_ctz_l(y);
2131 -}
2132 -
2133 -static inline int a_cas(volatile int *p, int t, int s)
2134 -{
2135 -       __asm__("\n"
2136 -               "       sync\n"
2137 -               "1:     lwarx %0, 0, %4\n"
2138 -               "       cmpw %0, %2\n"
2139 -               "       bne 1f\n"
2140 -               "       stwcx. %3, 0, %4\n"
2141 -               "       bne- 1b\n"
2142 -               "       isync\n"
2143 -               "1:     \n"
2144 -               : "=&r"(t), "+m"(*p) : "r"(t), "r"(s), "r"(p) : "cc", "memory" );
2145 -        return t;
2146 -}
2147 -
2148 -static inline void *a_cas_p(volatile void *p, void *t, void *s)
2149 -{
2150 -       return (void *)a_cas(p, (int)t, (int)s);
2151 -}
2152 -
2153 -static inline int a_swap(volatile int *x, int v)
2154 -{
2155 -       int old;
2156 -       do old = *x;
2157 -       while (a_cas(x, old, v) != old);
2158 -       return old;
2159 -}
2160 -
2161 -static inline int a_fetch_add(volatile int *x, int v)
2162 -{
2163 -       int old;
2164 -       do old = *x;
2165 -       while (a_cas(x, old, old+v) != old);
2166 -       return old;
2167 -}
2168 -
2169 -static inline void a_inc(volatile int *x)
2170 -{
2171 -       a_fetch_add(x, 1);
2172 -}
2173 -
2174 -static inline void a_dec(volatile int *x)
2175 -{
2176 -       a_fetch_add(x, -1);
2177 -}
2178 -
2179 -static inline void a_store(volatile int *p, int x)
2180 -{
2181 -       __asm__ __volatile__ ("\n"
2182 -               "       sync\n"
2183 -               "       stw %1, %0\n"
2184 -               "       isync\n"
2185 -               : "=m"(*p) : "r"(x) : "memory" );
2186 -}
2187 -
2188 -#define a_spin a_barrier
2189 -
2190 -static inline void a_barrier()
2191 -{
2192 -       a_cas(&(int){0}, 0, 0);
2193 -}
2194 -
2195 -static inline void a_crash()
2196 -{
2197 -       *(volatile char *)0=0;
2198 -}
2199 -
2200 -static inline void a_and(volatile int *p, int v)
2201 -{
2202 -       int old;
2203 -       do old = *p;
2204 -       while (a_cas(p, old, old&v) != old);
2205 -}
2206 -
2207 -static inline void a_or(volatile int *p, int v)
2208 -{
2209 -       int old;
2210 -       do old = *p;
2211 -       while (a_cas(p, old, old|v) != old);
2212 -}
2213 -
2214 -static inline void a_or_l(volatile void *p, long v)
2215 -{
2216 -       a_or(p, v);
2217 -}
2218 -
2219 -static inline void a_and_64(volatile uint64_t *p, uint64_t v)
2220 -{
2221 -       union { uint64_t v; uint32_t r[2]; } u = { v };
2222 -       a_and((int *)p, u.r[0]);
2223 -       a_and((int *)p+1, u.r[1]);
2224 -}
2225 -
2226 -static inline void a_or_64(volatile uint64_t *p, uint64_t v)
2227 -{
2228 -       union { uint64_t v; uint32_t r[2]; } u = { v };
2229 -       a_or((int *)p, u.r[0]);
2230 -       a_or((int *)p+1, u.r[1]);
2231 -}
2232 -
2233 -#endif
2234 --- /dev/null
2235 +++ b/arch/powerpc/atomic_arch.h
2236 @@ -0,0 +1,15 @@
2237 +#define a_cas a_cas
2238 +static inline int a_cas(volatile int *p, int t, int s)
2239 +{
2240 +       __asm__("\n"
2241 +               "       sync\n"
2242 +               "1:     lwarx %0, 0, %4\n"
2243 +               "       cmpw %0, %2\n"
2244 +               "       bne 1f\n"
2245 +               "       stwcx. %3, 0, %4\n"
2246 +               "       bne- 1b\n"
2247 +               "       isync\n"
2248 +               "1:     \n"
2249 +               : "=&r"(t), "+m"(*p) : "r"(t), "r"(s), "r"(p) : "cc", "memory" );
2250 +        return t;
2251 +}
2252 --- a/arch/powerpc/pthread_arch.h
2253 +++ b/arch/powerpc/pthread_arch.h
2254 @@ -15,9 +15,8 @@ static inline struct pthread *__pthread_
2255
2256  #define DTP_OFFSET 0x8000
2257
2258 -// offset of the PC register in mcontext_t, divided by the system wordsize
2259  // the kernel calls the ip "nip", it's the first saved value after the 32
2260  // GPRs.
2261 -#define CANCEL_REG_IP 32
2262 +#define MC_PC gregs[32]
2263
2264  #define CANARY canary_at_end
2265 --- a/arch/sh/atomic.h
2266 +++ /dev/null
2267 @@ -1,168 +0,0 @@
2268 -#ifndef _INTERNAL_ATOMIC_H
2269 -#define _INTERNAL_ATOMIC_H
2270 -
2271 -#include <stdint.h>
2272 -
2273 -static inline int a_ctz_l(unsigned long x)
2274 -{
2275 -       static const char debruijn32[32] = {
2276 -               0, 1, 23, 2, 29, 24, 19, 3, 30, 27, 25, 11, 20, 8, 4, 13,
2277 -               31, 22, 28, 18, 26, 10, 7, 12, 21, 17, 9, 6, 16, 5, 15, 14
2278 -       };
2279 -       return debruijn32[(x&-x)*0x076be629 >> 27];
2280 -}
2281 -
2282 -static inline int a_ctz_64(uint64_t x)
2283 -{
2284 -       uint32_t y = x;
2285 -       if (!y) {
2286 -               y = x>>32;
2287 -               return 32 + a_ctz_l(y);
2288 -       }
2289 -       return a_ctz_l(y);
2290 -}
2291 -
2292 -#define LLSC_CLOBBERS "r0", "t", "memory"
2293 -#define LLSC_START(mem) "synco\n"  \
2294 -       "0:     movli.l @" mem ", r0\n"
2295 -#define LLSC_END(mem)              \
2296 -       "1:     movco.l r0, @" mem "\n"    \
2297 -       "       bf 0b\n"                   \
2298 -       "       synco\n"
2299 -
2300 -static inline int __sh_cas_llsc(volatile int *p, int t, int s)
2301 -{
2302 -       int old;
2303 -       __asm__ __volatile__(
2304 -               LLSC_START("%1")
2305 -               "       mov r0, %0\n"
2306 -               "       cmp/eq %0, %2\n"
2307 -               "       bf 1f\n"
2308 -               "       mov %3, r0\n"
2309 -               LLSC_END("%1")
2310 -               : "=&r"(old) : "r"(p), "r"(t), "r"(s) : LLSC_CLOBBERS);
2311 -       return old;
2312 -}
2313 -
2314 -static inline int __sh_swap_llsc(volatile int *x, int v)
2315 -{
2316 -       int old;
2317 -       __asm__ __volatile__(
2318 -               LLSC_START("%1")
2319 -               "       mov r0, %0\n"
2320 -               "       mov %2, r0\n"
2321 -               LLSC_END("%1")
2322 -               : "=&r"(old) : "r"(x), "r"(v) : LLSC_CLOBBERS);
2323 -       return old;
2324 -}
2325 -
2326 -static inline int __sh_fetch_add_llsc(volatile int *x, int v)
2327 -{
2328 -       int old;
2329 -       __asm__ __volatile__(
2330 -               LLSC_START("%1")
2331 -               "       mov r0, %0\n"
2332 -               "       add %2, r0\n"
2333 -               LLSC_END("%1")
2334 -               : "=&r"(old) : "r"(x), "r"(v) : LLSC_CLOBBERS);
2335 -       return old;
2336 -}
2337 -
2338 -static inline void __sh_store_llsc(volatile int *p, int x)
2339 -{
2340 -       __asm__ __volatile__(
2341 -               "       synco\n"
2342 -               "       mov.l %1, @%0\n"
2343 -               "       synco\n"
2344 -               : : "r"(p), "r"(x) : "memory");
2345 -}
2346 -
2347 -static inline void __sh_and_llsc(volatile int *x, int v)
2348 -{
2349 -       __asm__ __volatile__(
2350 -               LLSC_START("%0")
2351 -               "       and %1, r0\n"
2352 -               LLSC_END("%0")
2353 -               : : "r"(x), "r"(v) : LLSC_CLOBBERS);
2354 -}
2355 -
2356 -static inline void __sh_or_llsc(volatile int *x, int v)
2357 -{
2358 -       __asm__ __volatile__(
2359 -               LLSC_START("%0")
2360 -               "       or %1, r0\n"
2361 -               LLSC_END("%0")
2362 -               : : "r"(x), "r"(v) : LLSC_CLOBBERS);
2363 -}
2364 -
2365 -#ifdef __SH4A__
2366 -#define a_cas(p,t,s)     __sh_cas_llsc(p,t,s)
2367 -#define a_swap(x,v)      __sh_swap_llsc(x,v)
2368 -#define a_fetch_add(x,v) __sh_fetch_add_llsc(x, v)
2369 -#define a_store(x,v)     __sh_store_llsc(x, v)
2370 -#define a_and(x,v)       __sh_and_llsc(x, v)
2371 -#define a_or(x,v)        __sh_or_llsc(x, v)
2372 -#else
2373 -
2374 -int  __sh_cas(volatile int *, int, int);
2375 -int  __sh_swap(volatile int *, int);
2376 -int  __sh_fetch_add(volatile int *, int);
2377 -void __sh_store(volatile int *, int);
2378 -void __sh_and(volatile int *, int);
2379 -void __sh_or(volatile int *, int);
2380 -
2381 -#define a_cas(p,t,s)     __sh_cas(p,t,s)
2382 -#define a_swap(x,v)      __sh_swap(x,v)
2383 -#define a_fetch_add(x,v) __sh_fetch_add(x, v)
2384 -#define a_store(x,v)     __sh_store(x, v)
2385 -#define a_and(x,v)       __sh_and(x, v)
2386 -#define a_or(x,v)        __sh_or(x, v)
2387 -#endif
2388 -
2389 -static inline void *a_cas_p(volatile void *p, void *t, void *s)
2390 -{
2391 -       return (void *)a_cas(p, (int)t, (int)s);
2392 -}
2393 -
2394 -static inline void a_inc(volatile int *x)
2395 -{
2396 -       a_fetch_add(x, 1);
2397 -}
2398 -
2399 -static inline void a_dec(volatile int *x)
2400 -{
2401 -       a_fetch_add(x, -1);
2402 -}
2403 -
2404 -#define a_spin a_barrier
2405 -
2406 -static inline void a_barrier()
2407 -{
2408 -       a_cas(&(int){0}, 0, 0);
2409 -}
2410 -
2411 -static inline void a_crash()
2412 -{
2413 -       *(volatile char *)0=0;
2414 -}
2415 -
2416 -static inline void a_or_l(volatile void *p, long v)
2417 -{
2418 -       a_or(p, v);
2419 -}
2420 -
2421 -static inline void a_and_64(volatile uint64_t *p, uint64_t v)
2422 -{
2423 -       union { uint64_t v; uint32_t r[2]; } u = { v };
2424 -       a_and((int *)p,   u.r[0]);
2425 -       a_and((int *)p+1, u.r[1]);
2426 -}
2427 -
2428 -static inline void a_or_64(volatile uint64_t *p, uint64_t v)
2429 -{
2430 -       union { uint64_t v; uint32_t r[2]; } u = { v };
2431 -       a_or((int *)p,   u.r[0]);
2432 -       a_or((int *)p+1, u.r[1]);
2433 -}
2434 -
2435 -#endif
2436 --- /dev/null
2437 +++ b/arch/sh/atomic_arch.h
2438 @@ -0,0 +1,46 @@
2439 +#if defined(__SH4A__)
2440 +
2441 +#define a_ll a_ll
2442 +static inline int a_ll(volatile int *p)
2443 +{
2444 +       int v;
2445 +       __asm__ __volatile__ ("movli.l @%1, %0" : "=z"(v) : "r"(p), "m"(*p));
2446 +       return v;
2447 +}
2448 +
2449 +#define a_sc a_sc
2450 +static inline int a_sc(volatile int *p, int v)
2451 +{
2452 +       int r;
2453 +       __asm__ __volatile__ (
2454 +               "movco.l %2, @%3 ; movt %0"
2455 +               : "=r"(r), "=m"(*p) : "z"(v), "r"(p) : "memory", "cc");
2456 +       return r;
2457 +}
2458 +
2459 +#define a_barrier a_barrier
2460 +static inline void a_barrier()
2461 +{
2462 +       __asm__ __volatile__ ("synco" : : "memory");
2463 +}
2464 +
2465 +#define a_pre_llsc a_barrier
2466 +#define a_post_llsc a_barrier
2467 +
2468 +#else
2469 +
2470 +#define a_cas a_cas
2471 +__attribute__((__visibility__("hidden"))) extern const void *__sh_cas_ptr;
2472 +static inline int a_cas(volatile int *p, int t, int s)
2473 +{
2474 +       register int r1 __asm__("r1");
2475 +       register int r2 __asm__("r2") = t;
2476 +       register int r3 __asm__("r3") = s;
2477 +       __asm__ __volatile__ (
2478 +               "jsr @%4 ; nop"
2479 +               : "=r"(r1), "+r"(r3) : "z"(p), "r"(r2), "r"(__sh_cas_ptr)
2480 +               : "memory", "pr", "cc");
2481 +       return r3;
2482 +}
2483 +
2484 +#endif
2485 --- a/arch/sh/crt_arch.h
2486 +++ b/arch/sh/crt_arch.h
2487 @@ -22,7 +22,8 @@ START ": \n"
2488  "      mov.l 1f, r5 \n"
2489  "      mov.l 1f+4, r6 \n"
2490  "      add r0, r5 \n"
2491 -"      bsr __fdpic_fixup \n"
2492 +"      mov.l 4f, r1 \n"
2493 +"5:    bsrf r1 \n"
2494  "       add r0, r6 \n"
2495  "      mov r0, r12 \n"
2496  #endif
2497 @@ -31,11 +32,16 @@ START ": \n"
2498  "      mov.l r9, @-r15 \n"
2499  "      mov.l r8, @-r15 \n"
2500  "      mov #-16, r0 \n"
2501 -"      bsr " START "_c \n"
2502 +"      mov.l 2f, r1 \n"
2503 +"3:    bsrf r1 \n"
2504  "       and r0, r15 \n"
2505  ".align 2 \n"
2506  "1:    .long __ROFIXUP_LIST__@PCREL \n"
2507  "      .long __ROFIXUP_END__@PCREL + 4 \n"
2508 +"2:    .long " START "_c@PCREL - (3b+4-.) \n"
2509 +#ifndef SHARED
2510 +"4:    .long __fdpic_fixup@PCREL - (5b+4-.) \n"
2511 +#endif
2512  );
2513
2514  #ifndef SHARED
2515 @@ -53,13 +59,14 @@ START ": \n"
2516  "      add r0, r5 \n"
2517  "      mov r15, r4 \n"
2518  "      mov #-16, r0 \n"
2519 -"      and r0, r15 \n"
2520 -"      bsr " START "_c \n"
2521 -"      nop \n"
2522 +"      mov.l 2f, r1 \n"
2523 +"3:    bsrf r1 \n"
2524 +"       and r0, r15 \n"
2525  ".align 2 \n"
2526  ".weak _DYNAMIC \n"
2527  ".hidden _DYNAMIC \n"
2528  "1:    .long _DYNAMIC-. \n"
2529 +"2:    .long " START "_c@PCREL - (3b+4-.) \n"
2530  );
2531
2532  #endif
2533 --- a/arch/sh/pthread_arch.h
2534 +++ b/arch/sh/pthread_arch.h
2535 @@ -8,4 +8,4 @@ static inline struct pthread *__pthread_
2536  #define TLS_ABOVE_TP
2537  #define TP_ADJ(p) ((char *)(p) + sizeof(struct pthread) - 8)
2538
2539 -#define CANCEL_REG_IP 17
2540 +#define MC_PC sc_pc
2541 --- a/arch/sh/reloc.h
2542 +++ b/arch/sh/reloc.h
2543 @@ -32,6 +32,8 @@
2544  #define REL_DTPOFF      R_SH_TLS_DTPOFF32
2545  #define REL_TPOFF       R_SH_TLS_TPOFF32
2546
2547 +#define DL_NOMMU_SUPPORT 1
2548 +
2549  #if __SH_FDPIC__
2550  #define REL_FUNCDESC    R_SH_FUNCDESC
2551  #define REL_FUNCDESC_VAL R_SH_FUNCDESC_VALUE
2552 --- a/arch/sh/src/__set_thread_area.c
2553 +++ /dev/null
2554 @@ -1,34 +0,0 @@
2555 -#include "pthread_impl.h"
2556 -#include "libc.h"
2557 -#include "sh_atomic.h"
2558 -#include <elf.h>
2559 -
2560 -/* Also perform sh-specific init */
2561 -
2562 -#define CPU_HAS_LLSC 0x0040
2563 -
2564 -__attribute__((__visibility__("hidden"))) unsigned __sh_atomic_model, __sh_nommu;
2565 -
2566 -int __set_thread_area(void *p)
2567 -{
2568 -       size_t *aux;
2569 -       __asm__ __volatile__ ( "ldc %0, gbr" : : "r"(p) : "memory" );
2570 -#ifndef __SH4A__
2571 -       if (__hwcap & CPU_HAS_LLSC) {
2572 -               __sh_atomic_model = SH_A_LLSC;
2573 -               return 0;
2574 -       }
2575 -#if !defined(__SH3__) && !defined(__SH4__)
2576 -       for (aux=libc.auxv; *aux; aux+=2) {
2577 -               if (*aux != AT_PLATFORM) continue;
2578 -               const char *s = (void *)aux[1];
2579 -               if (s[0]!='s' || s[1]!='h' || s[2]!='2' || s[3]-'0'<10u) break;
2580 -               __sh_atomic_model = SH_A_IMASK;
2581 -               __sh_nommu = 1;
2582 -               return 0;
2583 -       }
2584 -#endif
2585 -       /* __sh_atomic_model = SH_A_GUSA; */ /* 0, default */
2586 -#endif
2587 -       return 0;
2588 -}
2589 --- a/arch/sh/src/atomic.c
2590 +++ /dev/null
2591 @@ -1,158 +0,0 @@
2592 -#ifndef __SH4A__
2593 -
2594 -#include "sh_atomic.h"
2595 -#include "atomic.h"
2596 -#include "libc.h"
2597 -
2598 -static inline unsigned mask()
2599 -{
2600 -       unsigned sr;
2601 -       __asm__ __volatile__ ( "\n"
2602 -       "       stc sr,r0 \n"
2603 -       "       mov r0,%0 \n"
2604 -       "       or #0xf0,r0 \n"
2605 -       "       ldc r0,sr \n"
2606 -       : "=&r"(sr) : : "memory", "r0" );
2607 -       return sr;
2608 -}
2609 -
2610 -static inline void unmask(unsigned sr)
2611 -{
2612 -       __asm__ __volatile__ ( "ldc %0,sr" : : "r"(sr) : "memory" );
2613 -}
2614 -
2615 -/* gusa is a hack in the kernel which lets you create a sequence of instructions
2616 - * which will be restarted if the process is preempted in the middle of the
2617 - * sequence. It will do for implementing atomics on non-smp systems. ABI is:
2618 - * r0  = address of first instruction after the atomic sequence
2619 - * r1  = original stack pointer
2620 - * r15 = -1 * length of atomic sequence in bytes
2621 - */
2622 -#define GUSA_CLOBBERS   "r0", "r1", "memory"
2623 -#define GUSA_START(mem,old,nop)    \
2624 -       "       .align 2\n"                \
2625 -       "       mova 1f, r0\n"             \
2626 -       nop                            \
2627 -       "       mov r15, r1\n"             \
2628 -       "       mov #(0f-1f), r15\n"       \
2629 -       "0:     mov.l @" mem ", " old "\n"
2630 -/* the target of mova must be 4 byte aligned, so we may need a nop */
2631 -#define GUSA_START_ODD(mem,old)  GUSA_START(mem,old,"")
2632 -#define GUSA_START_EVEN(mem,old) GUSA_START(mem,old,"\tnop\n")
2633 -#define GUSA_END(mem,new)          \
2634 -       "       mov.l " new ", @" mem "\n" \
2635 -       "1:     mov r1, r15\n"
2636 -
2637 -int __sh_cas(volatile int *p, int t, int s)
2638 -{
2639 -       if (__sh_atomic_model == SH_A_LLSC) return __sh_cas_llsc(p, t, s);
2640 -
2641 -       if (__sh_atomic_model == SH_A_IMASK) {
2642 -               unsigned sr = mask();
2643 -               int old = *p;
2644 -               if (old==t) *p = s;
2645 -               unmask(sr);
2646 -               return old;
2647 -       }
2648 -
2649 -       int old;
2650 -       __asm__ __volatile__(
2651 -               GUSA_START_EVEN("%1", "%0")
2652 -               "       cmp/eq %0, %2\n"
2653 -               "       bf 1f\n"
2654 -               GUSA_END("%1", "%3")
2655 -               : "=&r"(old) : "r"(p), "r"(t), "r"(s) : GUSA_CLOBBERS, "t");
2656 -       return old;
2657 -}
2658 -
2659 -int __sh_swap(volatile int *x, int v)
2660 -{
2661 -       if (__sh_atomic_model == SH_A_LLSC) return __sh_swap_llsc(x, v);
2662 -
2663 -       if (__sh_atomic_model == SH_A_IMASK) {
2664 -               unsigned sr = mask();
2665 -               int old = *x;
2666 -               *x = v;
2667 -               unmask(sr);
2668 -               return old;
2669 -       }
2670 -
2671 -       int old;
2672 -       __asm__ __volatile__(
2673 -               GUSA_START_EVEN("%1", "%0")
2674 -               GUSA_END("%1", "%2")
2675 -               : "=&r"(old) : "r"(x), "r"(v) : GUSA_CLOBBERS);
2676 -       return old;
2677 -}
2678 -
2679 -int __sh_fetch_add(volatile int *x, int v)
2680 -{
2681 -       if (__sh_atomic_model == SH_A_LLSC) return __sh_fetch_add_llsc(x, v);
2682 -
2683 -       if (__sh_atomic_model == SH_A_IMASK) {
2684 -               unsigned sr = mask();
2685 -               int old = *x;
2686 -               *x = old + v;
2687 -               unmask(sr);
2688 -               return old;
2689 -       }
2690 -
2691 -       int old, dummy;
2692 -       __asm__ __volatile__(
2693 -               GUSA_START_EVEN("%2", "%0")
2694 -               "       mov %0, %1\n"
2695 -               "       add %3, %1\n"
2696 -               GUSA_END("%2", "%1")
2697 -               : "=&r"(old), "=&r"(dummy) : "r"(x), "r"(v) : GUSA_CLOBBERS);
2698 -       return old;
2699 -}
2700 -
2701 -void __sh_store(volatile int *p, int x)
2702 -{
2703 -       if (__sh_atomic_model == SH_A_LLSC) return __sh_store_llsc(p, x);
2704 -       __asm__ __volatile__(
2705 -               "       mov.l %1, @%0\n"
2706 -               : : "r"(p), "r"(x) : "memory");
2707 -}
2708 -
2709 -void __sh_and(volatile int *x, int v)
2710 -{
2711 -       if (__sh_atomic_model == SH_A_LLSC) return __sh_and_llsc(x, v);
2712 -
2713 -       if (__sh_atomic_model == SH_A_IMASK) {
2714 -               unsigned sr = mask();
2715 -               int old = *x;
2716 -               *x = old & v;
2717 -               unmask(sr);
2718 -               return;
2719 -       }
2720 -
2721 -       int dummy;
2722 -       __asm__ __volatile__(
2723 -               GUSA_START_ODD("%1", "%0")
2724 -               "       and %2, %0\n"
2725 -               GUSA_END("%1", "%0")
2726 -               : "=&r"(dummy) : "r"(x), "r"(v) : GUSA_CLOBBERS);
2727 -}
2728 -
2729 -void __sh_or(volatile int *x, int v)
2730 -{
2731 -       if (__sh_atomic_model == SH_A_LLSC) return __sh_or_llsc(x, v);
2732 -
2733 -       if (__sh_atomic_model == SH_A_IMASK) {
2734 -               unsigned sr = mask();
2735 -               int old = *x;
2736 -               *x = old | v;
2737 -               unmask(sr);
2738 -               return;
2739 -       }
2740 -
2741 -       int dummy;
2742 -       __asm__ __volatile__(
2743 -               GUSA_START_ODD("%1", "%0")
2744 -               "       or %2, %0\n"
2745 -               GUSA_END("%1", "%0")
2746 -               : "=&r"(dummy) : "r"(x), "r"(v) : GUSA_CLOBBERS);
2747 -}
2748 -
2749 -#endif
2750 --- a/arch/sh/src/sh_atomic.h
2751 +++ /dev/null
2752 @@ -1,15 +0,0 @@
2753 -#ifndef _SH_ATOMIC_H
2754 -#define _SH_ATOMIC_H
2755 -
2756 -#define SH_A_GUSA 0
2757 -#define SH_A_LLSC 1
2758 -#define SH_A_CAS 2
2759 -#if !defined(__SH3__) && !defined(__SH4__)
2760 -#define SH_A_IMASK 3
2761 -#else
2762 -#define SH_A_IMASK -1LL /* unmatchable by unsigned int */
2763 -#endif
2764 -
2765 -extern __attribute__((__visibility__("hidden"))) unsigned __sh_atomic_model;
2766 -
2767 -#endif
2768 --- a/arch/x32/atomic.h
2769 +++ /dev/null
2770 @@ -1,105 +0,0 @@
2771 -#ifndef _INTERNAL_ATOMIC_H
2772 -#define _INTERNAL_ATOMIC_H
2773 -
2774 -#include <stdint.h>
2775 -
2776 -static inline int a_ctz_64(uint64_t x)
2777 -{
2778 -       __asm__( "bsf %1,%0" : "=r"(x) : "r"(x) );
2779 -       return x;
2780 -}
2781 -
2782 -static inline int a_ctz_l(unsigned long x)
2783 -{
2784 -       __asm__( "bsf %1,%0" : "=r"(x) : "r"(x) );
2785 -       return x;
2786 -}
2787 -
2788 -static inline void a_and_64(volatile uint64_t *p, uint64_t v)
2789 -{
2790 -       __asm__( "lock ; and %1, %0"
2791 -                        : "=m"(*p) : "r"(v) : "memory" );
2792 -}
2793 -
2794 -static inline void a_or_64(volatile uint64_t *p, uint64_t v)
2795 -{
2796 -       __asm__( "lock ; or %1, %0"
2797 -                        : "=m"(*p) : "r"(v) : "memory" );
2798 -}
2799 -
2800 -static inline void a_or_l(volatile void *p, long v)
2801 -{
2802 -       __asm__( "lock ; or %1, %0"
2803 -               : "=m"(*(long *)p) : "r"(v) : "memory" );
2804 -}
2805 -
2806 -static inline void *a_cas_p(volatile void *p, void *t, void *s)
2807 -{
2808 -       __asm__( "lock ; cmpxchg %3, %1"
2809 -               : "=a"(t), "=m"(*(long *)p) : "a"(t), "r"(s) : "memory" );
2810 -       return t;
2811 -}
2812 -
2813 -static inline int a_cas(volatile int *p, int t, int s)
2814 -{
2815 -       __asm__( "lock ; cmpxchg %3, %1"
2816 -               : "=a"(t), "=m"(*p) : "a"(t), "r"(s) : "memory" );
2817 -       return t;
2818 -}
2819 -
2820 -static inline void a_or(volatile int *p, int v)
2821 -{
2822 -       __asm__( "lock ; or %1, %0"
2823 -               : "=m"(*p) : "r"(v) : "memory" );
2824 -}
2825 -
2826 -static inline void a_and(volatile int *p, int v)
2827 -{
2828 -       __asm__( "lock ; and %1, %0"
2829 -               : "=m"(*p) : "r"(v) : "memory" );
2830 -}
2831 -
2832 -static inline int a_swap(volatile int *x, int v)
2833 -{
2834 -       __asm__( "xchg %0, %1" : "=r"(v), "=m"(*x) : "0"(v) : "memory" );
2835 -       return v;
2836 -}
2837 -
2838 -static inline int a_fetch_add(volatile int *x, int v)
2839 -{
2840 -       __asm__( "lock ; xadd %0, %1" : "=r"(v), "=m"(*x) : "0"(v) : "memory" );
2841 -       return v;
2842 -}
2843 -
2844 -static inline void a_inc(volatile int *x)
2845 -{
2846 -       __asm__( "lock ; incl %0" : "=m"(*x) : "m"(*x) : "memory" );
2847 -}
2848 -
2849 -static inline void a_dec(volatile int *x)
2850 -{
2851 -       __asm__( "lock ; decl %0" : "=m"(*x) : "m"(*x) : "memory" );
2852 -}
2853 -
2854 -static inline void a_store(volatile int *p, int x)
2855 -{
2856 -       __asm__( "mov %1, %0 ; lock ; orl $0,(%%rsp)" : "=m"(*p) : "r"(x) : "memory" );
2857 -}
2858 -
2859 -static inline void a_spin()
2860 -{
2861 -       __asm__ __volatile__( "pause" : : : "memory" );
2862 -}
2863 -
2864 -static inline void a_barrier()
2865 -{
2866 -       __asm__ __volatile__( "" : : : "memory" );
2867 -}
2868 -
2869 -static inline void a_crash()
2870 -{
2871 -       __asm__ __volatile__( "hlt" : : : "memory" );
2872 -}
2873 -
2874 -
2875 -#endif
2876 --- /dev/null
2877 +++ b/arch/x32/atomic_arch.h
2878 @@ -0,0 +1,106 @@
2879 +#define a_ctz_64 a_ctz_64
2880 +static inline int a_ctz_64(uint64_t x)
2881 +{
2882 +       __asm__( "bsf %1,%0" : "=r"(x) : "r"(x) );
2883 +       return x;
2884 +}
2885 +
2886 +#define a_ctz_l a_ctz_l
2887 +static inline int a_ctz_l(unsigned long x)
2888 +{
2889 +       __asm__( "bsf %1,%0" : "=r"(x) : "r"(x) );
2890 +       return x;
2891 +}
2892 +
2893 +#define a_and_64 a_and_64
2894 +static inline void a_and_64(volatile uint64_t *p, uint64_t v)
2895 +{
2896 +       __asm__( "lock ; and %1, %0"
2897 +                        : "=m"(*p) : "r"(v) : "memory" );
2898 +}
2899 +
2900 +#define a_or_64 a_or_64
2901 +static inline void a_or_64(volatile uint64_t *p, uint64_t v)
2902 +{
2903 +       __asm__( "lock ; or %1, %0"
2904 +                        : "=m"(*p) : "r"(v) : "memory" );
2905 +}
2906 +
2907 +#define a_or_l a_or_l
2908 +static inline void a_or_l(volatile void *p, long v)
2909 +{
2910 +       __asm__( "lock ; or %1, %0"
2911 +               : "=m"(*(long *)p) : "r"(v) : "memory" );
2912 +}
2913 +
2914 +#define a_cas a_cas
2915 +static inline int a_cas(volatile int *p, int t, int s)
2916 +{
2917 +       __asm__( "lock ; cmpxchg %3, %1"
2918 +               : "=a"(t), "=m"(*p) : "a"(t), "r"(s) : "memory" );
2919 +       return t;
2920 +}
2921 +
2922 +#define a_or a_or
2923 +static inline void a_or(volatile int *p, int v)
2924 +{
2925 +       __asm__( "lock ; or %1, %0"
2926 +               : "=m"(*p) : "r"(v) : "memory" );
2927 +}
2928 +
2929 +#define a_and a_and
2930 +static inline void a_and(volatile int *p, int v)
2931 +{
2932 +       __asm__( "lock ; and %1, %0"
2933 +               : "=m"(*p) : "r"(v) : "memory" );
2934 +}
2935 +
2936 +#define a_swap a_swap
2937 +static inline int a_swap(volatile int *x, int v)
2938 +{
2939 +       __asm__( "xchg %0, %1" : "=r"(v), "=m"(*x) : "0"(v) : "memory" );
2940 +       return v;
2941 +}
2942 +
2943 +#define a_fetch_add a_fetch_add
2944 +static inline int a_fetch_add(volatile int *x, int v)
2945 +{
2946 +       __asm__( "lock ; xadd %0, %1" : "=r"(v), "=m"(*x) : "0"(v) : "memory" );
2947 +       return v;
2948 +}
2949 +
2950 +#define a_inc a_inc
2951 +static inline void a_inc(volatile int *x)
2952 +{
2953 +       __asm__( "lock ; incl %0" : "=m"(*x) : "m"(*x) : "memory" );
2954 +}
2955 +
2956 +#define a_dec a_dec
2957 +static inline void a_dec(volatile int *x)
2958 +{
2959 +       __asm__( "lock ; decl %0" : "=m"(*x) : "m"(*x) : "memory" );
2960 +}
2961 +
2962 +#define a_store a_store
2963 +static inline void a_store(volatile int *p, int x)
2964 +{
2965 +       __asm__( "mov %1, %0 ; lock ; orl $0,(%%rsp)" : "=m"(*p) : "r"(x) : "memory" );
2966 +}
2967 +
2968 +#define a_spin a_spin
2969 +static inline void a_spin()
2970 +{
2971 +       __asm__ __volatile__( "pause" : : : "memory" );
2972 +}
2973 +
2974 +#define a_barrier a_barrier
2975 +static inline void a_barrier()
2976 +{
2977 +       __asm__ __volatile__( "" : : : "memory" );
2978 +}
2979 +
2980 +#define a_crash a_crash
2981 +static inline void a_crash()
2982 +{
2983 +       __asm__ __volatile__( "hlt" : : : "memory" );
2984 +}
2985 --- a/arch/x32/pthread_arch.h
2986 +++ b/arch/x32/pthread_arch.h
2987 @@ -7,6 +7,6 @@ static inline struct pthread *__pthread_
2988
2989  #define TP_ADJ(p) (p)
2990
2991 -#define CANCEL_REG_IP 32
2992 +#define MC_PC gregs[REG_RIP]
2993
2994  #define CANARY canary2
2995 --- a/arch/x32/src/syscall_cp_fixup.c
2996 +++ b/arch/x32/src/syscall_cp_fixup.c
2997 @@ -1,8 +1,6 @@
2998  #include <sys/syscall.h>
2999
3000 -#ifdef SHARED
3001  __attribute__((__visibility__("hidden")))
3002 -#endif
3003  long __syscall_cp_internal(volatile void*, long long, long long, long long, long long,
3004                               long long, long long, long long);
3005
3006 @@ -14,9 +12,7 @@ struct __timespec_kernel { long long tv_
3007         ts->tv_nsec = __tsc(X)->tv_nsec; \
3008         (X) = (unsigned long)ts; } } while(0)
3009
3010 -#ifdef SHARED
3011  __attribute__((__visibility__("hidden")))
3012 -#endif
3013  long __syscall_cp_asm (volatile void * foo, long long n, long long a1, long long a2, long long a3,
3014                              long long a4, long long a5, long long a6)
3015  {
3016 --- a/arch/x86_64/atomic.h
3017 +++ /dev/null
3018 @@ -1,105 +0,0 @@
3019 -#ifndef _INTERNAL_ATOMIC_H
3020 -#define _INTERNAL_ATOMIC_H
3021 -
3022 -#include <stdint.h>
3023 -
3024 -static inline int a_ctz_64(uint64_t x)
3025 -{
3026 -       __asm__( "bsf %1,%0" : "=r"(x) : "r"(x) );
3027 -       return x;
3028 -}
3029 -
3030 -static inline int a_ctz_l(unsigned long x)
3031 -{
3032 -       __asm__( "bsf %1,%0" : "=r"(x) : "r"(x) );
3033 -       return x;
3034 -}
3035 -
3036 -static inline void a_and_64(volatile uint64_t *p, uint64_t v)
3037 -{
3038 -       __asm__( "lock ; and %1, %0"
3039 -                        : "=m"(*p) : "r"(v) : "memory" );
3040 -}
3041 -
3042 -static inline void a_or_64(volatile uint64_t *p, uint64_t v)
3043 -{
3044 -       __asm__( "lock ; or %1, %0"
3045 -                        : "=m"(*p) : "r"(v) : "memory" );
3046 -}
3047 -
3048 -static inline void a_or_l(volatile void *p, long v)
3049 -{
3050 -       __asm__( "lock ; or %1, %0"
3051 -               : "=m"(*(long *)p) : "r"(v) : "memory" );
3052 -}
3053 -
3054 -static inline void *a_cas_p(volatile void *p, void *t, void *s)
3055 -{
3056 -       __asm__( "lock ; cmpxchg %3, %1"
3057 -               : "=a"(t), "=m"(*(long *)p) : "a"(t), "r"(s) : "memory" );
3058 -       return t;
3059 -}
3060 -
3061 -static inline int a_cas(volatile int *p, int t, int s)
3062 -{
3063 -       __asm__( "lock ; cmpxchg %3, %1"
3064 -               : "=a"(t), "=m"(*p) : "a"(t), "r"(s) : "memory" );
3065 -       return t;
3066 -}
3067 -
3068 -static inline void a_or(volatile int *p, int v)
3069 -{
3070 -       __asm__( "lock ; or %1, %0"
3071 -               : "=m"(*p) : "r"(v) : "memory" );
3072 -}
3073 -
3074 -static inline void a_and(volatile int *p, int v)
3075 -{
3076 -       __asm__( "lock ; and %1, %0"
3077 -               : "=m"(*p) : "r"(v) : "memory" );
3078 -}
3079 -
3080 -static inline int a_swap(volatile int *x, int v)
3081 -{
3082 -       __asm__( "xchg %0, %1" : "=r"(v), "=m"(*x) : "0"(v) : "memory" );
3083 -       return v;
3084 -}
3085 -
3086 -static inline int a_fetch_add(volatile int *x, int v)
3087 -{
3088 -       __asm__( "lock ; xadd %0, %1" : "=r"(v), "=m"(*x) : "0"(v) : "memory" );
3089 -       return v;
3090 -}
3091 -
3092 -static inline void a_inc(volatile int *x)
3093 -{
3094 -       __asm__( "lock ; incl %0" : "=m"(*x) : "m"(*x) : "memory" );
3095 -}
3096 -
3097 -static inline void a_dec(volatile int *x)
3098 -{
3099 -       __asm__( "lock ; decl %0" : "=m"(*x) : "m"(*x) : "memory" );
3100 -}
3101 -
3102 -static inline void a_store(volatile int *p, int x)
3103 -{
3104 -       __asm__( "mov %1, %0 ; lock ; orl $0,(%%rsp)" : "=m"(*p) : "r"(x) : "memory" );
3105 -}
3106 -
3107 -static inline void a_spin()
3108 -{
3109 -       __asm__ __volatile__( "pause" : : : "memory" );
3110 -}
3111 -
3112 -static inline void a_barrier()
3113 -{
3114 -       __asm__ __volatile__( "" : : : "memory" );
3115 -}
3116 -
3117 -static inline void a_crash()
3118 -{
3119 -       __asm__ __volatile__( "hlt" : : : "memory" );
3120 -}
3121 -
3122 -
3123 -#endif
3124 --- /dev/null
3125 +++ b/arch/x86_64/atomic_arch.h
3126 @@ -0,0 +1,107 @@
3127 +#define a_ctz_64 a_ctz_64
3128 +static inline int a_ctz_64(uint64_t x)
3129 +{
3130 +       __asm__( "bsf %1,%0" : "=r"(x) : "r"(x) );
3131 +       return x;
3132 +}
3133 +
3134 +#define a_and_64 a_and_64
3135 +static inline void a_and_64(volatile uint64_t *p, uint64_t v)
3136 +{
3137 +       __asm__( "lock ; and %1, %0"
3138 +                        : "=m"(*p) : "r"(v) : "memory" );
3139 +}
3140 +
3141 +#define a_or_64 a_or_64
3142 +static inline void a_or_64(volatile uint64_t *p, uint64_t v)
3143 +{
3144 +       __asm__( "lock ; or %1, %0"
3145 +                        : "=m"(*p) : "r"(v) : "memory" );
3146 +}
3147 +
3148 +#define a_or_l a_or_l
3149 +static inline void a_or_l(volatile void *p, long v)
3150 +{
3151 +       __asm__( "lock ; or %1, %0"
3152 +               : "=m"(*(long *)p) : "r"(v) : "memory" );
3153 +}
3154 +
3155 +#define a_cas_p a_cas_p
3156 +static inline void *a_cas_p(volatile void *p, void *t, void *s)
3157 +{
3158 +       __asm__( "lock ; cmpxchg %3, %1"
3159 +               : "=a"(t), "=m"(*(long *)p) : "a"(t), "r"(s) : "memory" );
3160 +       return t;
3161 +}
3162 +
3163 +#define a_cas a_cas
3164 +static inline int a_cas(volatile int *p, int t, int s)
3165 +{
3166 +       __asm__( "lock ; cmpxchg %3, %1"
3167 +               : "=a"(t), "=m"(*p) : "a"(t), "r"(s) : "memory" );
3168 +       return t;
3169 +}
3170 +
3171 +#define a_or a_or
3172 +static inline void a_or(volatile int *p, int v)
3173 +{
3174 +       __asm__( "lock ; or %1, %0"
3175 +               : "=m"(*p) : "r"(v) : "memory" );
3176 +}
3177 +
3178 +#define a_and a_and
3179 +static inline void a_and(volatile int *p, int v)
3180 +{
3181 +       __asm__( "lock ; and %1, %0"
3182 +               : "=m"(*p) : "r"(v) : "memory" );
3183 +}
3184 +
3185 +#define a_swap a_swap
3186 +static inline int a_swap(volatile int *x, int v)
3187 +{
3188 +       __asm__( "xchg %0, %1" : "=r"(v), "=m"(*x) : "0"(v) : "memory" );
3189 +       return v;
3190 +}
3191 +
3192 +#define a_fetch_add a_fetch_add
3193 +static inline int a_fetch_add(volatile int *x, int v)
3194 +{
3195 +       __asm__( "lock ; xadd %0, %1" : "=r"(v), "=m"(*x) : "0"(v) : "memory" );
3196 +       return v;
3197 +}
3198 +
3199 +#define a_inc a_inc
3200 +static inline void a_inc(volatile int *x)
3201 +{
3202 +       __asm__( "lock ; incl %0" : "=m"(*x) : "m"(*x) : "memory" );
3203 +}
3204 +
3205 +#define a_dec a_dec
3206 +static inline void a_dec(volatile int *x)
3207 +{
3208 +       __asm__( "lock ; decl %0" : "=m"(*x) : "m"(*x) : "memory" );
3209 +}
3210 +
3211 +#define a_store a_store
3212 +static inline void a_store(volatile int *p, int x)
3213 +{
3214 +       __asm__( "mov %1, %0 ; lock ; orl $0,(%%rsp)" : "=m"(*p) : "r"(x) : "memory" );
3215 +}
3216 +
3217 +#define a_spin a_spin
3218 +static inline void a_spin()
3219 +{
3220 +       __asm__ __volatile__( "pause" : : : "memory" );
3221 +}
3222 +
3223 +#define a_barrier a_barrier
3224 +static inline void a_barrier()
3225 +{
3226 +       __asm__ __volatile__( "" : : : "memory" );
3227 +}
3228 +
3229 +#define a_crash a_crash
3230 +static inline void a_crash()
3231 +{
3232 +       __asm__ __volatile__( "hlt" : : : "memory" );
3233 +}
3234 --- a/arch/x86_64/pthread_arch.h
3235 +++ b/arch/x86_64/pthread_arch.h
3236 @@ -7,4 +7,4 @@ static inline struct pthread *__pthread_
3237
3238  #define TP_ADJ(p) (p)
3239
3240 -#define CANCEL_REG_IP 16
3241 +#define MC_PC gregs[REG_RIP]
3242 --- a/configure
3243 +++ b/configure
3244 @@ -9,6 +9,9 @@ VAR=VALUE.  See below for descriptions o
3245
3246  Defaults for the options are specified in brackets.
3247
3248 +Configuration:
3249 +  --srcdir=DIR            source directory [detected]
3250 +
3251  Installation directories:
3252    --prefix=PREFIX         main installation prefix [/usr/local/musl]
3253    --exec-prefix=EPREFIX   installation prefix for executable files [PREFIX]
3254 @@ -117,6 +120,7 @@ CFLAGS_TRY=
3255  LDFLAGS_AUTO=
3256  LDFLAGS_TRY=
3257  OPTIMIZE_GLOBS=
3258 +srcdir=
3259  prefix=/usr/local/musl
3260  exec_prefix='$(prefix)'
3261  bindir='$(exec_prefix)/bin'
3262 @@ -139,6 +143,7 @@ clang_wrapper=no
3263  for arg ; do
3264  case "$arg" in
3265  --help) usage ;;
3266 +--srcdir=*) srcdir=${arg#*=} ;;
3267  --prefix=*) prefix=${arg#*=} ;;
3268  --exec-prefix=*) exec_prefix=${arg#*=} ;;
3269  --bindir=*) bindir=${arg#*=} ;;
3270 @@ -179,11 +184,23 @@ LIBCC=*) LIBCC=${arg#*=} ;;
3271  esac
3272  done
3273
3274 -for i in prefix exec_prefix bindir libdir includedir syslibdir ; do
3275 +for i in srcdir prefix exec_prefix bindir libdir includedir syslibdir ; do
3276  stripdir $i
3277  done
3278
3279  #
3280 +# Get the source dir for out-of-tree builds
3281 +#
3282 +if test -z "$srcdir" ; then
3283 +srcdir="${0%/configure}"
3284 +stripdir srcdir
3285 +fi
3286 +abs_builddir="$(pwd)" || fail "$0: cannot determine working directory"
3287 +abs_srcdir="$(cd $srcdir && pwd)" || fail "$0: invalid source directory $srcdir"
3288 +test "$abs_srcdir" = "$abs_builddir" && srcdir=.
3289 +test "$srcdir" != "." -a -f Makefile -a ! -h Makefile && fail "$0: Makefile already exists in the working directory"
3290 +
3291 +#
3292  # Get a temp filename we can use
3293  #
3294  i=0
3295 @@ -263,11 +280,11 @@ fi
3296  fi
3297
3298  if test "$gcc_wrapper" = yes ; then
3299 -tools="$tools tools/musl-gcc"
3300 +tools="$tools obj/musl-gcc"
3301  tool_libs="$tool_libs lib/musl-gcc.specs"
3302  fi
3303  if test "$clang_wrapper" = yes ; then
3304 -tools="$tools tools/musl-clang tools/ld.musl-clang"
3305 +tools="$tools obj/musl-clang obj/ld.musl-clang"
3306  fi
3307
3308  #
3309 @@ -321,7 +338,7 @@ __attribute__((__may_alias__))
3310  #endif
3311  x;
3312  EOF
3313 -if $CC $CFLAGS_C99FSE -I./arch/$ARCH -I./include $CPPFLAGS $CFLAGS \
3314 +if $CC $CFLAGS_C99FSE -I$srcdir/arch/$ARCH -I$srcdir/include $CPPFLAGS $CFLAGS \
3315    -c -o /dev/null "$tmpc" >/dev/null 2>&1 ; then
3316  printf "no\n"
3317  else
3318 @@ -330,6 +347,13 @@ CFLAGS_C99FSE="$CFLAGS_C99FSE -D__may_al
3319  fi
3320
3321  #
3322 +# The GNU toolchain defaults to assuming unmarked files need an
3323 +# executable stack, potentially exposing vulnerabilities in programs
3324 +# linked with such object files. Fix this.
3325 +#
3326 +tryflag CFLAGS_C99FSE -Wa,--noexecstack
3327 +
3328 +#
3329  # Check for options to disable stack protector, which needs to be
3330  # disabled for a few early-bootstrap translation units. If not found,
3331  # this is not an error; we assume the toolchain does not do ssp.
3332 @@ -430,11 +454,15 @@ tryflag CFLAGS_AUTO -fno-unwind-tables
3333  tryflag CFLAGS_AUTO -fno-asynchronous-unwind-tables
3334
3335  #
3336 -# The GNU toolchain defaults to assuming unmarked files need an
3337 -# executable stack, potentially exposing vulnerabilities in programs
3338 -# linked with such object files. Fix this.
3339 +# Attempt to put each function and each data object in its own
3340 +# section. This both allows additional size optimizations at link
3341 +# time and works around a dangerous class of compiler/assembler bugs
3342 +# whereby relative address expressions are constant-folded by the
3343 +# assembler even when one or more of the symbols involved is
3344 +# replaceable. See gas pr 18561 and gcc pr 66609, 68178, etc.
3345  #
3346 -tryflag CFLAGS_AUTO -Wa,--noexecstack
3347 +tryflag CFLAGS_AUTO -ffunction-sections
3348 +tryflag CFLAGS_AUTO -fdata-sections
3349
3350  #
3351  # On x86, make sure we don't have incompatible instruction set
3352 @@ -489,7 +517,7 @@ int foo(void) { }
3353  int bar(void) { fp = foo; return foo(); }
3354  EOF
3355  if $CC $CFLAGS_C99FSE $CPPFLAGS $CFLAGS \
3356 -  -DSHARED -fPIC -I./src/internal -include vis.h \
3357 +  -DSHARED -fPIC -I$srcdir/src/internal -include vis.h \
3358    -nostdlib -shared -Wl,-Bsymbolic-functions \
3359    -o /dev/null "$tmpc" >/dev/null 2>&1 ; then
3360  visibility=yes
3361 @@ -504,6 +532,16 @@ CFLAGS_AUTO="$CFLAGS_AUTO -include vis.h
3362  CFLAGS_AUTO="${CFLAGS_AUTO# }"
3363  fi
3364
3365 +# Reduce space lost to padding for alignment purposes by sorting data
3366 +# objects according to their alignment reqirements. This approximates
3367 +# optimal packing.
3368 +tryldflag LDFLAGS_AUTO -Wl,--sort-section,alignment
3369 +tryldflag LDFLAGS_AUTO -Wl,--sort-common
3370 +
3371 +# When linking shared library, drop dummy weak definitions that were
3372 +# replaced by strong definitions from other translation units.
3373 +tryldflag LDFLAGS_AUTO -Wl,--gc-sections
3374 +
3375  # Some patched GCC builds have these defaults messed up...
3376  tryldflag LDFLAGS_AUTO -Wl,--hash-style=both
3377
3378 @@ -513,6 +551,11 @@ tryldflag LDFLAGS_AUTO -Wl,--hash-style=
3379  # runtime library; implementation error is also a possibility.
3380  tryldflag LDFLAGS_AUTO -Wl,--no-undefined
3381
3382 +# Avoid exporting symbols from compiler runtime libraries. They
3383 +# should be hidden anyway, but some toolchains including old gcc
3384 +# versions built without shared library support and pcc are broken.
3385 +tryldflag LDFLAGS_AUTO -Wl,--exclude-libs=ALL
3386 +
3387  test "$shared" = "no" || {
3388  # Disable dynamic linking if ld is broken and can't do -Bsymbolic-functions
3389  LDFLAGS_DUMMY=
3390 @@ -599,7 +642,7 @@ echo '#include <float.h>' > "$tmpc"
3391  echo '#if LDBL_MANT_DIG == 53' >> "$tmpc"
3392  echo 'typedef char ldcheck[9-(int)sizeof(long double)];' >> "$tmpc"
3393  echo '#endif' >> "$tmpc"
3394 -if $CC $CFLAGS_C99FSE -I./arch/$ARCH -I./include $CPPFLAGS $CFLAGS \
3395 +if $CC $CFLAGS_C99FSE -I$srcdir/arch/$ARCH -I$srcdir/include $CPPFLAGS $CFLAGS \
3396    -c -o /dev/null "$tmpc" >/dev/null 2>&1 ; then
3397  printf "yes\n"
3398  else
3399 @@ -622,6 +665,7 @@ cat << EOF
3400  ARCH = $ARCH
3401  SUBARCH = $SUBARCH
3402  ASMSUBARCH = $ASMSUBARCH
3403 +srcdir = $srcdir
3404  prefix = $prefix
3405  exec_prefix = $exec_prefix
3406  bindir = $bindir
3407 @@ -629,12 +673,14 @@ libdir = $libdir
3408  includedir = $includedir
3409  syslibdir = $syslibdir
3410  CC = $CC
3411 -CFLAGS = $CFLAGS_AUTO $CFLAGS
3412 +CFLAGS = $CFLAGS
3413 +CFLAGS_AUTO = $CFLAGS_AUTO
3414  CFLAGS_C99FSE = $CFLAGS_C99FSE
3415  CFLAGS_MEMOPS = $CFLAGS_MEMOPS
3416  CFLAGS_NOSSP = $CFLAGS_NOSSP
3417  CPPFLAGS = $CPPFLAGS
3418 -LDFLAGS = $LDFLAGS_AUTO $LDFLAGS
3419 +LDFLAGS = $LDFLAGS
3420 +LDFLAGS_AUTO = $LDFLAGS_AUTO
3421  CROSS_COMPILE = $CROSS_COMPILE
3422  LIBCC = $LIBCC
3423  OPTIMIZE_GLOBS = $OPTIMIZE_GLOBS
3424 @@ -648,4 +694,6 @@ test "x$cc_family" = xgcc && echo 'WRAPC
3425  test "x$cc_family" = xclang && echo 'WRAPCC_CLANG = $(CC)'
3426  exec 1>&3 3>&-
3427
3428 +test "$srcdir" = "." || ln -sf $srcdir/Makefile .
3429 +
3430  printf "done\n"
3431 --- a/crt/arm/crti.s
3432 +++ b/crt/arm/crti.s
3433 @@ -1,3 +1,5 @@
3434 +.syntax unified
3435 +
3436  .section .init
3437  .global _init
3438  .type _init,%function
3439 --- a/crt/arm/crtn.s
3440 +++ b/crt/arm/crtn.s
3441 @@ -1,11 +1,9 @@
3442 +.syntax unified
3443 +
3444  .section .init
3445         pop {r0,lr}
3446 -       tst lr,#1
3447 -       moveq pc,lr
3448         bx lr
3449
3450  .section .fini
3451         pop {r0,lr}
3452 -       tst lr,#1
3453 -       moveq pc,lr
3454         bx lr
3455 --- a/include/complex.h
3456 +++ b/include/complex.h
3457 @@ -116,7 +116,7 @@ long double creall(long double complex);
3458
3459  #if __STDC_VERSION__ >= 201112L
3460  #if defined(_Imaginary_I)
3461 -#define __CMPLX(x, y, t) ((t)(x) + _Imaginary_I*(t)(y)))
3462 +#define __CMPLX(x, y, t) ((t)(x) + _Imaginary_I*(t)(y))
3463  #elif defined(__clang__)
3464  #define __CMPLX(x, y, t) (+(_Complex t){ (t)(x), (t)(y) })
3465  #else
3466 --- a/include/netinet/tcp.h
3467 +++ b/include/netinet/tcp.h
3468 @@ -41,7 +41,20 @@
3469  #define TCP_CLOSING      11
3470
3471  #if defined(_GNU_SOURCE) || defined(_BSD_SOURCE)
3472 +#define TCPOPT_EOL              0
3473 +#define TCPOPT_NOP              1
3474 +#define TCPOPT_MAXSEG           2
3475 +#define TCPOPT_WINDOW           3
3476 +#define TCPOPT_SACK_PERMITTED   4
3477 +#define TCPOPT_SACK             5
3478 +#define TCPOPT_TIMESTAMP        8
3479 +#define TCPOLEN_SACK_PERMITTED  2
3480 +#define TCPOLEN_WINDOW          3
3481 +#define TCPOLEN_MAXSEG          4
3482 +#define TCPOLEN_TIMESTAMP       10
3483 +
3484  #define SOL_TCP 6
3485 +
3486  #include <sys/types.h>
3487  #include <sys/socket.h>
3488  #include <stdint.h>
3489 --- a/src/env/__init_tls.c
3490 +++ b/src/env/__init_tls.c
3491 @@ -8,9 +8,6 @@
3492  #include "atomic.h"
3493  #include "syscall.h"
3494
3495 -#ifndef SHARED
3496 -static
3497 -#endif
3498  int __init_tp(void *p)
3499  {
3500         pthread_t td = p;
3501 @@ -24,8 +21,6 @@ int __init_tp(void *p)
3502         return 0;
3503  }
3504
3505 -#ifndef SHARED
3506 -
3507  static struct builtin_tls {
3508         char c;
3509         struct pthread pt;
3510 @@ -33,33 +28,40 @@ static struct builtin_tls {
3511  } builtin_tls[1];
3512  #define MIN_TLS_ALIGN offsetof(struct builtin_tls, pt)
3513
3514 -struct tls_image {
3515 -       void *image;
3516 -       size_t len, size, align;
3517 -} __static_tls;
3518 -
3519 -#define T __static_tls
3520 +static struct tls_module main_tls;
3521
3522  void *__copy_tls(unsigned char *mem)
3523  {
3524         pthread_t td;
3525 -       if (!T.image) return mem;
3526 -       void **dtv = (void *)mem;
3527 -       dtv[0] = (void *)1;
3528 +       struct tls_module *p;
3529 +       size_t i;
3530 +       void **dtv;
3531 +
3532  #ifdef TLS_ABOVE_TP
3533 -       mem += sizeof(void *) * 2;
3534 -       mem += -((uintptr_t)mem + sizeof(struct pthread)) & (T.align-1);
3535 +       dtv = (void **)(mem + libc.tls_size) - (libc.tls_cnt + 1);
3536 +
3537 +       mem += -((uintptr_t)mem + sizeof(struct pthread)) & (libc.tls_align-1);
3538         td = (pthread_t)mem;
3539         mem += sizeof(struct pthread);
3540 +
3541 +       for (i=1, p=libc.tls_head; p; i++, p=p->next) {
3542 +               dtv[i] = mem + p->offset;
3543 +               memcpy(dtv[i], p->image, p->len);
3544 +       }
3545  #else
3546 +       dtv = (void **)mem;
3547 +
3548         mem += libc.tls_size - sizeof(struct pthread);
3549 -       mem -= (uintptr_t)mem & (T.align-1);
3550 +       mem -= (uintptr_t)mem & (libc.tls_align-1);
3551         td = (pthread_t)mem;
3552 -       mem -= T.size;
3553 +
3554 +       for (i=1, p=libc.tls_head; p; i++, p=p->next) {
3555 +               dtv[i] = mem - p->offset;
3556 +               memcpy(dtv[i], p->image, p->len);
3557 +       }
3558  #endif
3559 +       dtv[0] = (void *)libc.tls_cnt;
3560         td->dtv = td->dtv_copy = dtv;
3561 -       dtv[1] = mem;
3562 -       memcpy(mem, T.image, T.len);
3563         return td;
3564  }
3565
3566 @@ -69,7 +71,7 @@ typedef Elf32_Phdr Phdr;
3567  typedef Elf64_Phdr Phdr;
3568  #endif
3569
3570 -void __init_tls(size_t *aux)
3571 +static void static_init_tls(size_t *aux)
3572  {
3573         unsigned char *p;
3574         size_t n;
3575 @@ -86,16 +88,24 @@ void __init_tls(size_t *aux)
3576         }
3577
3578         if (tls_phdr) {
3579 -               T.image = (void *)(base + tls_phdr->p_vaddr);
3580 -               T.len = tls_phdr->p_filesz;
3581 -               T.size = tls_phdr->p_memsz;
3582 -               T.align = tls_phdr->p_align;
3583 +               main_tls.image = (void *)(base + tls_phdr->p_vaddr);
3584 +               main_tls.len = tls_phdr->p_filesz;
3585 +               main_tls.size = tls_phdr->p_memsz;
3586 +               main_tls.align = tls_phdr->p_align;
3587 +               libc.tls_cnt = 1;
3588 +               libc.tls_head = &main_tls;
3589         }
3590
3591 -       T.size += (-T.size - (uintptr_t)T.image) & (T.align-1);
3592 -       if (T.align < MIN_TLS_ALIGN) T.align = MIN_TLS_ALIGN;
3593 +       main_tls.size += (-main_tls.size - (uintptr_t)main_tls.image)
3594 +               & (main_tls.align-1);
3595 +       if (main_tls.align < MIN_TLS_ALIGN) main_tls.align = MIN_TLS_ALIGN;
3596 +#ifndef TLS_ABOVE_TP
3597 +       main_tls.offset = main_tls.size;
3598 +#endif
3599
3600 -       libc.tls_size = 2*sizeof(void *)+T.size+T.align+sizeof(struct pthread)
3601 +       libc.tls_align = main_tls.align;
3602 +       libc.tls_size = 2*sizeof(void *) + sizeof(struct pthread)
3603 +               + main_tls.size + main_tls.align
3604                 + MIN_TLS_ALIGN-1 & -MIN_TLS_ALIGN;
3605
3606         if (libc.tls_size > sizeof builtin_tls) {
3607 @@ -117,6 +127,5 @@ void __init_tls(size_t *aux)
3608         if (__init_tp(__copy_tls(mem)) < 0)
3609                 a_crash();
3610  }
3611 -#else
3612 -void __init_tls(size_t *auxv) { }
3613 -#endif
3614 +
3615 +weak_alias(static_init_tls, __init_tls);
3616 --- a/src/env/__libc_start_main.c
3617 +++ b/src/env/__libc_start_main.c
3618 @@ -8,21 +8,17 @@
3619
3620  void __init_tls(size_t *);
3621
3622 -#ifndef SHARED
3623 -static void dummy() {}
3624 +static void dummy(void) {}
3625  weak_alias(dummy, _init);
3626 -extern void (*const __init_array_start)() __attribute__((weak));
3627 -extern void (*const __init_array_end)() __attribute__((weak));
3628 -#endif
3629 +
3630 +__attribute__((__weak__, __visibility__("hidden")))
3631 +extern void (*const __init_array_start)(void), (*const __init_array_end)(void);
3632
3633  static void dummy1(void *p) {}
3634  weak_alias(dummy1, __init_ssp);
3635
3636  #define AUX_CNT 38
3637
3638 -#ifndef SHARED
3639 -static
3640 -#endif
3641  void __init_libc(char **envp, char *pn)
3642  {
3643         size_t i, *auxv, aux[AUX_CNT] = { 0 };
3644 @@ -57,20 +53,22 @@ void __init_libc(char **envp, char *pn)
3645         libc.secure = 1;
3646  }
3647
3648 -int __libc_start_main(int (*main)(int,char **,char **), int argc, char **argv)
3649 +static void libc_start_init(void)
3650  {
3651 -       char **envp = argv+argc+1;
3652 -
3653 -#ifndef SHARED
3654 -       __init_libc(envp, argv[0]);
3655         _init();
3656         uintptr_t a = (uintptr_t)&__init_array_start;
3657         for (; a<(uintptr_t)&__init_array_end; a+=sizeof(void(*)()))
3658                 (*(void (**)())a)();
3659 -#else
3660 -       void __libc_start_init(void);
3661 +}
3662 +
3663 +weak_alias(libc_start_init, __libc_start_init);
3664 +
3665 +int __libc_start_main(int (*main)(int,char **,char **), int argc, char **argv)
3666 +{
3667 +       char **envp = argv+argc+1;
3668 +
3669 +       __init_libc(envp, argv[0]);
3670         __libc_start_init();
3671 -#endif
3672
3673         /* Pass control to the application */
3674         exit(main(argc, argv, envp));
3675 --- a/src/env/__reset_tls.c
3676 +++ b/src/env/__reset_tls.c
3677 @@ -1,21 +1,16 @@
3678 -#ifndef SHARED
3679 -
3680  #include <string.h>
3681  #include "pthread_impl.h"
3682 -
3683 -extern struct tls_image {
3684 -       void *image;
3685 -       size_t len, size, align;
3686 -} __static_tls;
3687 -
3688 -#define T __static_tls
3689 +#include "libc.h"
3690
3691  void __reset_tls()
3692  {
3693 -       if (!T.size) return;
3694         pthread_t self = __pthread_self();
3695 -       memcpy(self->dtv[1], T.image, T.len);
3696 -       memset((char *)self->dtv[1]+T.len, 0, T.size-T.len);
3697 +       struct tls_module *p;
3698 +       size_t i, n = (size_t)self->dtv[0];
3699 +       if (n) for (p=libc.tls_head, i=1; i<=n; i++, p=p->next) {
3700 +               if (!self->dtv[i]) continue;
3701 +               memcpy(self->dtv[i], p->image, p->len);
3702 +               memset((char *)self->dtv[i]+p->len, 0,
3703 +                       p->size - p->len);
3704 +       }
3705  }
3706 -
3707 -#endif
3708 --- a/src/env/__stack_chk_fail.c
3709 +++ b/src/env/__stack_chk_fail.c
3710 @@ -17,16 +17,7 @@ void __stack_chk_fail(void)
3711         a_crash();
3712  }
3713
3714 -#ifdef SHARED
3715 -
3716  __attribute__((__visibility__("hidden")))
3717 -void __stack_chk_fail_local(void)
3718 -{
3719 -       a_crash();
3720 -}
3721 -
3722 -#else
3723 +void __stack_chk_fail_local(void);
3724
3725  weak_alias(__stack_chk_fail, __stack_chk_fail_local);
3726 -
3727 -#endif
3728 --- /dev/null
3729 +++ b/src/exit/arm/__aeabi_atexit.c
3730 @@ -0,0 +1,6 @@
3731 +int __cxa_atexit(void (*func)(void *), void *arg, void *dso);
3732 +
3733 +int __aeabi_atexit (void *obj, void (*func) (void *), void *d)
3734 +{
3735 +       return __cxa_atexit (func, obj, d);
3736 +}
3737 --- a/src/exit/exit.c
3738 +++ b/src/exit/exit.c
3739 @@ -10,25 +10,25 @@ static void dummy()
3740   * as a consequence of linking either __toread.c or __towrite.c. */
3741  weak_alias(dummy, __funcs_on_exit);
3742  weak_alias(dummy, __stdio_exit);
3743 -
3744 -#ifndef SHARED
3745  weak_alias(dummy, _fini);
3746 -extern void (*const __fini_array_start)() __attribute__((weak));
3747 -extern void (*const __fini_array_end)() __attribute__((weak));
3748 -#endif
3749
3750 -_Noreturn void exit(int code)
3751 -{
3752 -       __funcs_on_exit();
3753 +__attribute__((__weak__, __visibility__("hidden")))
3754 +extern void (*const __fini_array_start)(void), (*const __fini_array_end)(void);
3755
3756 -#ifndef SHARED
3757 +static void libc_exit_fini(void)
3758 +{
3759         uintptr_t a = (uintptr_t)&__fini_array_end;
3760         for (; a>(uintptr_t)&__fini_array_start; a-=sizeof(void(*)()))
3761                 (*(void (**)())(a-sizeof(void(*)())))();
3762         _fini();
3763 -#endif
3764 +}
3765
3766 -       __stdio_exit();
3767 +weak_alias(libc_exit_fini, __libc_exit_fini);
3768
3769 +_Noreturn void exit(int code)
3770 +{
3771 +       __funcs_on_exit();
3772 +       __libc_exit_fini();
3773 +       __stdio_exit();
3774         _Exit(code);
3775  }
3776 --- /dev/null
3777 +++ b/src/fenv/arm/fenv-hf.S
3778 @@ -0,0 +1,69 @@
3779 +#if __ARM_PCS_VFP
3780 +
3781 +.syntax unified
3782 +.fpu vfp
3783 +
3784 +.global fegetround
3785 +.type fegetround,%function
3786 +fegetround:
3787 +       fmrx r0, fpscr
3788 +       and r0, r0, #0xc00000
3789 +       bx lr
3790 +
3791 +.global __fesetround
3792 +.type __fesetround,%function
3793 +__fesetround:
3794 +       fmrx r3, fpscr
3795 +       bic r3, r3, #0xc00000
3796 +       orr r3, r3, r0
3797 +       fmxr fpscr, r3
3798 +       mov r0, #0
3799 +       bx lr
3800 +
3801 +.global fetestexcept
3802 +.type fetestexcept,%function
3803 +fetestexcept:
3804 +       and r0, r0, #0x1f
3805 +       fmrx r3, fpscr
3806 +       and r0, r0, r3
3807 +       bx lr
3808 +
3809 +.global feclearexcept
3810 +.type feclearexcept,%function
3811 +feclearexcept:
3812 +       and r0, r0, #0x1f
3813 +       fmrx r3, fpscr
3814 +       bic r3, r3, r0
3815 +       fmxr fpscr, r3
3816 +       mov r0, #0
3817 +       bx lr
3818 +
3819 +.global feraiseexcept
3820 +.type feraiseexcept,%function
3821 +feraiseexcept:
3822 +       and r0, r0, #0x1f
3823 +       fmrx r3, fpscr
3824 +       orr r3, r3, r0
3825 +       fmxr fpscr, r3
3826 +       mov r0, #0
3827 +       bx lr
3828 +
3829 +.global fegetenv
3830 +.type fegetenv,%function
3831 +fegetenv:
3832 +       fmrx r3, fpscr
3833 +       str r3, [r0]
3834 +       mov r0, #0
3835 +       bx lr
3836 +
3837 +.global fesetenv
3838 +.type fesetenv,%function
3839 +fesetenv:
3840 +       cmn r0, #1
3841 +       moveq r3, #0
3842 +       ldrne r3, [r0]
3843 +       fmxr fpscr, r3
3844 +       mov r0, #0
3845 +       bx lr
3846 +
3847 +#endif
3848 --- /dev/null
3849 +++ b/src/fenv/arm/fenv.c
3850 @@ -0,0 +1,3 @@
3851 +#if !__ARM_PCS_VFP
3852 +#include "../fenv.c"
3853 +#endif
3854 --- a/src/fenv/armebhf/fenv.sub
3855 +++ /dev/null
3856 @@ -1 +0,0 @@
3857 -../armhf/fenv.s
3858 --- a/src/fenv/armhf/fenv.s
3859 +++ /dev/null
3860 @@ -1,64 +0,0 @@
3861 -.fpu vfp
3862 -
3863 -.global fegetround
3864 -.type fegetround,%function
3865 -fegetround:
3866 -       mrc p10, 7, r0, cr1, cr0, 0
3867 -       and r0, r0, #0xc00000
3868 -       bx lr
3869 -
3870 -.global __fesetround
3871 -.type __fesetround,%function
3872 -__fesetround:
3873 -       mrc p10, 7, r3, cr1, cr0, 0
3874 -       bic r3, r3, #0xc00000
3875 -       orr r3, r3, r0
3876 -       mcr p10, 7, r3, cr1, cr0, 0
3877 -       mov r0, #0
3878 -       bx lr
3879 -
3880 -.global fetestexcept
3881 -.type fetestexcept,%function
3882 -fetestexcept:
3883 -       and r0, r0, #0x1f
3884 -       mrc p10, 7, r3, cr1, cr0, 0
3885 -       and r0, r0, r3
3886 -       bx lr
3887 -
3888 -.global feclearexcept
3889 -.type feclearexcept,%function
3890 -feclearexcept:
3891 -       and r0, r0, #0x1f
3892 -       mrc p10, 7, r3, cr1, cr0, 0
3893 -       bic r3, r3, r0
3894 -       mcr p10, 7, r3, cr1, cr0, 0
3895 -       mov r0, #0
3896 -       bx lr
3897 -
3898 -.global feraiseexcept
3899 -.type feraiseexcept,%function
3900 -feraiseexcept:
3901 -       and r0, r0, #0x1f
3902 -       mrc p10, 7, r3, cr1, cr0, 0
3903 -       orr r3, r3, r0
3904 -       mcr p10, 7, r3, cr1, cr0, 0
3905 -       mov r0, #0
3906 -       bx lr
3907 -
3908 -.global fegetenv
3909 -.type fegetenv,%function
3910 -fegetenv:
3911 -       mrc p10, 7, r3, cr1, cr0, 0
3912 -       str r3, [r0]
3913 -       mov r0, #0
3914 -       bx lr
3915 -
3916 -.global fesetenv
3917 -.type fesetenv,%function
3918 -fesetenv:
3919 -       cmn r0, #1
3920 -       moveq r3, #0
3921 -       ldrne r3, [r0]
3922 -       mcr p10, 7, r3, cr1, cr0, 0
3923 -       mov r0, #0
3924 -       bx lr
3925 --- a/src/fenv/armhf/fenv.sub
3926 +++ /dev/null
3927 @@ -1 +0,0 @@
3928 -fenv.s
3929 --- a/src/fenv/mips-sf/fenv.sub
3930 +++ /dev/null
3931 @@ -1 +0,0 @@
3932 -../fenv.c
3933 --- /dev/null
3934 +++ b/src/fenv/mips/fenv-sf.c
3935 @@ -0,0 +1,3 @@
3936 +#ifdef __mips_soft_float
3937 +#include "../fenv.c"
3938 +#endif
3939 --- /dev/null
3940 +++ b/src/fenv/mips/fenv.S
3941 @@ -0,0 +1,71 @@
3942 +#ifndef __mips_soft_float
3943 +
3944 +.set noreorder
3945 +
3946 +.global feclearexcept
3947 +.type  feclearexcept,@function
3948 +feclearexcept:
3949 +       and     $4, $4, 0x7c
3950 +       cfc1    $5, $31
3951 +       or      $5, $5, $4
3952 +       xor     $5, $5, $4
3953 +       ctc1    $5, $31
3954 +       jr      $ra
3955 +       li      $2, 0
3956 +
3957 +.global feraiseexcept
3958 +.type  feraiseexcept,@function
3959 +feraiseexcept:
3960 +       and     $4, $4, 0x7c
3961 +       cfc1    $5, $31
3962 +       or      $5, $5, $4
3963 +       ctc1    $5, $31
3964 +       jr      $ra
3965 +       li      $2, 0
3966 +
3967 +.global fetestexcept
3968 +.type  fetestexcept,@function
3969 +fetestexcept:
3970 +       and     $4, $4, 0x7c
3971 +       cfc1    $2, $31
3972 +       jr      $ra
3973 +       and     $2, $2, $4
3974 +
3975 +.global fegetround
3976 +.type  fegetround,@function
3977 +fegetround:
3978 +       cfc1    $2, $31
3979 +       jr      $ra
3980 +       andi    $2, $2, 3
3981 +
3982 +.global __fesetround
3983 +.type __fesetround,@function
3984 +__fesetround:
3985 +       cfc1    $5, $31
3986 +       li      $6, -4
3987 +       and     $5, $5, $6
3988 +       or      $5, $5, $4
3989 +       ctc1    $5, $31
3990 +       jr      $ra
3991 +       li      $2, 0
3992 +
3993 +.global fegetenv
3994 +.type  fegetenv,@function
3995 +fegetenv:
3996 +       cfc1    $5, $31
3997 +       sw      $5, 0($4)
3998 +       jr      $ra
3999 +       li      $2, 0
4000 +
4001 +.global fesetenv
4002 +.type  fesetenv,@function
4003 +fesetenv:
4004 +       addiu   $5, $4, 1
4005 +       beq     $5, $0, 1f
4006 +        nop
4007 +       lw      $5, 0($4)
4008 +1:     ctc1    $5, $31
4009 +       jr      $ra
4010 +       li      $2, 0
4011 +
4012 +#endif
4013 --- a/src/fenv/mips/fenv.s
4014 +++ /dev/null
4015 @@ -1,67 +0,0 @@
4016 -.set noreorder
4017 -
4018 -.global feclearexcept
4019 -.type  feclearexcept,@function
4020 -feclearexcept:
4021 -       and     $4, $4, 0x7c
4022 -       cfc1    $5, $31
4023 -       or      $5, $5, $4
4024 -       xor     $5, $5, $4
4025 -       ctc1    $5, $31
4026 -       jr      $ra
4027 -       li      $2, 0
4028 -
4029 -.global feraiseexcept
4030 -.type  feraiseexcept,@function
4031 -feraiseexcept:
4032 -       and     $4, $4, 0x7c
4033 -       cfc1    $5, $31
4034 -       or      $5, $5, $4
4035 -       ctc1    $5, $31
4036 -       jr      $ra
4037 -       li      $2, 0
4038 -
4039 -.global fetestexcept
4040 -.type  fetestexcept,@function
4041 -fetestexcept:
4042 -       and     $4, $4, 0x7c
4043 -       cfc1    $2, $31
4044 -       jr      $ra
4045 -       and     $2, $2, $4
4046 -
4047 -.global fegetround
4048 -.type  fegetround,@function
4049 -fegetround:
4050 -       cfc1    $2, $31
4051 -       jr      $ra
4052 -       andi    $2, $2, 3
4053 -
4054 -.global __fesetround
4055 -.type __fesetround,@function
4056 -__fesetround:
4057 -       cfc1    $5, $31
4058 -       li      $6, -4
4059 -       and     $5, $5, $6
4060 -       or      $5, $5, $4
4061 -       ctc1    $5, $31
4062 -       jr      $ra
4063 -       li      $2, 0
4064 -
4065 -.global fegetenv
4066 -.type  fegetenv,@function
4067 -fegetenv:
4068 -       cfc1    $5, $31
4069 -       sw      $5, 0($4)
4070 -       jr      $ra
4071 -       li      $2, 0
4072 -
4073 -.global fesetenv
4074 -.type  fesetenv,@function
4075 -fesetenv:
4076 -       addiu   $5, $4, 1
4077 -       beq     $5, $0, 1f
4078 -        nop
4079 -       lw      $5, 0($4)
4080 -1:     ctc1    $5, $31
4081 -       jr      $ra
4082 -       li      $2, 0
4083 --- a/src/fenv/mipsel-sf/fenv.sub
4084 +++ /dev/null
4085 @@ -1 +0,0 @@
4086 -../fenv.c
4087 --- a/src/fenv/sh-nofpu/fenv.sub
4088 +++ /dev/null
4089 @@ -1 +0,0 @@
4090 -../fenv.c
4091 --- /dev/null
4092 +++ b/src/fenv/sh/fenv-nofpu.c
4093 @@ -0,0 +1,3 @@
4094 +#if !__SH_FPU_ANY__ && !__SH4__
4095 +#include "../fenv.c"
4096 +#endif
4097 --- /dev/null
4098 +++ b/src/fenv/sh/fenv.S
4099 @@ -0,0 +1,78 @@
4100 +#if __SH_FPU_ANY__ || __SH4__
4101 +
4102 +.global fegetround
4103 +.type   fegetround, @function
4104 +fegetround:
4105 +       sts fpscr, r0
4106 +       rts
4107 +        and #3, r0
4108 +
4109 +.global __fesetround
4110 +.type   __fesetround, @function
4111 +__fesetround:
4112 +       sts fpscr, r0
4113 +       or  r4, r0
4114 +       lds r0, fpscr
4115 +       rts
4116 +        mov #0, r0
4117 +
4118 +.global fetestexcept
4119 +.type   fetestexcept, @function
4120 +fetestexcept:
4121 +       sts fpscr, r0
4122 +       and r4, r0
4123 +       rts
4124 +        and #0x7c, r0
4125 +
4126 +.global feclearexcept
4127 +.type   feclearexcept, @function
4128 +feclearexcept:
4129 +       mov r4, r0
4130 +       and #0x7c, r0
4131 +       not r0, r4
4132 +       sts fpscr, r0
4133 +       and r4, r0
4134 +       lds r0, fpscr
4135 +       rts
4136 +        mov #0, r0
4137 +
4138 +.global feraiseexcept
4139 +.type   feraiseexcept, @function
4140 +feraiseexcept:
4141 +       mov r4, r0
4142 +       and #0x7c, r0
4143 +       sts fpscr, r4
4144 +       or  r4, r0
4145 +       lds r0, fpscr
4146 +       rts
4147 +        mov #0, r0
4148 +
4149 +.global fegetenv
4150 +.type   fegetenv, @function
4151 +fegetenv:
4152 +       sts fpscr, r0
4153 +       mov.l r0, @r4
4154 +       rts
4155 +        mov #0, r0
4156 +
4157 +.global fesetenv
4158 +.type   fesetenv, @function
4159 +fesetenv:
4160 +       mov r4, r0
4161 +       cmp/eq #-1, r0
4162 +       bf 1f
4163 +
4164 +       ! the default environment is complicated by the fact that we need to
4165 +       ! preserve the current precision bit, which we do not know a priori
4166 +       sts fpscr, r0
4167 +       mov #8, r1
4168 +       swap.w r1, r1
4169 +       bra 2f
4170 +        and r1, r0
4171 +
4172 +1:     mov.l @r4, r0      ! non-default environment
4173 +2:     lds r0, fpscr
4174 +       rts
4175 +        mov #0, r0
4176 +
4177 +#endif
4178 --- a/src/fenv/sh/fenv.s
4179 +++ /dev/null
4180 @@ -1,74 +0,0 @@
4181 -.global fegetround
4182 -.type   fegetround, @function
4183 -fegetround:
4184 -       sts fpscr, r0
4185 -       rts
4186 -        and #3, r0
4187 -
4188 -.global __fesetround
4189 -.type   __fesetround, @function
4190 -__fesetround:
4191 -       sts fpscr, r0
4192 -       or  r4, r0
4193 -       lds r0, fpscr
4194 -       rts
4195 -        mov #0, r0
4196 -
4197 -.global fetestexcept
4198 -.type   fetestexcept, @function
4199 -fetestexcept:
4200 -       sts fpscr, r0
4201 -       and r4, r0
4202 -       rts
4203 -        and #0x7c, r0
4204 -
4205 -.global feclearexcept
4206 -.type   feclearexcept, @function
4207 -feclearexcept:
4208 -       mov r4, r0
4209 -       and #0x7c, r0
4210 -       not r0, r4
4211 -       sts fpscr, r0
4212 -       and r4, r0
4213 -       lds r0, fpscr
4214 -       rts
4215 -        mov #0, r0
4216 -
4217 -.global feraiseexcept
4218 -.type   feraiseexcept, @function
4219 -feraiseexcept:
4220 -       mov r4, r0
4221 -       and #0x7c, r0
4222 -       sts fpscr, r4
4223 -       or  r4, r0
4224 -       lds r0, fpscr
4225 -       rts
4226 -        mov #0, r0
4227 -
4228 -.global fegetenv
4229 -.type   fegetenv, @function
4230 -fegetenv:
4231 -       sts fpscr, r0
4232 -       mov.l r0, @r4
4233 -       rts
4234 -        mov #0, r0
4235 -
4236 -.global fesetenv
4237 -.type   fesetenv, @function
4238 -fesetenv:
4239 -       mov r4, r0
4240 -       cmp/eq #-1, r0
4241 -       bf 1f
4242 -
4243 -       ! the default environment is complicated by the fact that we need to
4244 -       ! preserve the current precision bit, which we do not know a priori
4245 -       sts fpscr, r0
4246 -       mov #8, r1
4247 -       swap.w r1, r1
4248 -       bra 2f
4249 -        and r1, r0
4250 -
4251 -1:     mov.l @r4, r0      ! non-default environment
4252 -2:     lds r0, fpscr
4253 -       rts
4254 -        mov #0, r0
4255 --- a/src/fenv/sheb-nofpu/fenv.sub
4256 +++ /dev/null
4257 @@ -1 +0,0 @@
4258 -../fenv.c
4259 --- a/src/internal/arm/syscall.s
4260 +++ b/src/internal/arm/syscall.s
4261 @@ -1,3 +1,4 @@
4262 +.syntax unified
4263  .global __syscall
4264  .hidden __syscall
4265  .type __syscall,%function
4266 @@ -11,6 +12,4 @@ __syscall:
4267         ldmfd ip,{r3,r4,r5,r6}
4268         svc 0
4269         ldmfd sp!,{r4,r5,r6,r7}
4270 -       tst lr,#1
4271 -       moveq pc,lr
4272         bx lr
4273 --- /dev/null
4274 +++ b/src/internal/atomic.h
4275 @@ -0,0 +1,275 @@
4276 +#ifndef _ATOMIC_H
4277 +#define _ATOMIC_H
4278 +
4279 +#include <stdint.h>
4280 +
4281 +#include "atomic_arch.h"
4282 +
4283 +#ifdef a_ll
4284 +
4285 +#ifndef a_pre_llsc
4286 +#define a_pre_llsc()
4287 +#endif
4288 +
4289 +#ifndef a_post_llsc
4290 +#define a_post_llsc()
4291 +#endif
4292 +
4293 +#ifndef a_cas
4294 +#define a_cas a_cas
4295 +static inline int a_cas(volatile int *p, int t, int s)
4296 +{
4297 +       int old;
4298 +       a_pre_llsc();
4299 +       do old = a_ll(p);
4300 +       while (old==t && !a_sc(p, s));
4301 +       a_post_llsc();
4302 +       return old;
4303 +}
4304 +#endif
4305 +
4306 +#ifndef a_swap
4307 +#define a_swap a_swap
4308 +static inline int a_swap(volatile int *p, int v)
4309 +{
4310 +       int old;
4311 +       a_pre_llsc();
4312 +       do old = a_ll(p);
4313 +       while (!a_sc(p, v));
4314 +       a_post_llsc();
4315 +       return old;
4316 +}
4317 +#endif
4318 +
4319 +#ifndef a_fetch_add
4320 +#define a_fetch_add a_fetch_add
4321 +static inline int a_fetch_add(volatile int *p, int v)
4322 +{
4323 +       int old;
4324 +       a_pre_llsc();
4325 +       do old = a_ll(p);
4326 +       while (!a_sc(p, (unsigned)old + v));
4327 +       a_post_llsc();
4328 +       return old;
4329 +}
4330 +#endif
4331 +
4332 +#ifndef a_fetch_and
4333 +#define a_fetch_and a_fetch_and
4334 +static inline int a_fetch_and(volatile int *p, int v)
4335 +{
4336 +       int old;
4337 +       a_pre_llsc();
4338 +       do old = a_ll(p);
4339 +       while (!a_sc(p, old & v));
4340 +       a_post_llsc();
4341 +       return old;
4342 +}
4343 +#endif
4344 +
4345 +#ifndef a_fetch_or
4346 +#define a_fetch_or a_fetch_or
4347 +static inline int a_fetch_or(volatile int *p, int v)
4348 +{
4349 +       int old;
4350 +       a_pre_llsc();
4351 +       do old = a_ll(p);
4352 +       while (!a_sc(p, old | v));
4353 +       a_post_llsc();
4354 +       return old;
4355 +}
4356 +#endif
4357 +
4358 +#endif
4359 +
4360 +#ifndef a_cas
4361 +#error missing definition of a_cas
4362 +#endif
4363 +
4364 +#ifndef a_swap
4365 +#define a_swap a_swap
4366 +static inline int a_swap(volatile int *p, int v)
4367 +{
4368 +       int old;
4369 +       do old = *p;
4370 +       while (a_cas(p, old, v) != old);
4371 +       return old;
4372 +}
4373 +#endif
4374 +
4375 +#ifndef a_fetch_add
4376 +#define a_fetch_add a_fetch_add
4377 +static inline int a_fetch_add(volatile int *p, int v)
4378 +{
4379 +       int old;
4380 +       do old = *p;
4381 +       while (a_cas(p, old, (unsigned)old+v) != old);
4382 +       return old;
4383 +}
4384 +#endif
4385 +
4386 +#ifndef a_fetch_and
4387 +#define a_fetch_and a_fetch_and
4388 +static inline int a_fetch_and(volatile int *p, int v)
4389 +{
4390 +       int old;
4391 +       do old = *p;
4392 +       while (a_cas(p, old, old&v) != old);
4393 +       return old;
4394 +}
4395 +#endif
4396 +#ifndef a_fetch_or
4397 +#define a_fetch_or a_fetch_or
4398 +static inline int a_fetch_or(volatile int *p, int v)
4399 +{
4400 +       int old;
4401 +       do old = *p;
4402 +       while (a_cas(p, old, old|v) != old);
4403 +       return old;
4404 +}
4405 +#endif
4406 +
4407 +#ifndef a_and
4408 +#define a_and a_and
4409 +static inline void a_and(volatile int *p, int v)
4410 +{
4411 +       a_fetch_and(p, v);
4412 +}
4413 +#endif
4414 +
4415 +#ifndef a_or
4416 +#define a_or a_or
4417 +static inline void a_or(volatile int *p, int v)
4418 +{
4419 +       a_fetch_or(p, v);
4420 +}
4421 +#endif
4422 +
4423 +#ifndef a_inc
4424 +#define a_inc a_inc
4425 +static inline void a_inc(volatile int *p)
4426 +{
4427 +       a_fetch_add(p, 1);
4428 +}
4429 +#endif
4430 +
4431 +#ifndef a_dec
4432 +#define a_dec a_dec
4433 +static inline void a_dec(volatile int *p)
4434 +{
4435 +       a_fetch_add(p, -1);
4436 +}
4437 +#endif
4438 +
4439 +#ifndef a_store
4440 +#define a_store a_store
4441 +static inline void a_store(volatile int *p, int v)
4442 +{
4443 +#ifdef a_barrier
4444 +       a_barrier();
4445 +       *p = v;
4446 +       a_barrier();
4447 +#else
4448 +       a_swap(p, v);
4449 +#endif
4450 +}
4451 +#endif
4452 +
4453 +#ifndef a_barrier
4454 +#define a_barrier a_barrier
4455 +static void a_barrier()
4456 +{
4457 +       volatile int tmp = 0;
4458 +       a_cas(&tmp, 0, 0);
4459 +}
4460 +#endif
4461 +
4462 +#ifndef a_spin
4463 +#define a_spin a_barrier
4464 +#endif
4465 +
4466 +#ifndef a_and_64
4467 +#define a_and_64 a_and_64
4468 +static inline void a_and_64(volatile uint64_t *p, uint64_t v)
4469 +{
4470 +       union { uint64_t v; uint32_t r[2]; } u = { v };
4471 +       if (u.r[0]+1) a_and((int *)p, u.r[0]);
4472 +       if (u.r[1]+1) a_and((int *)p+1, u.r[1]);
4473 +}
4474 +#endif
4475 +
4476 +#ifndef a_or_64
4477 +#define a_or_64 a_or_64
4478 +static inline void a_or_64(volatile uint64_t *p, uint64_t v)
4479 +{
4480 +       union { uint64_t v; uint32_t r[2]; } u = { v };
4481 +       if (u.r[0]) a_or((int *)p, u.r[0]);
4482 +       if (u.r[1]) a_or((int *)p+1, u.r[1]);
4483 +}
4484 +#endif
4485 +
4486 +#ifndef a_cas_p
4487 +#define a_cas_p a_cas_p
4488 +static inline void *a_cas_p(volatile void *p, void *t, void *s)
4489 +{
4490 +       return (void *)a_cas((volatile int *)p, (int)t, (int)s);
4491 +}
4492 +#endif
4493 +
4494 +#ifndef a_or_l
4495 +#define a_or_l a_or_l
4496 +static inline void a_or_l(volatile void *p, long v)
4497 +{
4498 +       if (sizeof(long) == sizeof(int)) a_or(p, v);
4499 +       else a_or_64(p, v);
4500 +}
4501 +#endif
4502 +
4503 +#ifndef a_crash
4504 +#define a_crash a_crash
4505 +static inline void a_crash()
4506 +{
4507 +       *(volatile char *)0=0;
4508 +}
4509 +#endif
4510 +
4511 +#ifndef a_ctz_64
4512 +#define a_ctz_64 a_ctz_64
4513 +static inline int a_ctz_64(uint64_t x)
4514 +{
4515 +       static const char debruijn64[64] = {
4516 +               0, 1, 2, 53, 3, 7, 54, 27, 4, 38, 41, 8, 34, 55, 48, 28,
4517 +               62, 5, 39, 46, 44, 42, 22, 9, 24, 35, 59, 56, 49, 18, 29, 11,
4518 +               63, 52, 6, 26, 37, 40, 33, 47, 61, 45, 43, 21, 23, 58, 17, 10,
4519 +               51, 25, 36, 32, 60, 20, 57, 16, 50, 31, 19, 15, 30, 14, 13, 12
4520 +       };
4521 +       static const char debruijn32[32] = {
4522 +               0, 1, 23, 2, 29, 24, 19, 3, 30, 27, 25, 11, 20, 8, 4, 13,
4523 +               31, 22, 28, 18, 26, 10, 7, 12, 21, 17, 9, 6, 16, 5, 15, 14
4524 +       };
4525 +       if (sizeof(long) < 8) {
4526 +               uint32_t y = x;
4527 +               if (!y) {
4528 +                       y = x>>32;
4529 +                       return 32 + debruijn32[(y&-y)*0x076be629 >> 27];
4530 +               }
4531 +               return debruijn32[(y&-y)*0x076be629 >> 27];
4532 +       }
4533 +       return debruijn64[(x&-x)*0x022fdd63cc95386dull >> 58];
4534 +}
4535 +#endif
4536 +
4537 +#ifndef a_ctz_l
4538 +#define a_ctz_l a_ctz_l
4539 +static inline int a_ctz_l(unsigned long x)
4540 +{
4541 +       static const char debruijn32[32] = {
4542 +               0, 1, 23, 2, 29, 24, 19, 3, 30, 27, 25, 11, 20, 8, 4, 13,
4543 +               31, 22, 28, 18, 26, 10, 7, 12, 21, 17, 9, 6, 16, 5, 15, 14
4544 +       };
4545 +       if (sizeof(long) == 8) return a_ctz_64(x);
4546 +       return debruijn32[(x&-x)*0x076be629 >> 27];
4547 +}
4548 +#endif
4549 +
4550 +#endif
4551 --- a/src/internal/dynlink.h
4552 +++ b/src/internal/dynlink.h
4553 @@ -64,6 +64,10 @@ struct fdpic_dummy_loadmap {
4554  #define DL_FDPIC 0
4555  #endif
4556
4557 +#ifndef DL_NOMMU_SUPPORT
4558 +#define DL_NOMMU_SUPPORT 0
4559 +#endif
4560 +
4561  #if !DL_FDPIC
4562  #define IS_RELATIVE(x,s) ( \
4563         (R_TYPE(x) == REL_RELATIVE) || \
4564 --- a/src/internal/libc.h
4565 +++ b/src/internal/libc.h
4566 @@ -11,13 +11,20 @@ struct __locale_struct {
4567         const struct __locale_map *volatile cat[6];
4568  };
4569
4570 +struct tls_module {
4571 +       struct tls_module *next;
4572 +       void *image;
4573 +       size_t len, size, align, offset;
4574 +};
4575 +
4576  struct __libc {
4577         int can_do_threads;
4578         int threaded;
4579         int secure;
4580         volatile int threads_minus_1;
4581         size_t *auxv;
4582 -       size_t tls_size;
4583 +       struct tls_module *tls_head;
4584 +       size_t tls_size, tls_align, tls_cnt;
4585         size_t page_size;
4586         struct __locale_struct global_locale;
4587  };
4588 --- a/src/internal/syscall.h
4589 +++ b/src/internal/syscall.h
4590 @@ -17,9 +17,7 @@
4591  typedef long syscall_arg_t;
4592  #endif
4593
4594 -#ifdef SHARED
4595  __attribute__((visibility("hidden")))
4596 -#endif
4597  long __syscall_ret(unsigned long), __syscall(syscall_arg_t, ...),
4598         __syscall_cp(syscall_arg_t, syscall_arg_t, syscall_arg_t, syscall_arg_t,
4599                      syscall_arg_t, syscall_arg_t, syscall_arg_t);
4600 --- a/src/internal/version.c
4601 +++ b/src/internal/version.c
4602 @@ -1,12 +1,9 @@
4603 -#ifdef SHARED
4604 -
4605  #include "version.h"
4606
4607  static const char version[] = VERSION;
4608
4609 +__attribute__((__visibility__("hidden")))
4610  const char *__libc_get_version()
4611  {
4612         return version;
4613  }
4614 -
4615 -#endif
4616 --- a/src/internal/vis.h
4617 +++ b/src/internal/vis.h
4618 @@ -4,10 +4,9 @@
4619   * override default visibilities to reduce the size and performance costs
4620   * of position-independent code. */
4621
4622 -#ifndef CRT
4623 -#ifdef SHARED
4624 +#if !defined(CRT) && !defined(__ASSEMBLER__)
4625
4626 -/* For shared libc.so, all symbols should be protected, but some toolchains
4627 +/* Conceptually, all symbols should be protected, but some toolchains
4628   * fail to support copy relocations for protected data, so exclude all
4629   * exported data symbols. */
4630
4631 @@ -25,16 +24,4 @@ extern char *optarg, **environ, **__envi
4632
4633  #pragma GCC visibility push(protected)
4634
4635 -#elif defined(__PIC__)
4636 -
4637 -/* If building static libc.a as position-independent code, try to make
4638 - * everything hidden except possibly-undefined weak references. */
4639 -
4640 -__attribute__((__visibility__("default")))
4641 -extern void (*const __init_array_start)(), (*const __init_array_end)(),
4642 -       (*const __fini_array_start)(), (*const __fini_array_end)();
4643 -
4644 -#pragma GCC visibility push(hidden)
4645 -
4646 -#endif
4647  #endif
4648 --- a/src/ldso/arm/dlsym.s
4649 +++ b/src/ldso/arm/dlsym.s
4650 @@ -1,3 +1,4 @@
4651 +.syntax unified
4652  .text
4653  .global dlsym
4654  .hidden __dlsym
4655 --- /dev/null
4656 +++ b/src/ldso/arm/find_exidx.c
4657 @@ -0,0 +1,42 @@
4658 +#define _GNU_SOURCE
4659 +#include <link.h>
4660 +#include <stdint.h>
4661 +
4662 +struct find_exidx_data {
4663 +       uintptr_t pc, exidx_start;
4664 +       int exidx_len;
4665 +};
4666 +
4667 +static int find_exidx(struct dl_phdr_info *info, size_t size, void *ptr)
4668 +{
4669 +       struct find_exidx_data *data = ptr;
4670 +       const ElfW(Phdr) *phdr = info->dlpi_phdr;
4671 +       uintptr_t addr, exidx_start = 0;
4672 +       int i, match = 0, exidx_len = 0;
4673 +
4674 +       for (i = info->dlpi_phnum; i > 0; i--, phdr++) {
4675 +               addr = info->dlpi_addr + phdr->p_vaddr;
4676 +               switch (phdr->p_type) {
4677 +               case PT_LOAD:
4678 +                       match |= data->pc >= addr && data->pc < addr + phdr->p_memsz;
4679 +                       break;
4680 +               case PT_ARM_EXIDX:
4681 +                       exidx_start = addr;
4682 +                       exidx_len = phdr->p_memsz;
4683 +                       break;
4684 +               }
4685 +       }
4686 +       data->exidx_start = exidx_start;
4687 +       data->exidx_len = exidx_len;
4688 +       return match;
4689 +}
4690 +
4691 +uintptr_t __gnu_Unwind_Find_exidx(uintptr_t pc, int *pcount)
4692 +{
4693 +       struct find_exidx_data data;
4694 +       data.pc = pc;
4695 +       if (dl_iterate_phdr(find_exidx, &data) <= 0)
4696 +               return 0;
4697 +       *pcount = data.exidx_len / 8;
4698 +       return data.exidx_start;
4699 +}
4700 --- a/src/ldso/dynlink.c
4701 +++ b/src/ldso/dynlink.c
4702 @@ -70,8 +70,8 @@ struct dso {
4703         char kernel_mapped;
4704         struct dso **deps, *needed_by;
4705         char *rpath_orig, *rpath;
4706 -       void *tls_image;
4707 -       size_t tls_len, tls_size, tls_align, tls_id, tls_offset;
4708 +       struct tls_module tls;
4709 +       size_t tls_id;
4710         size_t relro_start, relro_end;
4711         void **new_dtv;
4712         unsigned char *new_tls;
4713 @@ -99,7 +99,9 @@ struct symdef {
4714
4715  int __init_tp(void *);
4716  void __init_libc(char **, char *);
4717 +void *__copy_tls(unsigned char *);
4718
4719 +__attribute__((__visibility__("hidden")))
4720  const char *__libc_get_version(void);
4721
4722  static struct builtin_tls {
4723 @@ -123,6 +125,7 @@ static int noload;
4724  static jmp_buf *rtld_fail;
4725  static pthread_rwlock_t lock;
4726  static struct debug debug;
4727 +static struct tls_module *tls_tail;
4728  static size_t tls_cnt, tls_offset, tls_align = MIN_TLS_ALIGN;
4729  static size_t static_tls_cnt;
4730  static pthread_mutex_t init_fini_lock = { ._m_type = PTHREAD_MUTEX_RECURSIVE };
4731 @@ -131,6 +134,15 @@ static struct fdpic_dummy_loadmap app_du
4732
4733  struct debug *_dl_debug_addr = &debug;
4734
4735 +__attribute__((__visibility__("hidden")))
4736 +void (*const __init_array_start)(void)=0, (*const __fini_array_start)(void)=0;
4737 +
4738 +__attribute__((__visibility__("hidden")))
4739 +extern void (*const __init_array_end)(void), (*const __fini_array_end)(void);
4740 +
4741 +weak_alias(__init_array_start, __init_array_end);
4742 +weak_alias(__fini_array_start, __fini_array_end);
4743 +
4744  static int dl_strcmp(const char *l, const char *r)
4745  {
4746         for (; *l==*r && *l; l++, r++);
4747 @@ -397,14 +409,14 @@ static void do_relocs(struct dso *dso, s
4748                         break;
4749  #ifdef TLS_ABOVE_TP
4750                 case REL_TPOFF:
4751 -                       *reloc_addr = tls_val + def.dso->tls_offset + TPOFF_K + addend;
4752 +                       *reloc_addr = tls_val + def.dso->tls.offset + TPOFF_K + addend;
4753                         break;
4754  #else
4755                 case REL_TPOFF:
4756 -                       *reloc_addr = tls_val - def.dso->tls_offset + addend;
4757 +                       *reloc_addr = tls_val - def.dso->tls.offset + addend;
4758                         break;
4759                 case REL_TPOFF_NEG:
4760 -                       *reloc_addr = def.dso->tls_offset - tls_val + addend;
4761 +                       *reloc_addr = def.dso->tls.offset - tls_val + addend;
4762                         break;
4763  #endif
4764                 case REL_TLSDESC:
4765 @@ -426,10 +438,10 @@ static void do_relocs(struct dso *dso, s
4766                         } else {
4767                                 reloc_addr[0] = (size_t)__tlsdesc_static;
4768  #ifdef TLS_ABOVE_TP
4769 -                               reloc_addr[1] = tls_val + def.dso->tls_offset
4770 +                               reloc_addr[1] = tls_val + def.dso->tls.offset
4771                                         + TPOFF_K + addend;
4772  #else
4773 -                               reloc_addr[1] = tls_val - def.dso->tls_offset
4774 +                               reloc_addr[1] = tls_val - def.dso->tls.offset
4775                                         + addend;
4776  #endif
4777                         }
4778 @@ -482,8 +494,14 @@ static void reclaim_gaps(struct dso *dso
4779
4780  static void *mmap_fixed(void *p, size_t n, int prot, int flags, int fd, off_t off)
4781  {
4782 -       char *q = mmap(p, n, prot, flags, fd, off);
4783 -       if (q != MAP_FAILED || errno != EINVAL) return q;
4784 +       static int no_map_fixed;
4785 +       char *q;
4786 +       if (!no_map_fixed) {
4787 +               q = mmap(p, n, prot, flags|MAP_FIXED, fd, off);
4788 +               if (!DL_NOMMU_SUPPORT || q != MAP_FAILED || errno != EINVAL)
4789 +                       return q;
4790 +               no_map_fixed = 1;
4791 +       }
4792         /* Fallbacks for MAP_FIXED failure on NOMMU kernels. */
4793         if (flags & MAP_ANONYMOUS) {
4794                 memset(p, 0, n);
4795 @@ -561,9 +579,9 @@ static void *map_library(int fd, struct
4796                         dyn = ph->p_vaddr;
4797                 } else if (ph->p_type == PT_TLS) {
4798                         tls_image = ph->p_vaddr;
4799 -                       dso->tls_align = ph->p_align;
4800 -                       dso->tls_len = ph->p_filesz;
4801 -                       dso->tls_size = ph->p_memsz;
4802 +                       dso->tls.align = ph->p_align;
4803 +                       dso->tls.len = ph->p_filesz;
4804 +                       dso->tls.size = ph->p_memsz;
4805                 } else if (ph->p_type == PT_GNU_RELRO) {
4806                         dso->relro_start = ph->p_vaddr & -PAGE_SIZE;
4807                         dso->relro_end = (ph->p_vaddr + ph->p_memsz) & -PAGE_SIZE;
4808 @@ -593,7 +611,7 @@ static void *map_library(int fd, struct
4809                                 ((ph->p_flags&PF_W) ? PROT_WRITE: 0) |
4810                                 ((ph->p_flags&PF_X) ? PROT_EXEC : 0));
4811                         map = mmap(0, ph->p_memsz + (ph->p_vaddr & PAGE_SIZE-1),
4812 -                               prot, (prot&PROT_WRITE) ? MAP_PRIVATE : MAP_SHARED,
4813 +                               prot, MAP_PRIVATE,
4814                                 fd, ph->p_offset & -PAGE_SIZE);
4815                         if (map == MAP_FAILED) {
4816                                 unmap_library(dso);
4817 @@ -604,6 +622,19 @@ static void *map_library(int fd, struct
4818                         dso->loadmap->segs[i].p_vaddr = ph->p_vaddr;
4819                         dso->loadmap->segs[i].p_memsz = ph->p_memsz;
4820                         i++;
4821 +                       if (prot & PROT_WRITE) {
4822 +                               size_t brk = (ph->p_vaddr & PAGE_SIZE-1)
4823 +                                       + ph->p_filesz;
4824 +                               size_t pgbrk = brk + PAGE_SIZE-1 & -PAGE_SIZE;
4825 +                               size_t pgend = brk + ph->p_memsz - ph->p_filesz
4826 +                                       + PAGE_SIZE-1 & -PAGE_SIZE;
4827 +                               if (pgend > pgbrk && mmap_fixed(map+pgbrk,
4828 +                                       pgend-pgbrk, prot,
4829 +                                       MAP_PRIVATE|MAP_FIXED|MAP_ANONYMOUS,
4830 +                                       -1, off_start) == MAP_FAILED)
4831 +                                       goto error;
4832 +                               memset(map + brk, 0, pgbrk-brk);
4833 +                       }
4834                 }
4835                 map = (void *)dso->loadmap->segs[0].addr;
4836                 map_len = 0;
4837 @@ -618,7 +649,11 @@ static void *map_library(int fd, struct
4838          * the length of the file. This is okay because we will not
4839          * use the invalid part; we just need to reserve the right
4840          * amount of virtual address space to map over later. */
4841 -       map = mmap((void *)addr_min, map_len, prot, MAP_PRIVATE, fd, off_start);
4842 +       map = DL_NOMMU_SUPPORT
4843 +               ? mmap((void *)addr_min, map_len, PROT_READ|PROT_WRITE|PROT_EXEC,
4844 +                       MAP_PRIVATE|MAP_ANONYMOUS, -1, 0)
4845 +               : mmap((void *)addr_min, map_len, prot,
4846 +                       MAP_PRIVATE, fd, off_start);
4847         if (map==MAP_FAILED) goto error;
4848         dso->map = map;
4849         dso->map_len = map_len;
4850 @@ -643,7 +678,8 @@ static void *map_library(int fd, struct
4851                         dso->phentsize = eh->e_phentsize;
4852                 }
4853                 /* Reuse the existing mapping for the lowest-address LOAD */
4854 -               if ((ph->p_vaddr & -PAGE_SIZE) == addr_min) continue;
4855 +               if ((ph->p_vaddr & -PAGE_SIZE) == addr_min && !DL_NOMMU_SUPPORT)
4856 +                       continue;
4857                 this_min = ph->p_vaddr & -PAGE_SIZE;
4858                 this_max = ph->p_vaddr+ph->p_memsz+PAGE_SIZE-1 & -PAGE_SIZE;
4859                 off_start = ph->p_offset & -PAGE_SIZE;
4860 @@ -670,7 +706,7 @@ static void *map_library(int fd, struct
4861  done_mapping:
4862         dso->base = base;
4863         dso->dynv = laddr(dso, dyn);
4864 -       if (dso->tls_size) dso->tls_image = laddr(dso, tls_image);
4865 +       if (dso->tls.size) dso->tls.image = laddr(dso, tls_image);
4866         if (!runtime) reclaim_gaps(dso);
4867         free(allocated_buf);
4868         return map;
4869 @@ -987,8 +1023,8 @@ static struct dso *load_library(const ch
4870          * extended DTV capable of storing an additional slot for
4871          * the newly-loaded DSO. */
4872         alloc_size = sizeof *p + strlen(pathname) + 1;
4873 -       if (runtime && temp_dso.tls_image) {
4874 -               size_t per_th = temp_dso.tls_size + temp_dso.tls_align
4875 +       if (runtime && temp_dso.tls.image) {
4876 +               size_t per_th = temp_dso.tls.size + temp_dso.tls.align
4877                         + sizeof(void *) * (tls_cnt+3);
4878                 n_th = libc.threads_minus_1 + 1;
4879                 if (n_th > SSIZE_MAX / per_th) alloc_size = SIZE_MAX;
4880 @@ -1009,22 +1045,25 @@ static struct dso *load_library(const ch
4881         strcpy(p->name, pathname);
4882         /* Add a shortname only if name arg was not an explicit pathname. */
4883         if (pathname != name) p->shortname = strrchr(p->name, '/')+1;
4884 -       if (p->tls_image) {
4885 +       if (p->tls.image) {
4886                 p->tls_id = ++tls_cnt;
4887 -               tls_align = MAXP2(tls_align, p->tls_align);
4888 +               tls_align = MAXP2(tls_align, p->tls.align);
4889  #ifdef TLS_ABOVE_TP
4890 -               p->tls_offset = tls_offset + ( (tls_align-1) &
4891 -                       -(tls_offset + (uintptr_t)p->tls_image) );
4892 -               tls_offset += p->tls_size;
4893 +               p->tls.offset = tls_offset + ( (tls_align-1) &
4894 +                       -(tls_offset + (uintptr_t)p->tls.image) );
4895 +               tls_offset += p->tls.size;
4896  #else
4897 -               tls_offset += p->tls_size + p->tls_align - 1;
4898 -               tls_offset -= (tls_offset + (uintptr_t)p->tls_image)
4899 -                       & (p->tls_align-1);
4900 -               p->tls_offset = tls_offset;
4901 +               tls_offset += p->tls.size + p->tls.align - 1;
4902 +               tls_offset -= (tls_offset + (uintptr_t)p->tls.image)
4903 +                       & (p->tls.align-1);
4904 +               p->tls.offset = tls_offset;
4905  #endif
4906                 p->new_dtv = (void *)(-sizeof(size_t) &
4907                         (uintptr_t)(p->name+strlen(p->name)+sizeof(size_t)));
4908                 p->new_tls = (void *)(p->new_dtv + n_th*(tls_cnt+1));
4909 +               if (tls_tail) tls_tail->next = &p->tls;
4910 +               else libc.tls_head = &p->tls;
4911 +               tls_tail = &p->tls;
4912         }
4913
4914         tail->next = p;
4915 @@ -1151,7 +1190,7 @@ static void kernel_mapped_dso(struct dso
4916         p->kernel_mapped = 1;
4917  }
4918
4919 -static void do_fini()
4920 +void __libc_exit_fini()
4921  {
4922         struct dso *p;
4923         size_t dyn[DYN_CNT];
4924 @@ -1214,53 +1253,8 @@ static void dl_debug_state(void)
4925
4926  weak_alias(dl_debug_state, _dl_debug_state);
4927
4928 -void __reset_tls()
4929 +void __init_tls(size_t *auxv)
4930  {
4931 -       pthread_t self = __pthread_self();
4932 -       struct dso *p;
4933 -       for (p=head; p; p=p->next) {
4934 -               if (!p->tls_id || !self->dtv[p->tls_id]) continue;
4935 -               memcpy(self->dtv[p->tls_id], p->tls_image, p->tls_len);
4936 -               memset((char *)self->dtv[p->tls_id]+p->tls_len, 0,
4937 -                       p->tls_size - p->tls_len);
4938 -               if (p->tls_id == (size_t)self->dtv[0]) break;
4939 -       }
4940 -}
4941 -
4942 -void *__copy_tls(unsigned char *mem)
4943 -{
4944 -       pthread_t td;
4945 -       struct dso *p;
4946 -       void **dtv;
4947 -
4948 -#ifdef TLS_ABOVE_TP
4949 -       dtv = (void **)(mem + libc.tls_size) - (tls_cnt + 1);
4950 -
4951 -       mem += -((uintptr_t)mem + sizeof(struct pthread)) & (tls_align-1);
4952 -       td = (pthread_t)mem;
4953 -       mem += sizeof(struct pthread);
4954 -
4955 -       for (p=head; p; p=p->next) {
4956 -               if (!p->tls_id) continue;
4957 -               dtv[p->tls_id] = mem + p->tls_offset;
4958 -               memcpy(dtv[p->tls_id], p->tls_image, p->tls_len);
4959 -       }
4960 -#else
4961 -       dtv = (void **)mem;
4962 -
4963 -       mem += libc.tls_size - sizeof(struct pthread);
4964 -       mem -= (uintptr_t)mem & (tls_align-1);
4965 -       td = (pthread_t)mem;
4966 -
4967 -       for (p=head; p; p=p->next) {
4968 -               if (!p->tls_id) continue;
4969 -               dtv[p->tls_id] = mem - p->tls_offset;
4970 -               memcpy(dtv[p->tls_id], p->tls_image, p->tls_len);
4971 -       }
4972 -#endif
4973 -       dtv[0] = (void *)tls_cnt;
4974 -       td->dtv = td->dtv_copy = dtv;
4975 -       return td;
4976  }
4977
4978  __attribute__((__visibility__("hidden")))
4979 @@ -1286,7 +1280,7 @@ void *__tls_get_new(size_t *v)
4980         /* Get new DTV space from new DSO if needed */
4981         if (v[0] > (size_t)self->dtv[0]) {
4982                 void **newdtv = p->new_dtv +
4983 -                       (v[0]+1)*sizeof(void *)*a_fetch_add(&p->new_dtv_idx,1);
4984 +                       (v[0]+1)*a_fetch_add(&p->new_dtv_idx,1);
4985                 memcpy(newdtv, self->dtv,
4986                         ((size_t)self->dtv[0]+1) * sizeof(void *));
4987                 newdtv[0] = (void *)v[0];
4988 @@ -1297,12 +1291,12 @@ void *__tls_get_new(size_t *v)
4989         unsigned char *mem;
4990         for (p=head; ; p=p->next) {
4991                 if (!p->tls_id || self->dtv[p->tls_id]) continue;
4992 -               mem = p->new_tls + (p->tls_size + p->tls_align)
4993 +               mem = p->new_tls + (p->tls.size + p->tls.align)
4994                         * a_fetch_add(&p->new_tls_idx,1);
4995 -               mem += ((uintptr_t)p->tls_image - (uintptr_t)mem)
4996 -                       & (p->tls_align-1);
4997 +               mem += ((uintptr_t)p->tls.image - (uintptr_t)mem)
4998 +                       & (p->tls.align-1);
4999                 self->dtv[p->tls_id] = mem;
5000 -               memcpy(mem, p->tls_image, p->tls_len);
5001 +               memcpy(mem, p->tls.image, p->tls.len);
5002                 if (p->tls_id == v[0]) break;
5003         }
5004         __restore_sigs(&set);
5005 @@ -1311,6 +1305,8 @@ void *__tls_get_new(size_t *v)
5006
5007  static void update_tls_size()
5008  {
5009 +       libc.tls_cnt = tls_cnt;
5010 +       libc.tls_align = tls_align;
5011         libc.tls_size = ALIGN(
5012                 (1+tls_cnt) * sizeof(void *) +
5013                 tls_offset +
5014 @@ -1421,6 +1417,7 @@ _Noreturn void __dls3(size_t *sp)
5015          * use during dynamic linking. If possible it will also serve as the
5016          * thread pointer at runtime. */
5017         libc.tls_size = sizeof builtin_tls;
5018 +       libc.tls_align = tls_align;
5019         if (__init_tp(__copy_tls((void *)builtin_tls)) < 0) {
5020                 a_crash();
5021         }
5022 @@ -1448,13 +1445,13 @@ _Noreturn void __dls3(size_t *sp)
5023                                 interp_off = (size_t)phdr->p_vaddr;
5024                         else if (phdr->p_type == PT_TLS) {
5025                                 tls_image = phdr->p_vaddr;
5026 -                               app.tls_len = phdr->p_filesz;
5027 -                               app.tls_size = phdr->p_memsz;
5028 -                               app.tls_align = phdr->p_align;
5029 +                               app.tls.len = phdr->p_filesz;
5030 +                               app.tls.size = phdr->p_memsz;
5031 +                               app.tls.align = phdr->p_align;
5032                         }
5033                 }
5034                 if (DL_FDPIC) app.loadmap = app_loadmap;
5035 -               if (app.tls_size) app.tls_image = laddr(&app, tls_image);
5036 +               if (app.tls.size) app.tls.image = laddr(&app, tls_image);
5037                 if (interp_off) ldso.name = laddr(&app, interp_off);
5038                 if ((aux[0] & (1UL<<AT_EXECFN))
5039                     && strncmp((char *)aux[AT_EXECFN], "/proc/", 6))
5040 @@ -1523,19 +1520,20 @@ _Noreturn void __dls3(size_t *sp)
5041                         dprintf(1, "\t%s (%p)\n", ldso.name, ldso.base);
5042                 }
5043         }
5044 -       if (app.tls_size) {
5045 +       if (app.tls.size) {
5046 +               libc.tls_head = &app.tls;
5047                 app.tls_id = tls_cnt = 1;
5048  #ifdef TLS_ABOVE_TP
5049 -               app.tls_offset = 0;
5050 -               tls_offset = app.tls_size
5051 -                       + ( -((uintptr_t)app.tls_image + app.tls_size)
5052 -                       & (app.tls_align-1) );
5053 +               app.tls.offset = 0;
5054 +               tls_offset = app.tls.size
5055 +                       + ( -((uintptr_t)app.tls.image + app.tls.size)
5056 +                       & (app.tls.align-1) );
5057  #else
5058 -               tls_offset = app.tls_offset = app.tls_size
5059 -                       + ( -((uintptr_t)app.tls_image + app.tls_size)
5060 -                       & (app.tls_align-1) );
5061 +               tls_offset = app.tls.offset = app.tls.size
5062 +                       + ( -((uintptr_t)app.tls.image + app.tls.size)
5063 +                       & (app.tls.align-1) );
5064  #endif
5065 -               tls_align = MAXP2(tls_align, app.tls_align);
5066 +               tls_align = MAXP2(tls_align, app.tls.align);
5067         }
5068         app.global = 1;
5069         decode_dyn(&app);
5070 @@ -1635,8 +1633,6 @@ _Noreturn void __dls3(size_t *sp)
5071         debug.state = 0;
5072         _dl_debug_state();
5073
5074 -       __init_libc(envp, argv[0]);
5075 -       atexit(do_fini);
5076         errno = 0;
5077
5078         CRTJMP((void *)aux[AT_ENTRY], argv-1);
5079 @@ -1646,6 +1642,7 @@ _Noreturn void __dls3(size_t *sp)
5080  void *dlopen(const char *file, int mode)
5081  {
5082         struct dso *volatile p, *orig_tail, *next;
5083 +       struct tls_module *orig_tls_tail;
5084         size_t orig_tls_cnt, orig_tls_offset, orig_tls_align;
5085         size_t i;
5086         int cs;
5087 @@ -1658,6 +1655,7 @@ void *dlopen(const char *file, int mode)
5088         __inhibit_ptc();
5089
5090         p = 0;
5091 +       orig_tls_tail = tls_tail;
5092         orig_tls_cnt = tls_cnt;
5093         orig_tls_offset = tls_offset;
5094         orig_tls_align = tls_align;
5095 @@ -1684,6 +1682,8 @@ void *dlopen(const char *file, int mode)
5096                         unmap_library(p);
5097                         free(p);
5098                 }
5099 +               if (!orig_tls_tail) libc.tls_head = 0;
5100 +               tls_tail = orig_tls_tail;
5101                 tls_cnt = orig_tls_cnt;
5102                 tls_offset = orig_tls_offset;
5103                 tls_align = orig_tls_align;
5104 @@ -1900,7 +1900,7 @@ int dl_iterate_phdr(int(*callback)(struc
5105                 info.dlpi_adds      = gencnt;
5106                 info.dlpi_subs      = 0;
5107                 info.dlpi_tls_modid = current->tls_id;
5108 -               info.dlpi_tls_data  = current->tls_image;
5109 +               info.dlpi_tls_data  = current->tls.image;
5110
5111                 ret = (callback)(&info, sizeof (info), data);
5112
5113 --- a/src/locale/langinfo.c
5114 +++ b/src/locale/langinfo.c
5115 @@ -37,23 +37,23 @@ char *__nl_langinfo_l(nl_item item, loca
5116
5117         switch (cat) {
5118         case LC_NUMERIC:
5119 -               if (idx > 1) return NULL;
5120 +               if (idx > 1) return "";
5121                 str = c_numeric;
5122                 break;
5123         case LC_TIME:
5124 -               if (idx > 0x31) return NULL;
5125 +               if (idx > 0x31) return "";
5126                 str = c_time;
5127                 break;
5128         case LC_MONETARY:
5129 -               if (idx > 0) return NULL;
5130 +               if (idx > 0) return "";
5131                 str = "";
5132                 break;
5133         case LC_MESSAGES:
5134 -               if (idx > 3) return NULL;
5135 +               if (idx > 3) return "";
5136                 str = c_messages;
5137                 break;
5138         default:
5139 -               return NULL;
5140 +               return "";
5141         }
5142
5143         for (; idx; idx--, str++) for (; *str; str++);
5144 --- a/src/malloc/lite_malloc.c
5145 +++ b/src/malloc/lite_malloc.c
5146 @@ -8,7 +8,7 @@
5147
5148  void *__expand_heap(size_t *);
5149
5150 -void *__simple_malloc(size_t n)
5151 +static void *__simple_malloc(size_t n)
5152  {
5153         static char *cur, *end;
5154         static volatile int lock[2];
5155 --- a/src/math/__rem_pio2.c
5156 +++ b/src/math/__rem_pio2.c
5157 @@ -118,7 +118,7 @@ int __rem_pio2(double x, double *y)
5158         if (ix < 0x413921fb) {  /* |x| ~< 2^20*(pi/2), medium size */
5159  medium:
5160                 /* rint(x/(pi/2)), Assume round-to-nearest. */
5161 -               fn = x*invpio2 + toint - toint;
5162 +               fn = (double_t)x*invpio2 + toint - toint;
5163                 n = (int32_t)fn;
5164                 r = x - fn*pio2_1;
5165                 w = fn*pio2_1t;  /* 1st round, good to 85 bits */
5166 --- a/src/math/__rem_pio2f.c
5167 +++ b/src/math/__rem_pio2f.c
5168 @@ -51,7 +51,7 @@ int __rem_pio2f(float x, double *y)
5169         /* 25+53 bit pi is good enough for medium size */
5170         if (ix < 0x4dc90fdb) {  /* |x| ~< 2^28*(pi/2), medium size */
5171                 /* Use a specialized rint() to get fn.  Assume round-to-nearest. */
5172 -               fn = x*invpio2 + toint - toint;
5173 +               fn = (double_t)x*invpio2 + toint - toint;
5174                 n  = (int32_t)fn;
5175                 *y = x - fn*pio2_1 - fn*pio2_1t;
5176                 return n;
5177 --- /dev/null
5178 +++ b/src/math/arm/fabs.c
5179 @@ -0,0 +1,15 @@
5180 +#include <math.h>
5181 +
5182 +#if __ARM_PCS_VFP
5183 +
5184 +double fabs(double x)
5185 +{
5186 +       __asm__ ("vabs.f64 %P0, %P1" : "=w"(x) : "w"(x));
5187 +       return x;
5188 +}
5189 +
5190 +#else
5191 +
5192 +#include "../fabs.c"
5193 +
5194 +#endif
5195 --- /dev/null
5196 +++ b/src/math/arm/fabsf.c
5197 @@ -0,0 +1,15 @@
5198 +#include <math.h>
5199 +
5200 +#if __ARM_PCS_VFP
5201 +
5202 +float fabsf(float x)
5203 +{
5204 +       __asm__ ("vabs.f32 %0, %1" : "=t"(x) : "t"(x));
5205 +       return x;
5206 +}
5207 +
5208 +#else
5209 +
5210 +#include "../fabsf.c"
5211 +
5212 +#endif
5213 --- /dev/null
5214 +++ b/src/math/arm/sqrt.c
5215 @@ -0,0 +1,15 @@
5216 +#include <math.h>
5217 +
5218 +#if __VFP_FP__ && !__SOFTFP__
5219 +
5220 +double sqrt(double x)
5221 +{
5222 +       __asm__ ("vsqrt.f64 %P0, %P1" : "=w"(x) : "w"(x));
5223 +       return x;
5224 +}
5225 +
5226 +#else
5227 +
5228 +#include "../sqrt.c"
5229 +
5230 +#endif
5231 --- /dev/null
5232 +++ b/src/math/arm/sqrtf.c
5233 @@ -0,0 +1,15 @@
5234 +#include <math.h>
5235 +
5236 +#if __VFP_FP__ && !__SOFTFP__
5237 +
5238 +float sqrtf(float x)
5239 +{
5240 +       __asm__ ("vsqrt.f32 %0, %1" : "=t"(x) : "t"(x));
5241 +       return x;
5242 +}
5243 +
5244 +#else
5245 +
5246 +#include "../sqrtf.c"
5247 +
5248 +#endif
5249 --- a/src/math/armebhf/fabs.sub
5250 +++ /dev/null
5251 @@ -1 +0,0 @@
5252 -../armhf/fabs.s
5253 --- a/src/math/armebhf/fabsf.sub
5254 +++ /dev/null
5255 @@ -1 +0,0 @@
5256 -../armhf/fabsf.s
5257 --- a/src/math/armebhf/sqrt.sub
5258 +++ /dev/null
5259 @@ -1 +0,0 @@
5260 -../armhf/sqrt.s
5261 --- a/src/math/armebhf/sqrtf.sub
5262 +++ /dev/null
5263 @@ -1 +0,0 @@
5264 -../armhf/sqrtf.s
5265 --- a/src/math/armhf/fabs.s
5266 +++ /dev/null
5267 @@ -1,7 +0,0 @@
5268 -.fpu vfp
5269 -.text
5270 -.global fabs
5271 -.type   fabs,%function
5272 -fabs:
5273 -       vabs.f64 d0, d0
5274 -       bx lr
5275 --- a/src/math/armhf/fabs.sub
5276 +++ /dev/null
5277 @@ -1 +0,0 @@
5278 -fabs.s
5279 --- a/src/math/armhf/fabsf.s
5280 +++ /dev/null
5281 @@ -1,7 +0,0 @@
5282 -.fpu vfp
5283 -.text
5284 -.global fabsf
5285 -.type   fabsf,%function
5286 -fabsf:
5287 -       vabs.f32 s0, s0
5288 -       bx lr
5289 --- a/src/math/armhf/fabsf.sub
5290 +++ /dev/null
5291 @@ -1 +0,0 @@
5292 -fabsf.s
5293 --- a/src/math/armhf/sqrt.s
5294 +++ /dev/null
5295 @@ -1,7 +0,0 @@
5296 -.fpu vfp
5297 -.text
5298 -.global sqrt
5299 -.type   sqrt,%function
5300 -sqrt:
5301 -       vsqrt.f64 d0, d0
5302 -       bx lr
5303 --- a/src/math/armhf/sqrt.sub
5304 +++ /dev/null
5305 @@ -1 +0,0 @@
5306 -sqrt.s
5307 --- a/src/math/armhf/sqrtf.s
5308 +++ /dev/null
5309 @@ -1,7 +0,0 @@
5310 -.fpu vfp
5311 -.text
5312 -.global sqrtf
5313 -.type   sqrtf,%function
5314 -sqrtf:
5315 -       vsqrt.f32 s0, s0
5316 -       bx lr
5317 --- a/src/math/armhf/sqrtf.sub
5318 +++ /dev/null
5319 @@ -1 +0,0 @@
5320 -sqrtf.s
5321 --- a/src/math/hypot.c
5322 +++ b/src/math/hypot.c
5323 @@ -12,10 +12,10 @@ static void sq(double_t *hi, double_t *l
5324  {
5325         double_t xh, xl, xc;
5326
5327 -       xc = x*SPLIT;
5328 +       xc = (double_t)x*SPLIT;
5329         xh = x - xc + xc;
5330         xl = x - xh;
5331 -       *hi = x*x;
5332 +       *hi = (double_t)x*x;
5333         *lo = xh*xh - *hi + 2*xh*xl + xl*xl;
5334  }
5335
5336 --- a/src/mman/mremap.c
5337 +++ b/src/mman/mremap.c
5338 @@ -1,17 +1,31 @@
5339 +#define _GNU_SOURCE
5340  #include <unistd.h>
5341  #include <sys/mman.h>
5342 +#include <errno.h>
5343 +#include <stdint.h>
5344  #include <stdarg.h>
5345  #include "syscall.h"
5346  #include "libc.h"
5347
5348 +static void dummy(void) { }
5349 +weak_alias(dummy, __vm_wait);
5350 +
5351  void *__mremap(void *old_addr, size_t old_len, size_t new_len, int flags, ...)
5352  {
5353         va_list ap;
5354 -       void *new_addr;
5355 -
5356 -       va_start(ap, flags);
5357 -       new_addr = va_arg(ap, void *);
5358 -       va_end(ap);
5359 +       void *new_addr = 0;
5360 +
5361 +       if (new_len >= PTRDIFF_MAX) {
5362 +               errno = ENOMEM;
5363 +               return MAP_FAILED;
5364 +       }
5365 +
5366 +       if (flags & MREMAP_FIXED) {
5367 +               __vm_wait();
5368 +               va_start(ap, flags);
5369 +               new_addr = va_arg(ap, void *);
5370 +               va_end(ap);
5371 +       }
5372
5373         return (void *)syscall(SYS_mremap, old_addr, old_len, new_len, flags, new_addr);
5374  }
5375 --- a/src/network/getifaddrs.c
5376 +++ b/src/network/getifaddrs.c
5377 @@ -162,13 +162,26 @@ static int netlink_msg_to_ifaddr(void *p
5378                 for (rta = NLMSG_RTA(h, sizeof(*ifa)); NLMSG_RTAOK(rta, h); rta = RTA_NEXT(rta)) {
5379                         switch (rta->rta_type) {
5380                         case IFA_ADDRESS:
5381 -                               copy_addr(&ifs->ifa.ifa_addr, ifa->ifa_family, &ifs->addr, RTA_DATA(rta), RTA_DATALEN(rta), ifa->ifa_index);
5382 +                               /* If ifa_addr is already set we, received an IFA_LOCAL before
5383 +                                * so treat this as destination address */
5384 +                               if (ifs->ifa.ifa_addr)
5385 +                                       copy_addr(&ifs->ifa.ifa_dstaddr, ifa->ifa_family, &ifs->ifu, RTA_DATA(rta), RTA_DATALEN(rta), ifa->ifa_index);
5386 +                               else
5387 +                                       copy_addr(&ifs->ifa.ifa_addr, ifa->ifa_family, &ifs->addr, RTA_DATA(rta), RTA_DATALEN(rta), ifa->ifa_index);
5388                                 break;
5389                         case IFA_BROADCAST:
5390 -                               /* For point-to-point links this is peer, but ifa_broadaddr
5391 -                                * and ifa_dstaddr are union, so this works for both.  */
5392                                 copy_addr(&ifs->ifa.ifa_broadaddr, ifa->ifa_family, &ifs->ifu, RTA_DATA(rta), RTA_DATALEN(rta), ifa->ifa_index);
5393                                 break;
5394 +                       case IFA_LOCAL:
5395 +                               /* If ifa_addr is set and we get IFA_LOCAL, assume we have
5396 +                                * a point-to-point network. Move address to correct field. */
5397 +                               if (ifs->ifa.ifa_addr) {
5398 +                                       ifs->ifu = ifs->addr;
5399 +                                       ifs->ifa.ifa_dstaddr = &ifs->ifu.sa;
5400 +                                       memset(&ifs->addr, 0, sizeof(ifs->addr));
5401 +                               }
5402 +                               copy_addr(&ifs->ifa.ifa_addr, ifa->ifa_family, &ifs->addr, RTA_DATA(rta), RTA_DATALEN(rta), ifa->ifa_index);
5403 +                               break;
5404                         case IFA_LABEL:
5405                                 if (RTA_DATALEN(rta) < sizeof(ifs->name)) {
5406                                         memcpy(ifs->name, RTA_DATA(rta), RTA_DATALEN(rta));
5407 --- a/src/network/getnameinfo.c
5408 +++ b/src/network/getnameinfo.c
5409 @@ -135,13 +135,13 @@ int getnameinfo(const struct sockaddr *r
5410         switch (af) {
5411         case AF_INET:
5412                 a = (void *)&((struct sockaddr_in *)sa)->sin_addr;
5413 -               if (sl != sizeof(struct sockaddr_in)) return EAI_FAMILY;
5414 +               if (sl < sizeof(struct sockaddr_in)) return EAI_FAMILY;
5415                 mkptr4(ptr, a);
5416                 scopeid = 0;
5417                 break;
5418         case AF_INET6:
5419                 a = (void *)&((struct sockaddr_in6 *)sa)->sin6_addr;
5420 -               if (sl != sizeof(struct sockaddr_in6)) return EAI_FAMILY;
5421 +               if (sl < sizeof(struct sockaddr_in6)) return EAI_FAMILY;
5422                 if (memcmp(a, "\0\0\0\0\0\0\0\0\0\0\xff\xff", 12))
5423                         mkptr6(ptr, a);
5424                 else
5425 --- a/src/network/if_nametoindex.c
5426 +++ b/src/network/if_nametoindex.c
5427 @@ -10,7 +10,7 @@ unsigned if_nametoindex(const char *name
5428         struct ifreq ifr;
5429         int fd, r;
5430
5431 -       if ((fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0)) < 0) return -1;
5432 +       if ((fd = socket(AF_UNIX, SOCK_DGRAM|SOCK_CLOEXEC, 0)) < 0) return 0;
5433         strncpy(ifr.ifr_name, name, sizeof ifr.ifr_name);
5434         r = ioctl(fd, SIOCGIFINDEX, &ifr);
5435         __syscall(SYS_close, fd);
5436 --- a/src/network/lookup_name.c
5437 +++ b/src/network/lookup_name.c
5438 @@ -9,6 +9,7 @@
5439  #include <fcntl.h>
5440  #include <unistd.h>
5441  #include <pthread.h>
5442 +#include <errno.h>
5443  #include "lookup.h"
5444  #include "stdio_impl.h"
5445  #include "syscall.h"
5446 @@ -51,7 +52,14 @@ static int name_from_hosts(struct addres
5447         int cnt = 0;
5448         unsigned char _buf[1032];
5449         FILE _f, *f = __fopen_rb_ca("/etc/hosts", &_f, _buf, sizeof _buf);
5450 -       if (!f) return 0;
5451 +       if (!f) switch (errno) {
5452 +       case ENOENT:
5453 +       case ENOTDIR:
5454 +       case EACCES:
5455 +               return 0;
5456 +       default:
5457 +               return EAI_SYSTEM;
5458 +       }
5459         while (fgets(line, sizeof line, f) && cnt < MAXADDRS) {
5460                 char *p, *z;
5461
5462 --- a/src/network/lookup_serv.c
5463 +++ b/src/network/lookup_serv.c
5464 @@ -4,6 +4,7 @@
5465  #include <ctype.h>
5466  #include <string.h>
5467  #include <fcntl.h>
5468 +#include <errno.h>
5469  #include "lookup.h"
5470  #include "stdio_impl.h"
5471
5472 @@ -69,7 +70,14 @@ int __lookup_serv(struct service buf[sta
5473
5474         unsigned char _buf[1032];
5475         FILE _f, *f = __fopen_rb_ca("/etc/services", &_f, _buf, sizeof _buf);
5476 -       if (!f) return EAI_SERVICE;
5477 +       if (!f) switch (errno) {
5478 +       case ENOENT:
5479 +       case ENOTDIR:
5480 +       case EACCES:
5481 +               return EAI_SERVICE;
5482 +       default:
5483 +               return EAI_SYSTEM;
5484 +       }
5485
5486         while (fgets(line, sizeof line, f) && cnt < MAXSERVS) {
5487                 if ((p=strchr(line, '#'))) *p++='\n', *p=0;
5488 --- a/src/network/proto.c
5489 +++ b/src/network/proto.c
5490 @@ -9,21 +9,36 @@ static const unsigned char protos[] = {
5491         "\001icmp\0"
5492         "\002igmp\0"
5493         "\003ggp\0"
5494 +       "\004ipencap\0"
5495 +       "\005st\0"
5496         "\006tcp\0"
5497 +       "\008egp\0"
5498         "\014pup\0"
5499         "\021udp\0"
5500 -       "\026idp\0"
5501 +       "\024hmp\0"
5502 +       "\026xns-idp\0"
5503 +       "\033rdp\0"
5504 +       "\035iso-tp4\0"
5505 +       "\044xtp\0"
5506 +       "\045ddp\0"
5507 +       "\046idpr-cmtp\0"
5508         "\051ipv6\0"
5509         "\053ipv6-route\0"
5510         "\054ipv6-frag\0"
5511 +       "\055idrp\0"
5512 +       "\056rsvp\0"
5513         "\057gre\0"
5514         "\062esp\0"
5515         "\063ah\0"
5516 +       "\071skip\0"
5517         "\072ipv6-icmp\0"
5518         "\073ipv6-nonxt\0"
5519         "\074ipv6-opts\0"
5520 +       "\111rspf\0"
5521 +       "\121vmtp\0"
5522         "\131ospf\0"
5523         "\136ipip\0"
5524 +       "\142encap\0"
5525         "\147pim\0"
5526         "\377raw"
5527  };
5528 --- a/src/network/res_msend.c
5529 +++ b/src/network/res_msend.c
5530 @@ -54,7 +54,15 @@ int __res_msend(int nqueries, const unsi
5531
5532         /* Get nameservers from resolv.conf, fallback to localhost */
5533         f = __fopen_rb_ca("/etc/resolv.conf", &_f, _buf, sizeof _buf);
5534 -       if (f) for (nns=0; nns<3 && fgets(line, sizeof line, f); ) {
5535 +       if (!f) switch (errno) {
5536 +       case ENOENT:
5537 +       case ENOTDIR:
5538 +       case EACCES:
5539 +               goto no_resolv_conf;
5540 +       default:
5541 +               return -1;
5542 +       }
5543 +       for (nns=0; nns<3 && fgets(line, sizeof line, f); ) {
5544                 if (!strncmp(line, "options", 7) && isspace(line[7])) {
5545                         unsigned long x;
5546                         char *p, *z;
5547 @@ -92,7 +100,8 @@ int __res_msend(int nqueries, const unsi
5548                         }
5549                 }
5550         }
5551 -       if (f) __fclose_ca(f);
5552 +       __fclose_ca(f);
5553 +no_resolv_conf:
5554         if (!nns) {
5555                 ns[0].sin.sin_family = AF_INET;
5556                 ns[0].sin.sin_port = htons(53);
5557 --- a/src/search/tsearch_avl.c
5558 +++ b/src/search/tsearch_avl.c
5559 @@ -77,38 +77,45 @@ static struct node *find(struct node *n,
5560                 return find(n->right, k, cmp);
5561  }
5562
5563 -static struct node *insert(struct node **n, const void *k,
5564 -       int (*cmp)(const void *, const void *), int *new)
5565 +static struct node *insert(struct node *n, const void *k,
5566 +       int (*cmp)(const void *, const void *), struct node **found)
5567  {
5568 -       struct node *r = *n;
5569 +       struct node *r;
5570         int c;
5571
5572 -       if (!r) {
5573 -               *n = r = malloc(sizeof **n);
5574 -               if (r) {
5575 -                       r->key = k;
5576 -                       r->left = r->right = 0;
5577 -                       r->height = 1;
5578 +       if (!n) {
5579 +               n = malloc(sizeof *n);
5580 +               if (n) {
5581 +                       n->key = k;
5582 +                       n->left = n->right = 0;
5583 +                       n->height = 1;
5584                 }
5585 -               *new = 1;
5586 -               return r;
5587 +               *found = n;
5588 +               return n;
5589 +       }
5590 +       c = cmp(k, n->key);
5591 +       if (c == 0) {
5592 +               *found = n;
5593 +               return 0;
5594 +       }
5595 +       r = insert(c < 0 ? n->left : n->right, k, cmp, found);
5596 +       if (r) {
5597 +               if (c < 0)
5598 +                       n->left = r;
5599 +               else
5600 +                       n->right = r;
5601 +               r = balance(n);
5602         }
5603 -       c = cmp(k, r->key);
5604 -       if (c == 0)
5605 -               return r;
5606 -       if (c < 0)
5607 -               r = insert(&r->left, k, cmp, new);
5608 -       else
5609 -               r = insert(&r->right, k, cmp, new);
5610 -       if (*new)
5611 -               *n = balance(*n);
5612         return r;
5613  }
5614
5615 -static struct node *movr(struct node *n, struct node *r) {
5616 -       if (!n)
5617 -               return r;
5618 -       n->right = movr(n->right, r);
5619 +static struct node *remove_rightmost(struct node *n, struct node **rightmost)
5620 +{
5621 +       if (!n->right) {
5622 +               *rightmost = n;
5623 +               return n->left;
5624 +       }
5625 +       n->right = remove_rightmost(n->right, rightmost);
5626         return balance(n);
5627  }
5628
5629 @@ -122,7 +129,13 @@ static struct node *remove(struct node *
5630         c = cmp(k, (*n)->key);
5631         if (c == 0) {
5632                 struct node *r = *n;
5633 -               *n = movr(r->left, r->right);
5634 +               if (r->left) {
5635 +                       r->left = remove_rightmost(r->left, n);
5636 +                       (*n)->left = r->left;
5637 +                       (*n)->right = r->right;
5638 +                       *n = balance(*n);
5639 +               } else
5640 +                       *n = r->right;
5641                 free(r);
5642                 return parent;
5643         }
5644 @@ -138,6 +151,8 @@ static struct node *remove(struct node *
5645  void *tdelete(const void *restrict key, void **restrict rootp,
5646         int(*compar)(const void *, const void *))
5647  {
5648 +       if (!rootp)
5649 +               return 0;
5650         struct node *n = *rootp;
5651         struct node *ret;
5652         /* last argument is arbitrary non-null pointer
5653 @@ -150,17 +165,21 @@ void *tdelete(const void *restrict key,
5654  void *tfind(const void *key, void *const *rootp,
5655         int(*compar)(const void *, const void *))
5656  {
5657 +       if (!rootp)
5658 +               return 0;
5659         return find(*rootp, key, compar);
5660  }
5661
5662  void *tsearch(const void *key, void **rootp,
5663         int (*compar)(const void *, const void *))
5664  {
5665 -       int new = 0;
5666 -       struct node *n = *rootp;
5667 +       struct node *update;
5668         struct node *ret;
5669 -       ret = insert(&n, key, compar, &new);
5670 -       *rootp = n;
5671 +       if (!rootp)
5672 +               return 0;
5673 +       update = insert(*rootp, key, compar, &ret);
5674 +       if (update)
5675 +               *rootp = update;
5676         return ret;
5677  }
5678
5679 --- a/src/setjmp/arm/longjmp.s
5680 +++ b/src/setjmp/arm/longjmp.s
5681 @@ -1,3 +1,4 @@
5682 +.syntax unified
5683  .global _longjmp
5684  .global longjmp
5685  .type _longjmp,%function
5686 @@ -20,7 +21,11 @@ longjmp:
5687         ldc p2, cr4, [ip], #48
5688  2:     tst r1,#0x40
5689         beq 2f
5690 -       .word 0xecbc8b10 /* vldmia ip!, {d8-d15} */
5691 +       .fpu vfp
5692 +       vldmia ip!, {d8-d15}
5693 +       .fpu softvfp
5694 +       .eabi_attribute 10, 0
5695 +       .eabi_attribute 27, 0
5696  2:     tst r1,#0x200
5697         beq 3f
5698         ldcl p1, cr10, [ip], #8
5699 @@ -29,9 +34,7 @@ longjmp:
5700         ldcl p1, cr13, [ip], #8
5701         ldcl p1, cr14, [ip], #8
5702         ldcl p1, cr15, [ip], #8
5703 -3:     tst lr,#1
5704 -       moveq pc,lr
5705 -       bx lr
5706 +3:     bx lr
5707
5708  .hidden __hwcap
5709  1:     .word __hwcap-1b
5710 --- a/src/setjmp/arm/setjmp.s
5711 +++ b/src/setjmp/arm/setjmp.s
5712 @@ -1,3 +1,4 @@
5713 +.syntax unified
5714  .global __setjmp
5715  .global _setjmp
5716  .global setjmp
5717 @@ -22,7 +23,11 @@ setjmp:
5718         stc p2, cr4, [ip], #48
5719  2:     tst r1,#0x40
5720         beq 2f
5721 -       .word 0xecac8b10 /* vstmia ip!, {d8-d15} */
5722 +       .fpu vfp
5723 +       vstmia ip!, {d8-d15}
5724 +       .fpu softvfp
5725 +       .eabi_attribute 10, 0
5726 +       .eabi_attribute 27, 0
5727  2:     tst r1,#0x200
5728         beq 3f
5729         stcl p1, cr10, [ip], #8
5730 @@ -31,9 +36,7 @@ setjmp:
5731         stcl p1, cr13, [ip], #8
5732         stcl p1, cr14, [ip], #8
5733         stcl p1, cr15, [ip], #8
5734 -3:     tst lr,#1
5735 -       moveq pc,lr
5736 -       bx lr
5737 +3:     bx lr
5738
5739  .hidden __hwcap
5740  1:     .word __hwcap-1b
5741 --- a/src/setjmp/mips-sf/longjmp.s
5742 +++ /dev/null
5743 @@ -1,25 +0,0 @@
5744 -.set noreorder
5745 -
5746 -.global _longjmp
5747 -.global longjmp
5748 -.type   _longjmp,@function
5749 -.type   longjmp,@function
5750 -_longjmp:
5751 -longjmp:
5752 -       move    $2, $5
5753 -       bne     $2, $0, 1f
5754 -       nop
5755 -       addu    $2, $2, 1
5756 -1:     lw      $ra,  0($4)
5757 -       lw      $sp,  4($4)
5758 -       lw      $16,  8($4)
5759 -       lw      $17, 12($4)
5760 -       lw      $18, 16($4)
5761 -       lw      $19, 20($4)
5762 -       lw      $20, 24($4)
5763 -       lw      $21, 28($4)
5764 -       lw      $22, 32($4)
5765 -       lw      $23, 36($4)
5766 -       lw      $30, 40($4)
5767 -       jr      $ra
5768 -       lw      $28, 44($4)
5769 --- a/src/setjmp/mips-sf/longjmp.sub
5770 +++ /dev/null
5771 @@ -1 +0,0 @@
5772 -longjmp.s
5773 --- a/src/setjmp/mips-sf/setjmp.s
5774 +++ /dev/null
5775 @@ -1,25 +0,0 @@
5776 -.set noreorder
5777 -
5778 -.global __setjmp
5779 -.global _setjmp
5780 -.global setjmp
5781 -.type   __setjmp,@function
5782 -.type   _setjmp,@function
5783 -.type   setjmp,@function
5784 -__setjmp:
5785 -_setjmp:
5786 -setjmp:
5787 -       sw      $ra,  0($4)
5788 -       sw      $sp,  4($4)
5789 -       sw      $16,  8($4)
5790 -       sw      $17, 12($4)
5791 -       sw      $18, 16($4)
5792 -       sw      $19, 20($4)
5793 -       sw      $20, 24($4)
5794 -       sw      $21, 28($4)
5795 -       sw      $22, 32($4)
5796 -       sw      $23, 36($4)
5797 -       sw      $30, 40($4)
5798 -       sw      $28, 44($4)
5799 -       jr      $ra
5800 -       li      $2, 0
5801 --- a/src/setjmp/mips-sf/setjmp.sub
5802 +++ /dev/null
5803 @@ -1 +0,0 @@
5804 -setjmp.s
5805 --- /dev/null
5806 +++ b/src/setjmp/mips/longjmp.S
5807 @@ -0,0 +1,40 @@
5808 +.set noreorder
5809 +
5810 +.global _longjmp
5811 +.global longjmp
5812 +.type   _longjmp,@function
5813 +.type   longjmp,@function
5814 +_longjmp:
5815 +longjmp:
5816 +       move    $2, $5
5817 +       bne     $2, $0, 1f
5818 +       nop
5819 +       addu    $2, $2, 1
5820 +1:
5821 +#ifndef __mips_soft_float
5822 +       lwc1    $20, 56($4)
5823 +       lwc1    $21, 60($4)
5824 +       lwc1    $22, 64($4)
5825 +       lwc1    $23, 68($4)
5826 +       lwc1    $24, 72($4)
5827 +       lwc1    $25, 76($4)
5828 +       lwc1    $26, 80($4)
5829 +       lwc1    $27, 84($4)
5830 +       lwc1    $28, 88($4)
5831 +       lwc1    $29, 92($4)
5832 +       lwc1    $30, 96($4)
5833 +       lwc1    $31, 100($4)
5834 +#endif
5835 +       lw      $ra,  0($4)
5836 +       lw      $sp,  4($4)
5837 +       lw      $16,  8($4)
5838 +       lw      $17, 12($4)
5839 +       lw      $18, 16($4)
5840 +       lw      $19, 20($4)
5841 +       lw      $20, 24($4)
5842 +       lw      $21, 28($4)
5843 +       lw      $22, 32($4)
5844 +       lw      $23, 36($4)
5845 +       lw      $30, 40($4)
5846 +       jr      $ra
5847 +       lw      $28, 44($4)
5848 --- a/src/setjmp/mips/longjmp.s
5849 +++ /dev/null
5850 @@ -1,37 +0,0 @@
5851 -.set noreorder
5852 -
5853 -.global _longjmp
5854 -.global longjmp
5855 -.type   _longjmp,@function
5856 -.type   longjmp,@function
5857 -_longjmp:
5858 -longjmp:
5859 -       move    $2, $5
5860 -       bne     $2, $0, 1f
5861 -       nop
5862 -       addu    $2, $2, 1
5863 -1:     lwc1    $20, 56($4)
5864 -       lwc1    $21, 60($4)
5865 -       lwc1    $22, 64($4)
5866 -       lwc1    $23, 68($4)
5867 -       lwc1    $24, 72($4)
5868 -       lwc1    $25, 76($4)
5869 -       lwc1    $26, 80($4)
5870 -       lwc1    $27, 84($4)
5871 -       lwc1    $28, 88($4)
5872 -       lwc1    $29, 92($4)
5873 -       lwc1    $30, 96($4)
5874 -       lwc1    $31, 100($4)
5875 -       lw      $ra,  0($4)
5876 -       lw      $sp,  4($4)
5877 -       lw      $16,  8($4)
5878 -       lw      $17, 12($4)
5879 -       lw      $18, 16($4)
5880 -       lw      $19, 20($4)
5881 -       lw      $20, 24($4)
5882 -       lw      $21, 28($4)
5883 -       lw      $22, 32($4)
5884 -       lw      $23, 36($4)
5885 -       lw      $30, 40($4)
5886 -       jr      $ra
5887 -       lw      $28, 44($4)
5888 --- /dev/null
5889 +++ b/src/setjmp/mips/setjmp.S
5890 @@ -0,0 +1,39 @@
5891 +.set noreorder
5892 +
5893 +.global __setjmp
5894 +.global _setjmp
5895 +.global setjmp
5896 +.type   __setjmp,@function
5897 +.type   _setjmp,@function
5898 +.type   setjmp,@function
5899 +__setjmp:
5900 +_setjmp:
5901 +setjmp:
5902 +       sw      $ra,  0($4)
5903 +       sw      $sp,  4($4)
5904 +       sw      $16,  8($4)
5905 +       sw      $17, 12($4)
5906 +       sw      $18, 16($4)
5907 +       sw      $19, 20($4)
5908 +       sw      $20, 24($4)
5909 +       sw      $21, 28($4)
5910 +       sw      $22, 32($4)
5911 +       sw      $23, 36($4)
5912 +       sw      $30, 40($4)
5913 +       sw      $28, 44($4)
5914 +#ifndef __mips_soft_float
5915 +       swc1    $20, 56($4)
5916 +       swc1    $21, 60($4)
5917 +       swc1    $22, 64($4)
5918 +       swc1    $23, 68($4)
5919 +       swc1    $24, 72($4)
5920 +       swc1    $25, 76($4)
5921 +       swc1    $26, 80($4)
5922 +       swc1    $27, 84($4)
5923 +       swc1    $28, 88($4)
5924 +       swc1    $29, 92($4)
5925 +       swc1    $30, 96($4)
5926 +       swc1    $31, 100($4)
5927 +#endif
5928 +       jr      $ra
5929 +       li      $2, 0
5930 --- a/src/setjmp/mips/setjmp.s
5931 +++ /dev/null
5932 @@ -1,37 +0,0 @@
5933 -.set noreorder
5934 -
5935 -.global __setjmp
5936 -.global _setjmp
5937 -.global setjmp
5938 -.type   __setjmp,@function
5939 -.type   _setjmp,@function
5940 -.type   setjmp,@function
5941 -__setjmp:
5942 -_setjmp:
5943 -setjmp:
5944 -       sw      $ra,  0($4)
5945 -       sw      $sp,  4($4)
5946 -       sw      $16,  8($4)
5947 -       sw      $17, 12($4)
5948 -       sw      $18, 16($4)
5949 -       sw      $19, 20($4)
5950 -       sw      $20, 24($4)
5951 -       sw      $21, 28($4)
5952 -       sw      $22, 32($4)
5953 -       sw      $23, 36($4)
5954 -       sw      $30, 40($4)
5955 -       sw      $28, 44($4)
5956 -       swc1    $20, 56($4)
5957 -       swc1    $21, 60($4)
5958 -       swc1    $22, 64($4)
5959 -       swc1    $23, 68($4)
5960 -       swc1    $24, 72($4)
5961 -       swc1    $25, 76($4)
5962 -       swc1    $26, 80($4)
5963 -       swc1    $27, 84($4)
5964 -       swc1    $28, 88($4)
5965 -       swc1    $29, 92($4)
5966 -       swc1    $30, 96($4)
5967 -       swc1    $31, 100($4)
5968 -       jr      $ra
5969 -       li      $2, 0
5970 --- a/src/setjmp/mipsel-sf/longjmp.sub
5971 +++ /dev/null
5972 @@ -1 +0,0 @@
5973 -../mips-sf/longjmp.s
5974 --- a/src/setjmp/mipsel-sf/setjmp.sub
5975 +++ /dev/null
5976 @@ -1 +0,0 @@
5977 -../mips-sf/setjmp.s
5978 --- a/src/setjmp/sh-nofpu/longjmp.s
5979 +++ /dev/null
5980 @@ -1,22 +0,0 @@
5981 -.global _longjmp
5982 -.global longjmp
5983 -.type   _longjmp, @function
5984 -.type   longjmp,  @function
5985 -_longjmp:
5986 -longjmp:
5987 -       mov.l  @r4+, r8
5988 -       mov.l  @r4+, r9
5989 -       mov.l  @r4+, r10
5990 -       mov.l  @r4+, r11
5991 -       mov.l  @r4+, r12
5992 -       mov.l  @r4+, r13
5993 -       mov.l  @r4+, r14
5994 -       mov.l  @r4+, r15
5995 -       lds.l  @r4+, pr
5996 -
5997 -       tst  r5, r5
5998 -       movt r0
5999 -       add  r5, r0
6000 -
6001 -       rts
6002 -        nop
6003 --- a/src/setjmp/sh-nofpu/longjmp.sub
6004 +++ /dev/null
6005 @@ -1 +0,0 @@
6006 -longjmp.s
6007 --- a/src/setjmp/sh-nofpu/setjmp.s
6008 +++ /dev/null
6009 @@ -1,24 +0,0 @@
6010 -.global ___setjmp
6011 -.hidden ___setjmp
6012 -.global __setjmp
6013 -.global _setjmp
6014 -.global setjmp
6015 -.type   __setjmp, @function
6016 -.type   _setjmp,  @function
6017 -.type   setjmp,   @function
6018 -___setjmp:
6019 -__setjmp:
6020 -_setjmp:
6021 -setjmp:
6022 -       add   #36, r4
6023 -       sts.l  pr,   @-r4
6024 -       mov.l  r15   @-r4
6025 -       mov.l  r14,  @-r4
6026 -       mov.l  r13,  @-r4
6027 -       mov.l  r12,  @-r4
6028 -       mov.l  r11,  @-r4
6029 -       mov.l  r10,  @-r4
6030 -       mov.l  r9,   @-r4
6031 -       mov.l  r8,   @-r4
6032 -       rts
6033 -        mov  #0, r0
6034 --- a/src/setjmp/sh-nofpu/setjmp.sub
6035 +++ /dev/null
6036 @@ -1 +0,0 @@
6037 -setjmp.s
6038 --- /dev/null
6039 +++ b/src/setjmp/sh/longjmp.S
6040 @@ -0,0 +1,28 @@
6041 +.global _longjmp
6042 +.global longjmp
6043 +.type   _longjmp, @function
6044 +.type   longjmp,  @function
6045 +_longjmp:
6046 +longjmp:
6047 +       mov.l  @r4+, r8
6048 +       mov.l  @r4+, r9
6049 +       mov.l  @r4+, r10
6050 +       mov.l  @r4+, r11
6051 +       mov.l  @r4+, r12
6052 +       mov.l  @r4+, r13
6053 +       mov.l  @r4+, r14
6054 +       mov.l  @r4+, r15
6055 +       lds.l  @r4+, pr
6056 +#if __SH_FPU_ANY__ || __SH4__
6057 +       fmov.s @r4+, fr12
6058 +       fmov.s @r4+, fr13
6059 +       fmov.s @r4+, fr14
6060 +       fmov.s @r4+, fr15
6061 +#endif
6062 +
6063 +       tst  r5, r5
6064 +       movt r0
6065 +       add  r5, r0
6066 +
6067 +       rts
6068 +        nop
6069 --- a/src/setjmp/sh/longjmp.s
6070 +++ /dev/null
6071 @@ -1,26 +0,0 @@
6072 -.global _longjmp
6073 -.global longjmp
6074 -.type   _longjmp, @function
6075 -.type   longjmp,  @function
6076 -_longjmp:
6077 -longjmp:
6078 -       mov.l  @r4+, r8
6079 -       mov.l  @r4+, r9
6080 -       mov.l  @r4+, r10
6081 -       mov.l  @r4+, r11
6082 -       mov.l  @r4+, r12
6083 -       mov.l  @r4+, r13
6084 -       mov.l  @r4+, r14
6085 -       mov.l  @r4+, r15
6086 -       lds.l  @r4+, pr
6087 -       fmov.s @r4+, fr12
6088 -       fmov.s @r4+, fr13
6089 -       fmov.s @r4+, fr14
6090 -       fmov.s @r4+, fr15
6091 -
6092 -       tst  r5, r5
6093 -       movt r0
6094 -       add  r5, r0
6095 -
6096 -       rts
6097 -        nop
6098 --- /dev/null
6099 +++ b/src/setjmp/sh/setjmp.S
6100 @@ -0,0 +1,32 @@
6101 +.global ___setjmp
6102 +.hidden ___setjmp
6103 +.global __setjmp
6104 +.global _setjmp
6105 +.global setjmp
6106 +.type   __setjmp, @function
6107 +.type   _setjmp,  @function
6108 +.type   setjmp,   @function
6109 +___setjmp:
6110 +__setjmp:
6111 +_setjmp:
6112 +setjmp:
6113 +#if __SH_FPU_ANY__ || __SH4__
6114 +       add   #52, r4
6115 +       fmov.s fr15, @-r4
6116 +       fmov.s fr14, @-r4
6117 +       fmov.s fr13, @-r4
6118 +       fmov.s fr12, @-r4
6119 +#else
6120 +       add   #36, r4
6121 +#endif
6122 +       sts.l  pr,   @-r4
6123 +       mov.l  r15,  @-r4
6124 +       mov.l  r14,  @-r4
6125 +       mov.l  r13,  @-r4
6126 +       mov.l  r12,  @-r4
6127 +       mov.l  r11,  @-r4
6128 +       mov.l  r10,  @-r4
6129 +       mov.l  r9,   @-r4
6130 +       mov.l  r8,   @-r4
6131 +       rts
6132 +        mov  #0, r0
6133 --- a/src/setjmp/sh/setjmp.s
6134 +++ /dev/null
6135 @@ -1,28 +0,0 @@
6136 -.global ___setjmp
6137 -.hidden ___setjmp
6138 -.global __setjmp
6139 -.global _setjmp
6140 -.global setjmp
6141 -.type   __setjmp, @function
6142 -.type   _setjmp,  @function
6143 -.type   setjmp,   @function
6144 -___setjmp:
6145 -__setjmp:
6146 -_setjmp:
6147 -setjmp:
6148 -       add   #52, r4
6149 -       fmov.s fr15, @-r4
6150 -       fmov.s fr14, @-r4
6151 -       fmov.s fr13, @-r4
6152 -       fmov.s fr12, @-r4
6153 -       sts.l  pr,   @-r4
6154 -       mov.l  r15,  @-r4
6155 -       mov.l  r14,  @-r4
6156 -       mov.l  r13,  @-r4
6157 -       mov.l  r12,  @-r4
6158 -       mov.l  r11,  @-r4
6159 -       mov.l  r10,  @-r4
6160 -       mov.l  r9,   @-r4
6161 -       mov.l  r8,   @-r4
6162 -       rts
6163 -        mov  #0, r0
6164 --- a/src/setjmp/sheb-nofpu/longjmp.sub
6165 +++ /dev/null
6166 @@ -1 +0,0 @@
6167 -../sh-nofpu/longjmp.s
6168 --- a/src/setjmp/sheb-nofpu/setjmp.sub
6169 +++ /dev/null
6170 @@ -1 +0,0 @@
6171 -../sh-nofpu/setjmp.s
6172 --- a/src/signal/arm/restore.s
6173 +++ b/src/signal/arm/restore.s
6174 @@ -1,3 +1,5 @@
6175 +.syntax unified
6176 +
6177  .global __restore
6178  .type __restore,%function
6179  __restore:
6180 --- a/src/signal/arm/sigsetjmp.s
6181 +++ b/src/signal/arm/sigsetjmp.s
6182 @@ -1,3 +1,4 @@
6183 +.syntax unified
6184  .global sigsetjmp
6185  .global __sigsetjmp
6186  .type sigsetjmp,%function
6187 --- a/src/signal/sigaction.c
6188 +++ b/src/signal/sigaction.c
6189 @@ -17,10 +17,6 @@ void __get_handler_set(sigset_t *set)
6190  int __libc_sigaction(int sig, const struct sigaction *restrict sa, struct sigaction *restrict old)
6191  {
6192         struct k_sigaction ksa, ksa_old;
6193 -       if (sig >= (unsigned)_NSIG) {
6194 -               errno = EINVAL;
6195 -               return -1;
6196 -       }
6197         if (sa) {
6198                 if ((uintptr_t)sa->sa_handler > 1UL) {
6199                         a_or_l(handler_set+(sig-1)/(8*sizeof(long)),
6200 @@ -57,7 +53,7 @@ int __libc_sigaction(int sig, const stru
6201
6202  int __sigaction(int sig, const struct sigaction *restrict sa, struct sigaction *restrict old)
6203  {
6204 -       if (sig-32U < 3) {
6205 +       if (sig-32U < 3 || sig-1U >= _NSIG-1) {
6206                 errno = EINVAL;
6207                 return -1;
6208         }
6209 --- a/src/signal/sigsetjmp_tail.c
6210 +++ b/src/signal/sigsetjmp_tail.c
6211 @@ -2,9 +2,7 @@
6212  #include <signal.h>
6213  #include "syscall.h"
6214
6215 -#ifdef SHARED
6216  __attribute__((__visibility__("hidden")))
6217 -#endif
6218  int __sigsetjmp_tail(sigjmp_buf jb, int ret)
6219  {
6220         void *p = jb->__ss;
6221 --- a/src/stdio/getdelim.c
6222 +++ b/src/stdio/getdelim.c
6223 @@ -27,17 +27,18 @@ ssize_t getdelim(char **restrict s, size
6224         for (;;) {
6225                 z = memchr(f->rpos, delim, f->rend - f->rpos);
6226                 k = z ? z - f->rpos + 1 : f->rend - f->rpos;
6227 -               if (i+k >= *n) {
6228 +               if (i+k+1 >= *n) {
6229                         if (k >= SIZE_MAX/2-i) goto oom;
6230 -                       *n = i+k+2;
6231 -                       if (*n < SIZE_MAX/4) *n *= 2;
6232 -                       tmp = realloc(*s, *n);
6233 +                       size_t m = i+k+2;
6234 +                       if (!z && m < SIZE_MAX/4) m += m/2;
6235 +                       tmp = realloc(*s, m);
6236                         if (!tmp) {
6237 -                               *n = i+k+2;
6238 -                               tmp = realloc(*s, *n);
6239 +                               m = i+k+2;
6240 +                               tmp = realloc(*s, m);
6241                                 if (!tmp) goto oom;
6242                         }
6243                         *s = tmp;
6244 +                       *n = m;
6245                 }
6246                 memcpy(*s+i, f->rpos, k);
6247                 f->rpos += k;
6248 --- /dev/null
6249 +++ b/src/string/arm/__aeabi_memclr.c
6250 @@ -0,0 +1,9 @@
6251 +#include <string.h>
6252 +#include "libc.h"
6253 +
6254 +void __aeabi_memclr(void *dest, size_t n)
6255 +{
6256 +       memset(dest, 0, n);
6257 +}
6258 +weak_alias(__aeabi_memclr, __aeabi_memclr4);
6259 +weak_alias(__aeabi_memclr, __aeabi_memclr8);
6260 --- /dev/null
6261 +++ b/src/string/arm/__aeabi_memcpy.c
6262 @@ -0,0 +1,9 @@
6263 +#include <string.h>
6264 +#include "libc.h"
6265 +
6266 +void __aeabi_memcpy(void *restrict dest, const void *restrict src, size_t n)
6267 +{
6268 +       memcpy(dest, src, n);
6269 +}
6270 +weak_alias(__aeabi_memcpy, __aeabi_memcpy4);
6271 +weak_alias(__aeabi_memcpy, __aeabi_memcpy8);
6272 --- /dev/null
6273 +++ b/src/string/arm/__aeabi_memmove.c
6274 @@ -0,0 +1,9 @@
6275 +#include <string.h>
6276 +#include "libc.h"
6277 +
6278 +void __aeabi_memmove(void *dest, const void *src, size_t n)
6279 +{
6280 +       memmove(dest, src, n);
6281 +}
6282 +weak_alias(__aeabi_memmove, __aeabi_memmove4);
6283 +weak_alias(__aeabi_memmove, __aeabi_memmove8);
6284 --- /dev/null
6285 +++ b/src/string/arm/__aeabi_memset.c
6286 @@ -0,0 +1,9 @@
6287 +#include <string.h>
6288 +#include "libc.h"
6289 +
6290 +void __aeabi_memset(void *dest, size_t n, int c)
6291 +{
6292 +       memset(dest, c, n);
6293 +}
6294 +weak_alias(__aeabi_memset, __aeabi_memset4);
6295 +weak_alias(__aeabi_memset, __aeabi_memset8);
6296 --- /dev/null
6297 +++ b/src/string/arm/memcpy.c
6298 @@ -0,0 +1,3 @@
6299 +#if __ARMEB__
6300 +#include "../memcpy.c"
6301 +#endif
6302 --- /dev/null
6303 +++ b/src/string/arm/memcpy_le.S
6304 @@ -0,0 +1,383 @@
6305 +#ifndef __ARMEB__
6306 +
6307 +/*
6308 + * Copyright (C) 2008 The Android Open Source Project
6309 + * All rights reserved.
6310 + *
6311 + * Redistribution and use in source and binary forms, with or without
6312 + * modification, are permitted provided that the following conditions
6313 + * are met:
6314 + *  * Redistributions of source code must retain the above copyright
6315 + *    notice, this list of conditions and the following disclaimer.
6316 + *  * Redistributions in binary form must reproduce the above copyright
6317 + *    notice, this list of conditions and the following disclaimer in
6318 + *    the documentation and/or other materials provided with the
6319 + *    distribution.
6320 + *
6321 + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
6322 + * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
6323 + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
6324 + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
6325 + * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
6326 + * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
6327 + * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
6328 + * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
6329 + * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
6330 + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
6331 + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
6332 + * SUCH DAMAGE.
6333 + */
6334 +
6335 +
6336 +/*
6337 + * Optimized memcpy() for ARM.
6338 + *
6339 + * note that memcpy() always returns the destination pointer,
6340 + * so we have to preserve R0.
6341 +  */
6342 +
6343 +/*
6344 + * This file has been modified from the original for use in musl libc.
6345 + * The main changes are: addition of .type memcpy,%function to make the
6346 + * code safely callable from thumb mode, adjusting the return
6347 + * instructions to be compatible with pre-thumb ARM cpus, and removal
6348 + * of prefetch code that is not compatible with older cpus.
6349 + */
6350 +
6351 +.syntax unified
6352 +
6353 +.global memcpy
6354 +.type memcpy,%function
6355 +memcpy:
6356 +       /* The stack must always be 64-bits aligned to be compliant with the
6357 +        * ARM ABI. Since we have to save R0, we might as well save R4
6358 +        * which we can use for better pipelining of the reads below
6359 +        */
6360 +       .fnstart
6361 +       .save       {r0, r4, lr}
6362 +       stmfd       sp!, {r0, r4, lr}
6363 +       /* Making room for r5-r11 which will be spilled later */
6364 +       .pad        #28
6365 +       sub         sp, sp, #28
6366 +
6367 +       /* it simplifies things to take care of len<4 early */
6368 +       cmp     r2, #4
6369 +       blo     copy_last_3_and_return
6370 +
6371 +       /* compute the offset to align the source
6372 +        * offset = (4-(src&3))&3 = -src & 3
6373 +        */
6374 +       rsb     r3, r1, #0
6375 +       ands    r3, r3, #3
6376 +       beq     src_aligned
6377 +
6378 +       /* align source to 32 bits. We need to insert 2 instructions between
6379 +        * a ldr[b|h] and str[b|h] because byte and half-word instructions
6380 +        * stall 2 cycles.
6381 +        */
6382 +       movs    r12, r3, lsl #31
6383 +       sub     r2, r2, r3              /* we know that r3 <= r2 because r2 >= 4 */
6384 +       ldrbmi r3, [r1], #1
6385 +       ldrbcs r4, [r1], #1
6386 +       ldrbcs r12,[r1], #1
6387 +       strbmi r3, [r0], #1
6388 +       strbcs r4, [r0], #1
6389 +       strbcs r12,[r0], #1
6390 +
6391 +src_aligned:
6392 +
6393 +       /* see if src and dst are aligned together (congruent) */
6394 +       eor     r12, r0, r1
6395 +       tst     r12, #3
6396 +       bne     non_congruent
6397 +
6398 +       /* Use post-incriment mode for stm to spill r5-r11 to reserved stack
6399 +        * frame. Don't update sp.
6400 +        */
6401 +       stmea   sp, {r5-r11}
6402 +
6403 +       /* align the destination to a cache-line */
6404 +       rsb     r3, r0, #0
6405 +       ands    r3, r3, #0x1C
6406 +       beq     congruent_aligned32
6407 +       cmp     r3, r2
6408 +       andhi   r3, r2, #0x1C
6409 +
6410 +       /* conditionnaly copies 0 to 7 words (length in r3) */
6411 +       movs    r12, r3, lsl #28
6412 +       ldmcs   r1!, {r4, r5, r6, r7}           /* 16 bytes */
6413 +       ldmmi   r1!, {r8, r9}                   /*  8 bytes */
6414 +       stmcs   r0!, {r4, r5, r6, r7}
6415 +       stmmi   r0!, {r8, r9}
6416 +       tst     r3, #0x4
6417 +       ldrne   r10,[r1], #4                    /*  4 bytes */
6418 +       strne   r10,[r0], #4
6419 +       sub     r2, r2, r3
6420 +
6421 +congruent_aligned32:
6422 +       /*
6423 +        * here source is aligned to 32 bytes.
6424 +        */
6425 +
6426 +cached_aligned32:
6427 +       subs    r2, r2, #32
6428 +       blo     less_than_32_left
6429 +
6430 +       /*
6431 +        * We preload a cache-line up to 64 bytes ahead. On the 926, this will
6432 +        * stall only until the requested world is fetched, but the linefill
6433 +        * continues in the the background.
6434 +        * While the linefill is going, we write our previous cache-line
6435 +        * into the write-buffer (which should have some free space).
6436 +        * When the linefill is done, the writebuffer will
6437 +        * start dumping its content into memory
6438 +        *
6439 +        * While all this is going, we then load a full cache line into
6440 +        * 8 registers, this cache line should be in the cache by now
6441 +        * (or partly in the cache).
6442 +        *
6443 +        * This code should work well regardless of the source/dest alignment.
6444 +        *
6445 +        */
6446 +
6447 +       /* Align the preload register to a cache-line because the cpu does
6448 +        * "critical word first" (the first word requested is loaded first).
6449 +        */
6450 +       @ bic           r12, r1, #0x1F
6451 +       @ add           r12, r12, #64
6452 +
6453 +1:      ldmia   r1!, { r4-r11 }
6454 +       subs    r2, r2, #32
6455 +
6456 +       /*
6457 +        * NOTE: if r12 is more than 64 ahead of r1, the following ldrhi
6458 +        * for ARM9 preload will not be safely guarded by the preceding subs.
6459 +        * When it is safely guarded the only possibility to have SIGSEGV here
6460 +        * is because the caller overstates the length.
6461 +        */
6462 +       @ ldrhi         r3, [r12], #32      /* cheap ARM9 preload */
6463 +       stmia   r0!, { r4-r11 }
6464 +       bhs     1b
6465 +
6466 +       add     r2, r2, #32
6467 +
6468 +less_than_32_left:
6469 +       /*
6470 +        * less than 32 bytes left at this point (length in r2)
6471 +        */
6472 +
6473 +       /* skip all this if there is nothing to do, which should
6474 +        * be a common case (if not executed the code below takes
6475 +        * about 16 cycles)
6476 +        */
6477 +       tst     r2, #0x1F
6478 +       beq     1f
6479 +
6480 +       /* conditionnaly copies 0 to 31 bytes */
6481 +       movs    r12, r2, lsl #28
6482 +       ldmcs   r1!, {r4, r5, r6, r7}           /* 16 bytes */
6483 +       ldmmi   r1!, {r8, r9}                   /*  8 bytes */
6484 +       stmcs   r0!, {r4, r5, r6, r7}
6485 +       stmmi   r0!, {r8, r9}
6486 +       movs    r12, r2, lsl #30
6487 +       ldrcs   r3, [r1], #4                    /*  4 bytes */
6488 +       ldrhmi r4, [r1], #2                     /*  2 bytes */
6489 +       strcs   r3, [r0], #4
6490 +       strhmi r4, [r0], #2
6491 +       tst     r2, #0x1
6492 +       ldrbne r3, [r1]                         /*  last byte  */
6493 +       strbne r3, [r0]
6494 +
6495 +       /* we're done! restore everything and return */
6496 +1:      ldmfd   sp!, {r5-r11}
6497 +       ldmfd   sp!, {r0, r4, lr}
6498 +       bx      lr
6499 +
6500 +       /********************************************************************/
6501 +
6502 +non_congruent:
6503 +       /*
6504 +        * here source is aligned to 4 bytes
6505 +        * but destination is not.
6506 +        *
6507 +        * in the code below r2 is the number of bytes read
6508 +        * (the number of bytes written is always smaller, because we have
6509 +        * partial words in the shift queue)
6510 +        */
6511 +       cmp     r2, #4
6512 +       blo     copy_last_3_and_return
6513 +
6514 +       /* Use post-incriment mode for stm to spill r5-r11 to reserved stack
6515 +        * frame. Don't update sp.
6516 +        */
6517 +       stmea   sp, {r5-r11}
6518 +
6519 +       /* compute shifts needed to align src to dest */
6520 +       rsb     r5, r0, #0
6521 +       and     r5, r5, #3                      /* r5 = # bytes in partial words */
6522 +       mov     r12, r5, lsl #3         /* r12 = right */
6523 +       rsb     lr, r12, #32            /* lr = left  */
6524 +
6525 +       /* read the first word */
6526 +       ldr     r3, [r1], #4
6527 +       sub     r2, r2, #4
6528 +
6529 +       /* write a partial word (0 to 3 bytes), such that destination
6530 +        * becomes aligned to 32 bits (r5 = nb of words to copy for alignment)
6531 +        */
6532 +       movs    r5, r5, lsl #31
6533 +       strbmi r3, [r0], #1
6534 +       movmi   r3, r3, lsr #8
6535 +       strbcs r3, [r0], #1
6536 +       movcs   r3, r3, lsr #8
6537 +       strbcs r3, [r0], #1
6538 +       movcs   r3, r3, lsr #8
6539 +
6540 +       cmp     r2, #4
6541 +       blo     partial_word_tail
6542 +
6543 +       /* Align destination to 32 bytes (cache line boundary) */
6544 +1:      tst     r0, #0x1c
6545 +       beq     2f
6546 +       ldr     r5, [r1], #4
6547 +       sub     r2, r2, #4
6548 +       orr     r4, r3, r5,             lsl lr
6549 +       mov     r3, r5,                 lsr r12
6550 +       str     r4, [r0], #4
6551 +       cmp     r2, #4
6552 +       bhs     1b
6553 +       blo     partial_word_tail
6554 +
6555 +       /* copy 32 bytes at a time */
6556 +2:      subs    r2, r2, #32
6557 +       blo     less_than_thirtytwo
6558 +
6559 +       /* Use immediate mode for the shifts, because there is an extra cycle
6560 +        * for register shifts, which could account for up to 50% of
6561 +        * performance hit.
6562 +        */
6563 +
6564 +       cmp     r12, #24
6565 +       beq     loop24
6566 +       cmp     r12, #8
6567 +       beq     loop8
6568 +
6569 +loop16:
6570 +       ldr     r12, [r1], #4
6571 +1:      mov     r4, r12
6572 +       ldmia   r1!, {   r5,r6,r7,  r8,r9,r10,r11}
6573 +       subs    r2, r2, #32
6574 +       ldrhs   r12, [r1], #4
6575 +       orr     r3, r3, r4, lsl #16
6576 +       mov     r4, r4, lsr #16
6577 +       orr     r4, r4, r5, lsl #16
6578 +       mov     r5, r5, lsr #16
6579 +       orr     r5, r5, r6, lsl #16
6580 +       mov     r6, r6, lsr #16
6581 +       orr     r6, r6, r7, lsl #16
6582 +       mov     r7, r7, lsr #16
6583 +       orr     r7, r7, r8, lsl #16
6584 +       mov     r8, r8, lsr #16
6585 +       orr     r8, r8, r9, lsl #16
6586 +       mov     r9, r9, lsr #16
6587 +       orr     r9, r9, r10, lsl #16
6588 +       mov     r10, r10,               lsr #16
6589 +       orr     r10, r10, r11, lsl #16
6590 +       stmia   r0!, {r3,r4,r5,r6, r7,r8,r9,r10}
6591 +       mov     r3, r11, lsr #16
6592 +       bhs     1b
6593 +       b       less_than_thirtytwo
6594 +
6595 +loop8:
6596 +       ldr     r12, [r1], #4
6597 +1:      mov     r4, r12
6598 +       ldmia   r1!, {   r5,r6,r7,  r8,r9,r10,r11}
6599 +       subs    r2, r2, #32
6600 +       ldrhs   r12, [r1], #4
6601 +       orr     r3, r3, r4, lsl #24
6602 +       mov     r4, r4, lsr #8
6603 +       orr     r4, r4, r5, lsl #24
6604 +       mov     r5, r5, lsr #8
6605 +       orr     r5, r5, r6, lsl #24
6606 +       mov     r6, r6,  lsr #8
6607 +       orr     r6, r6, r7, lsl #24
6608 +       mov     r7, r7,  lsr #8
6609 +       orr     r7, r7, r8,             lsl #24
6610 +       mov     r8, r8,  lsr #8
6611 +       orr     r8, r8, r9,             lsl #24
6612 +       mov     r9, r9,  lsr #8
6613 +       orr     r9, r9, r10,    lsl #24
6614 +       mov     r10, r10, lsr #8
6615 +       orr     r10, r10, r11,  lsl #24
6616 +       stmia   r0!, {r3,r4,r5,r6, r7,r8,r9,r10}
6617 +       mov     r3, r11, lsr #8
6618 +       bhs     1b
6619 +       b       less_than_thirtytwo
6620 +
6621 +loop24:
6622 +       ldr     r12, [r1], #4
6623 +1:      mov     r4, r12
6624 +       ldmia   r1!, {   r5,r6,r7,  r8,r9,r10,r11}
6625 +       subs    r2, r2, #32
6626 +       ldrhs   r12, [r1], #4
6627 +       orr     r3, r3, r4, lsl #8
6628 +       mov     r4, r4, lsr #24
6629 +       orr     r4, r4, r5, lsl #8
6630 +       mov     r5, r5, lsr #24
6631 +       orr     r5, r5, r6, lsl #8
6632 +       mov     r6, r6, lsr #24
6633 +       orr     r6, r6, r7, lsl #8
6634 +       mov     r7, r7, lsr #24
6635 +       orr     r7, r7, r8, lsl #8
6636 +       mov     r8, r8, lsr #24
6637 +       orr     r8, r8, r9, lsl #8
6638 +       mov     r9, r9, lsr #24
6639 +       orr     r9, r9, r10, lsl #8
6640 +       mov     r10, r10, lsr #24
6641 +       orr     r10, r10, r11, lsl #8
6642 +       stmia   r0!, {r3,r4,r5,r6, r7,r8,r9,r10}
6643 +       mov     r3, r11, lsr #24
6644 +       bhs     1b
6645 +
6646 +less_than_thirtytwo:
6647 +       /* copy the last 0 to 31 bytes of the source */
6648 +       rsb     r12, lr, #32            /* we corrupted r12, recompute it  */
6649 +       add     r2, r2, #32
6650 +       cmp     r2, #4
6651 +       blo     partial_word_tail
6652 +
6653 +1:      ldr     r5, [r1], #4
6654 +       sub     r2, r2, #4
6655 +       orr     r4, r3, r5,             lsl lr
6656 +       mov     r3,     r5,                     lsr r12
6657 +       str     r4, [r0], #4
6658 +       cmp     r2, #4
6659 +       bhs     1b
6660 +
6661 +partial_word_tail:
6662 +       /* we have a partial word in the input buffer */
6663 +       movs    r5, lr, lsl #(31-3)
6664 +       strbmi r3, [r0], #1
6665 +       movmi   r3, r3, lsr #8
6666 +       strbcs r3, [r0], #1
6667 +       movcs   r3, r3, lsr #8
6668 +       strbcs r3, [r0], #1
6669 +
6670 +       /* Refill spilled registers from the stack. Don't update sp. */
6671 +       ldmfd   sp, {r5-r11}
6672 +
6673 +copy_last_3_and_return:
6674 +       movs    r2, r2, lsl #31 /* copy remaining 0, 1, 2 or 3 bytes */
6675 +       ldrbmi r2, [r1], #1
6676 +       ldrbcs r3, [r1], #1
6677 +       ldrbcs r12,[r1]
6678 +       strbmi r2, [r0], #1
6679 +       strbcs r3, [r0], #1
6680 +       strbcs r12,[r0]
6681 +
6682 +       /* we're done! restore sp and spilled registers and return */
6683 +       add     sp,  sp, #28
6684 +       ldmfd   sp!, {r0, r4, lr}
6685 +       bx      lr
6686 +
6687 +#endif
6688 --- a/src/string/armel/memcpy.s
6689 +++ /dev/null
6690 @@ -1,381 +0,0 @@
6691 -/*
6692 - * Copyright (C) 2008 The Android Open Source Project
6693 - * All rights reserved.
6694 - *
6695 - * Redistribution and use in source and binary forms, with or without
6696 - * modification, are permitted provided that the following conditions
6697 - * are met:
6698 - *  * Redistributions of source code must retain the above copyright
6699 - *    notice, this list of conditions and the following disclaimer.
6700 - *  * Redistributions in binary form must reproduce the above copyright
6701 - *    notice, this list of conditions and the following disclaimer in
6702 - *    the documentation and/or other materials provided with the
6703 - *    distribution.
6704 - *
6705 - * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
6706 - * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
6707 - * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
6708 - * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
6709 - * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
6710 - * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
6711 - * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
6712 - * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
6713 - * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
6714 - * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
6715 - * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
6716 - * SUCH DAMAGE.
6717 - */
6718 -
6719 -
6720 -/*
6721 - * Optimized memcpy() for ARM.
6722 - *
6723 - * note that memcpy() always returns the destination pointer,
6724 - * so we have to preserve R0.
6725 -  */
6726 -
6727 -/*
6728 - * This file has been modified from the original for use in musl libc.
6729 - * The main changes are: addition of .type memcpy,%function to make the
6730 - * code safely callable from thumb mode, adjusting the return
6731 - * instructions to be compatible with pre-thumb ARM cpus, and removal
6732 - * of prefetch code that is not compatible with older cpus.
6733 - */
6734 -
6735 -.global memcpy
6736 -.type memcpy,%function
6737 -memcpy:
6738 -       /* The stack must always be 64-bits aligned to be compliant with the
6739 -        * ARM ABI. Since we have to save R0, we might as well save R4
6740 -        * which we can use for better pipelining of the reads below
6741 -        */
6742 -       .fnstart
6743 -       .save       {r0, r4, lr}
6744 -       stmfd       sp!, {r0, r4, lr}
6745 -       /* Making room for r5-r11 which will be spilled later */
6746 -       .pad        #28
6747 -       sub         sp, sp, #28
6748 -
6749 -       /* it simplifies things to take care of len<4 early */
6750 -       cmp     r2, #4
6751 -       blo     copy_last_3_and_return
6752 -
6753 -       /* compute the offset to align the source
6754 -        * offset = (4-(src&3))&3 = -src & 3
6755 -        */
6756 -       rsb     r3, r1, #0
6757 -       ands    r3, r3, #3
6758 -       beq     src_aligned
6759 -
6760 -       /* align source to 32 bits. We need to insert 2 instructions between
6761 -        * a ldr[b|h] and str[b|h] because byte and half-word instructions
6762 -        * stall 2 cycles.
6763 -        */
6764 -       movs    r12, r3, lsl #31
6765 -       sub     r2, r2, r3              /* we know that r3 <= r2 because r2 >= 4 */
6766 -       .word 0x44d13001 /* ldrbmi r3, [r1], #1 */
6767 -       .word 0x24d14001 /* ldrbcs r4, [r1], #1 */
6768 -       .word 0x24d1c001 /* ldrbcs r12,[r1], #1 */
6769 -       .word 0x44c03001 /* strbmi r3, [r0], #1 */
6770 -       .word 0x24c04001 /* strbcs r4, [r0], #1 */
6771 -       .word 0x24c0c001 /* strbcs r12,[r0], #1 */
6772 -
6773 -src_aligned:
6774 -
6775 -       /* see if src and dst are aligned together (congruent) */
6776 -       eor     r12, r0, r1
6777 -       tst     r12, #3
6778 -       bne     non_congruent
6779 -
6780 -       /* Use post-incriment mode for stm to spill r5-r11 to reserved stack
6781 -        * frame. Don't update sp.
6782 -        */
6783 -       stmea   sp, {r5-r11}
6784 -
6785 -       /* align the destination to a cache-line */
6786 -       rsb     r3, r0, #0
6787 -       ands    r3, r3, #0x1C
6788 -       beq     congruent_aligned32
6789 -       cmp     r3, r2
6790 -       andhi   r3, r2, #0x1C
6791 -
6792 -       /* conditionnaly copies 0 to 7 words (length in r3) */
6793 -       movs    r12, r3, lsl #28
6794 -       ldmcs   r1!, {r4, r5, r6, r7}           /* 16 bytes */
6795 -       ldmmi   r1!, {r8, r9}                   /*  8 bytes */
6796 -       stmcs   r0!, {r4, r5, r6, r7}
6797 -       stmmi   r0!, {r8, r9}
6798 -       tst     r3, #0x4
6799 -       ldrne   r10,[r1], #4                    /*  4 bytes */
6800 -       strne   r10,[r0], #4
6801 -       sub     r2, r2, r3
6802 -
6803 -congruent_aligned32:
6804 -       /*
6805 -        * here source is aligned to 32 bytes.
6806 -        */
6807 -
6808 -cached_aligned32:
6809 -       subs    r2, r2, #32
6810 -       blo     less_than_32_left
6811 -
6812 -       /*
6813 -        * We preload a cache-line up to 64 bytes ahead. On the 926, this will
6814 -        * stall only until the requested world is fetched, but the linefill
6815 -        * continues in the the background.
6816 -        * While the linefill is going, we write our previous cache-line
6817 -        * into the write-buffer (which should have some free space).
6818 -        * When the linefill is done, the writebuffer will
6819 -        * start dumping its content into memory
6820 -        *
6821 -        * While all this is going, we then load a full cache line into
6822 -        * 8 registers, this cache line should be in the cache by now
6823 -        * (or partly in the cache).
6824 -        *
6825 -        * This code should work well regardless of the source/dest alignment.
6826 -        *
6827 -        */
6828 -
6829 -       /* Align the preload register to a cache-line because the cpu does
6830 -        * "critical word first" (the first word requested is loaded first).
6831 -        */
6832 -       @ bic           r12, r1, #0x1F
6833 -       @ add           r12, r12, #64
6834 -
6835 -1:      ldmia   r1!, { r4-r11 }
6836 -       subs    r2, r2, #32
6837 -
6838 -       /*
6839 -        * NOTE: if r12 is more than 64 ahead of r1, the following ldrhi
6840 -        * for ARM9 preload will not be safely guarded by the preceding subs.
6841 -        * When it is safely guarded the only possibility to have SIGSEGV here
6842 -        * is because the caller overstates the length.
6843 -        */
6844 -       @ ldrhi         r3, [r12], #32      /* cheap ARM9 preload */
6845 -       stmia   r0!, { r4-r11 }
6846 -       bhs     1b
6847 -
6848 -       add     r2, r2, #32
6849 -
6850 -less_than_32_left:
6851 -       /*
6852 -        * less than 32 bytes left at this point (length in r2)
6853 -        */
6854 -
6855 -       /* skip all this if there is nothing to do, which should
6856 -        * be a common case (if not executed the code below takes
6857 -        * about 16 cycles)
6858 -        */
6859 -       tst     r2, #0x1F
6860 -       beq     1f
6861 -
6862 -       /* conditionnaly copies 0 to 31 bytes */
6863 -       movs    r12, r2, lsl #28
6864 -       ldmcs   r1!, {r4, r5, r6, r7}           /* 16 bytes */
6865 -       ldmmi   r1!, {r8, r9}                   /*  8 bytes */
6866 -       stmcs   r0!, {r4, r5, r6, r7}
6867 -       stmmi   r0!, {r8, r9}
6868 -       movs    r12, r2, lsl #30
6869 -       ldrcs   r3, [r1], #4                    /*  4 bytes */
6870 -       .word 0x40d140b2 /* ldrhmi r4, [r1], #2 */ /*  2 bytes */
6871 -       strcs   r3, [r0], #4
6872 -       .word 0x40c040b2 /* strhmi r4, [r0], #2 */
6873 -       tst     r2, #0x1
6874 -       .word 0x15d13000 /* ldrbne r3, [r1] */  /*  last byte  */
6875 -       .word 0x15c03000 /* strbne r3, [r0] */
6876 -
6877 -       /* we're done! restore everything and return */
6878 -1:      ldmfd   sp!, {r5-r11}
6879 -       ldmfd   sp!, {r0, r4, lr}
6880 -       tst     lr, #1
6881 -       moveq   pc, lr
6882 -       bx      lr
6883 -
6884 -       /********************************************************************/
6885 -
6886 -non_congruent:
6887 -       /*
6888 -        * here source is aligned to 4 bytes
6889 -        * but destination is not.
6890 -        *
6891 -        * in the code below r2 is the number of bytes read
6892 -        * (the number of bytes written is always smaller, because we have
6893 -        * partial words in the shift queue)
6894 -        */
6895 -       cmp     r2, #4
6896 -       blo     copy_last_3_and_return
6897 -
6898 -       /* Use post-incriment mode for stm to spill r5-r11 to reserved stack
6899 -        * frame. Don't update sp.
6900 -        */
6901 -       stmea   sp, {r5-r11}
6902 -
6903 -       /* compute shifts needed to align src to dest */
6904 -       rsb     r5, r0, #0
6905 -       and     r5, r5, #3                      /* r5 = # bytes in partial words */
6906 -       mov     r12, r5, lsl #3         /* r12 = right */
6907 -       rsb     lr, r12, #32            /* lr = left  */
6908 -
6909 -       /* read the first word */
6910 -       ldr     r3, [r1], #4
6911 -       sub     r2, r2, #4
6912 -
6913 -       /* write a partial word (0 to 3 bytes), such that destination
6914 -        * becomes aligned to 32 bits (r5 = nb of words to copy for alignment)
6915 -        */
6916 -       movs    r5, r5, lsl #31
6917 -       .word 0x44c03001 /* strbmi r3, [r0], #1 */
6918 -       movmi   r3, r3, lsr #8
6919 -       .word 0x24c03001 /* strbcs r3, [r0], #1 */
6920 -       movcs   r3, r3, lsr #8
6921 -       .word 0x24c03001 /* strbcs r3, [r0], #1 */
6922 -       movcs   r3, r3, lsr #8
6923 -
6924 -       cmp     r2, #4
6925 -       blo     partial_word_tail
6926 -
6927 -       /* Align destination to 32 bytes (cache line boundary) */
6928 -1:      tst     r0, #0x1c
6929 -       beq     2f
6930 -       ldr     r5, [r1], #4
6931 -       sub     r2, r2, #4
6932 -       orr     r4, r3, r5,             lsl lr
6933 -       mov     r3, r5,                 lsr r12
6934 -       str     r4, [r0], #4
6935 -       cmp     r2, #4
6936 -       bhs     1b
6937 -       blo     partial_word_tail
6938 -
6939 -       /* copy 32 bytes at a time */
6940 -2:      subs    r2, r2, #32
6941 -       blo     less_than_thirtytwo
6942 -
6943 -       /* Use immediate mode for the shifts, because there is an extra cycle
6944 -        * for register shifts, which could account for up to 50% of
6945 -        * performance hit.
6946 -        */
6947 -
6948 -       cmp     r12, #24
6949 -       beq     loop24
6950 -       cmp     r12, #8
6951 -       beq     loop8
6952 -
6953 -loop16:
6954 -       ldr     r12, [r1], #4
6955 -1:      mov     r4, r12
6956 -       ldmia   r1!, {   r5,r6,r7,  r8,r9,r10,r11}
6957 -       subs    r2, r2, #32
6958 -       ldrhs   r12, [r1], #4
6959 -       orr     r3, r3, r4, lsl #16
6960 -       mov     r4, r4, lsr #16
6961 -       orr     r4, r4, r5, lsl #16
6962 -       mov     r5, r5, lsr #16
6963 -       orr     r5, r5, r6, lsl #16
6964 -       mov     r6, r6, lsr #16
6965 -       orr     r6, r6, r7, lsl #16
6966 -       mov     r7, r7, lsr #16
6967 -       orr     r7, r7, r8, lsl #16
6968 -       mov     r8, r8, lsr #16
6969 -       orr     r8, r8, r9, lsl #16
6970 -       mov     r9, r9, lsr #16
6971 -       orr     r9, r9, r10, lsl #16
6972 -       mov     r10, r10,               lsr #16
6973 -       orr     r10, r10, r11, lsl #16
6974 -       stmia   r0!, {r3,r4,r5,r6, r7,r8,r9,r10}
6975 -       mov     r3, r11, lsr #16
6976 -       bhs     1b
6977 -       b       less_than_thirtytwo
6978 -
6979 -loop8:
6980 -       ldr     r12, [r1], #4
6981 -1:      mov     r4, r12
6982 -       ldmia   r1!, {   r5,r6,r7,  r8,r9,r10,r11}
6983 -       subs    r2, r2, #32
6984 -       ldrhs   r12, [r1], #4
6985 -       orr     r3, r3, r4, lsl #24
6986 -       mov     r4, r4, lsr #8
6987 -       orr     r4, r4, r5, lsl #24
6988 -       mov     r5, r5, lsr #8
6989 -       orr     r5, r5, r6, lsl #24
6990 -       mov     r6, r6,  lsr #8
6991 -       orr     r6, r6, r7, lsl #24
6992 -       mov     r7, r7,  lsr #8
6993 -       orr     r7, r7, r8,             lsl #24
6994 -       mov     r8, r8,  lsr #8
6995 -       orr     r8, r8, r9,             lsl #24
6996 -       mov     r9, r9,  lsr #8
6997 -       orr     r9, r9, r10,    lsl #24
6998 -       mov     r10, r10, lsr #8
6999 -       orr     r10, r10, r11,  lsl #24
7000 -       stmia   r0!, {r3,r4,r5,r6, r7,r8,r9,r10}
7001 -       mov     r3, r11, lsr #8
7002 -       bhs     1b
7003 -       b       less_than_thirtytwo
7004 -
7005 -loop24:
7006 -       ldr     r12, [r1], #4
7007 -1:      mov     r4, r12
7008 -       ldmia   r1!, {   r5,r6,r7,  r8,r9,r10,r11}
7009 -       subs    r2, r2, #32
7010 -       ldrhs   r12, [r1], #4
7011 -       orr     r3, r3, r4, lsl #8
7012 -       mov     r4, r4, lsr #24
7013 -       orr     r4, r4, r5, lsl #8
7014 -       mov     r5, r5, lsr #24
7015 -       orr     r5, r5, r6, lsl #8
7016 -       mov     r6, r6, lsr #24
7017 -       orr     r6, r6, r7, lsl #8
7018 -       mov     r7, r7, lsr #24
7019 -       orr     r7, r7, r8, lsl #8
7020 -       mov     r8, r8, lsr #24
7021 -       orr     r8, r8, r9, lsl #8
7022 -       mov     r9, r9, lsr #24
7023 -       orr     r9, r9, r10, lsl #8
7024 -       mov     r10, r10, lsr #24
7025 -       orr     r10, r10, r11, lsl #8
7026 -       stmia   r0!, {r3,r4,r5,r6, r7,r8,r9,r10}
7027 -       mov     r3, r11, lsr #24
7028 -       bhs     1b
7029 -
7030 -less_than_thirtytwo:
7031 -       /* copy the last 0 to 31 bytes of the source */
7032 -       rsb     r12, lr, #32            /* we corrupted r12, recompute it  */
7033 -       add     r2, r2, #32
7034 -       cmp     r2, #4
7035 -       blo     partial_word_tail
7036 -
7037 -1:      ldr     r5, [r1], #4
7038 -       sub     r2, r2, #4
7039 -       orr     r4, r3, r5,             lsl lr
7040 -       mov     r3,     r5,                     lsr r12
7041 -       str     r4, [r0], #4
7042 -       cmp     r2, #4
7043 -       bhs     1b
7044 -
7045 -partial_word_tail:
7046 -       /* we have a partial word in the input buffer */
7047 -       movs    r5, lr, lsl #(31-3)
7048 -       .word 0x44c03001 /* strbmi r3, [r0], #1 */
7049 -       movmi   r3, r3, lsr #8
7050 -       .word 0x24c03001 /* strbcs r3, [r0], #1 */
7051 -       movcs   r3, r3, lsr #8
7052 -       .word 0x24c03001 /* strbcs r3, [r0], #1 */
7053 -
7054 -       /* Refill spilled registers from the stack. Don't update sp. */
7055 -       ldmfd   sp, {r5-r11}
7056 -
7057 -copy_last_3_and_return:
7058 -       movs    r2, r2, lsl #31 /* copy remaining 0, 1, 2 or 3 bytes */
7059 -       .word 0x44d12001 /* ldrbmi r2, [r1], #1 */
7060 -       .word 0x24d13001 /* ldrbcs r3, [r1], #1 */
7061 -       .word 0x25d1c000 /* ldrbcs r12,[r1] */
7062 -       .word 0x44c02001 /* strbmi r2, [r0], #1 */
7063 -       .word 0x24c03001 /* strbcs r3, [r0], #1 */
7064 -       .word 0x25c0c000 /* strbcs r12,[r0] */
7065 -
7066 -       /* we're done! restore sp and spilled registers and return */
7067 -       add     sp,  sp, #28
7068 -       ldmfd   sp!, {r0, r4, lr}
7069 -       tst     lr, #1
7070 -       moveq   pc, lr
7071 -       bx      lr
7072 --- a/src/string/armel/memcpy.sub
7073 +++ /dev/null
7074 @@ -1 +0,0 @@
7075 -memcpy.s
7076 --- a/src/string/armhf/memcpy.sub
7077 +++ /dev/null
7078 @@ -1 +0,0 @@
7079 -../armel/memcpy.s
7080 --- a/src/thread/__syscall_cp.c
7081 +++ b/src/thread/__syscall_cp.c
7082 @@ -1,9 +1,7 @@
7083  #include "pthread_impl.h"
7084  #include "syscall.h"
7085
7086 -#ifdef SHARED
7087  __attribute__((__visibility__("hidden")))
7088 -#endif
7089  long __syscall_cp_c();
7090
7091  static long sccp(syscall_arg_t nr,
7092 --- a/src/thread/__tls_get_addr.c
7093 +++ b/src/thread/__tls_get_addr.c
7094 @@ -1,16 +1,16 @@
7095  #include <stddef.h>
7096  #include "pthread_impl.h"
7097 +#include "libc.h"
7098 +
7099 +__attribute__((__visibility__("hidden")))
7100 +void *__tls_get_new(size_t *);
7101
7102  void *__tls_get_addr(size_t *v)
7103  {
7104         pthread_t self = __pthread_self();
7105 -#ifdef SHARED
7106 -       __attribute__((__visibility__("hidden")))
7107 -       void *__tls_get_new(size_t *);
7108         if (v[0]<=(size_t)self->dtv[0])
7109                 return (char *)self->dtv[v[0]]+v[1]+DTP_OFFSET;
7110         return __tls_get_new(v);
7111 -#else
7112 -       return (char *)self->dtv[1]+v[1]+DTP_OFFSET;
7113 -#endif
7114  }
7115 +
7116 +weak_alias(__tls_get_addr, __tls_get_new);
7117 --- a/src/thread/aarch64/syscall_cp.s
7118 +++ b/src/thread/aarch64/syscall_cp.s
7119 @@ -17,7 +17,7 @@
7120  __syscall_cp_asm:
7121  __cp_begin:
7122         ldr w0,[x0]
7123 -       cbnz w0,1f
7124 +       cbnz w0,__cp_cancel
7125         mov x8,x1
7126         mov x0,x2
7127         mov x1,x3
7128 @@ -28,6 +28,5 @@ __cp_begin:
7129         svc 0
7130  __cp_end:
7131         ret
7132 -
7133 -       // cbnz might not be able to jump far enough
7134 -1:     b __cancel
7135 +__cp_cancel:
7136 +       b __cancel
7137 --- /dev/null
7138 +++ b/src/thread/arm/__set_thread_area.c
7139 @@ -0,0 +1,49 @@
7140 +#include <stdint.h>
7141 +#include <elf.h>
7142 +#include "pthread_impl.h"
7143 +#include "libc.h"
7144 +
7145 +#define HWCAP_TLS (1 << 15)
7146 +
7147 +extern const unsigned char __attribute__((__visibility__("hidden")))
7148 +       __a_barrier_dummy[], __a_barrier_oldkuser[],
7149 +       __a_barrier_v6[], __a_barrier_v7[],
7150 +       __a_cas_dummy[], __a_cas_v6[], __a_cas_v7[],
7151 +       __a_gettp_dummy[];
7152 +
7153 +#define __a_barrier_kuser 0xffff0fa0
7154 +#define __a_cas_kuser 0xffff0fc0
7155 +#define __a_gettp_kuser 0xffff0fe0
7156 +
7157 +extern uintptr_t __attribute__((__visibility__("hidden")))
7158 +       __a_barrier_ptr, __a_cas_ptr, __a_gettp_ptr;
7159 +
7160 +#define SET(op,ver) (__a_##op##_ptr = \
7161 +       (uintptr_t)__a_##op##_##ver - (uintptr_t)__a_##op##_dummy)
7162 +
7163 +int __set_thread_area(void *p)
7164 +{
7165 +#if !__ARM_ARCH_7A__ && !__ARM_ARCH_7R__ && __ARM_ARCH < 7
7166 +       if (__hwcap & HWCAP_TLS) {
7167 +               size_t *aux;
7168 +               SET(cas, v7);
7169 +               SET(barrier, v7);
7170 +               for (aux=libc.auxv; *aux; aux+=2) {
7171 +                       if (*aux != AT_PLATFORM) continue;
7172 +                       const char *s = (void *)aux[1];
7173 +                       if (s[0]!='v' || s[1]!='6' || s[2]-'0'<10u) break;
7174 +                       SET(cas, v6);
7175 +                       SET(barrier, v6);
7176 +                       break;
7177 +               }
7178 +       } else {
7179 +               int ver = *(int *)0xffff0ffc;
7180 +               SET(gettp, kuser);
7181 +               SET(cas, kuser);
7182 +               SET(barrier, kuser);
7183 +               if (ver < 2) a_crash();
7184 +               if (ver < 3) SET(barrier, oldkuser);
7185 +       }
7186 +#endif
7187 +       return __syscall(0xf0005, p);
7188 +}
7189 --- a/src/thread/arm/__set_thread_area.s
7190 +++ /dev/null
7191 @@ -1 +0,0 @@
7192 -/* Replaced by C code in arch/arm/src */
7193 --- a/src/thread/arm/__unmapself.s
7194 +++ b/src/thread/arm/__unmapself.s
7195 @@ -1,3 +1,4 @@
7196 +.syntax unified
7197  .text
7198  .global __unmapself
7199  .type   __unmapself,%function
7200 --- /dev/null
7201 +++ b/src/thread/arm/atomics.s
7202 @@ -0,0 +1,111 @@
7203 +.syntax unified
7204 +.text
7205 +
7206 +.global __a_barrier
7207 +.hidden __a_barrier
7208 +.type __a_barrier,%function
7209 +__a_barrier:
7210 +       ldr ip,1f
7211 +       ldr ip,[pc,ip]
7212 +       add pc,pc,ip
7213 +1:     .word __a_barrier_ptr-1b
7214 +.global __a_barrier_dummy
7215 +.hidden __a_barrier_dummy
7216 +__a_barrier_dummy:
7217 +       bx lr
7218 +.global __a_barrier_oldkuser
7219 +.hidden __a_barrier_oldkuser
7220 +__a_barrier_oldkuser:
7221 +       push {r0,r1,r2,r3,ip,lr}
7222 +       mov r1,r0
7223 +       mov r2,sp
7224 +       ldr ip,=0xffff0fc0
7225 +       mov lr,pc
7226 +       mov pc,ip
7227 +       pop {r0,r1,r2,r3,ip,lr}
7228 +       bx lr
7229 +.global __a_barrier_v6
7230 +.hidden __a_barrier_v6
7231 +__a_barrier_v6:
7232 +       mcr p15,0,r0,c7,c10,5
7233 +       bx lr
7234 +.global __a_barrier_v7
7235 +.hidden __a_barrier_v7
7236 +__a_barrier_v7:
7237 +       .word 0xf57ff05b        /* dmb ish */
7238 +       bx lr
7239 +
7240 +.global __a_cas
7241 +.hidden __a_cas
7242 +.type __a_cas,%function
7243 +__a_cas:
7244 +       ldr ip,1f
7245 +       ldr ip,[pc,ip]
7246 +       add pc,pc,ip
7247 +1:     .word __a_cas_ptr-1b
7248 +.global __a_cas_dummy
7249 +.hidden __a_cas_dummy
7250 +__a_cas_dummy:
7251 +       mov r3,r0
7252 +       ldr r0,[r2]
7253 +       subs r0,r3,r0
7254 +       streq r1,[r2]
7255 +       bx lr
7256 +.global __a_cas_v6
7257 +.hidden __a_cas_v6
7258 +__a_cas_v6:
7259 +       mov r3,r0
7260 +       mcr p15,0,r0,c7,c10,5
7261 +1:     .word 0xe1920f9f        /* ldrex r0,[r2] */
7262 +       subs r0,r3,r0
7263 +       .word 0x01820f91        /* strexeq r0,r1,[r2] */
7264 +       teqeq r0,#1
7265 +       beq 1b
7266 +       mcr p15,0,r0,c7,c10,5
7267 +       bx lr
7268 +.global __a_cas_v7
7269 +.hidden __a_cas_v7
7270 +__a_cas_v7:
7271 +       mov r3,r0
7272 +       .word 0xf57ff05b        /* dmb ish */
7273 +1:     .word 0xe1920f9f        /* ldrex r0,[r2] */
7274 +       subs r0,r3,r0
7275 +       .word 0x01820f91        /* strexeq r0,r1,[r2] */
7276 +       teqeq r0,#1
7277 +       beq 1b
7278 +       .word 0xf57ff05b        /* dmb ish */
7279 +       bx lr
7280 +
7281 +.global __aeabi_read_tp
7282 +.type __aeabi_read_tp,%function
7283 +__aeabi_read_tp:
7284 +
7285 +.global __a_gettp
7286 +.hidden __a_gettp
7287 +.type __a_gettp,%function
7288 +__a_gettp:
7289 +       ldr r0,1f
7290 +       ldr r0,[pc,r0]
7291 +       add pc,pc,r0
7292 +1:     .word __a_gettp_ptr-1b
7293 +.global __a_gettp_dummy
7294 +.hidden __a_gettp_dummy
7295 +__a_gettp_dummy:
7296 +       mrc p15,0,r0,c13,c0,3
7297 +       bx lr
7298 +
7299 +.data
7300 +.global __a_barrier_ptr
7301 +.hidden __a_barrier_ptr
7302 +__a_barrier_ptr:
7303 +       .word 0
7304 +
7305 +.global __a_cas_ptr
7306 +.hidden __a_cas_ptr
7307 +__a_cas_ptr:
7308 +       .word 0
7309 +
7310 +.global __a_gettp_ptr
7311 +.hidden __a_gettp_ptr
7312 +__a_gettp_ptr:
7313 +       .word 0
7314 --- a/src/thread/arm/clone.s
7315 +++ b/src/thread/arm/clone.s
7316 @@ -1,3 +1,4 @@
7317 +.syntax unified
7318  .text
7319  .global __clone
7320  .type   __clone,%function
7321 @@ -15,8 +16,6 @@ __clone:
7322         tst r0,r0
7323         beq 1f
7324         ldmfd sp!,{r4,r5,r6,r7}
7325 -       tst lr,#1
7326 -       moveq pc,lr
7327         bx lr
7328
7329  1:     mov r0,r6
7330 --- a/src/thread/arm/syscall_cp.s
7331 +++ b/src/thread/arm/syscall_cp.s
7332 @@ -1,3 +1,4 @@
7333 +.syntax unified
7334  .global __cp_begin
7335  .hidden __cp_begin
7336  .global __cp_end
7337 @@ -22,8 +23,6 @@ __cp_begin:
7338         svc 0
7339  __cp_end:
7340         ldmfd sp!,{r4,r5,r6,r7,lr}
7341 -       tst lr,#1
7342 -       moveq pc,lr
7343         bx lr
7344  __cp_cancel:
7345         ldmfd sp!,{r4,r5,r6,r7,lr}
7346 --- a/src/thread/microblaze/syscall_cp.s
7347 +++ b/src/thread/microblaze/syscall_cp.s
7348 @@ -11,7 +11,7 @@
7349  __syscall_cp_asm:
7350  __cp_begin:
7351         lwi     r5, r5, 0
7352 -       bnei    r5, __cancel
7353 +       bnei    r5, __cp_cancel
7354         addi    r12, r6, 0
7355         add     r5, r7, r0
7356         add     r6, r8, r0
7357 @@ -23,3 +23,5 @@ __cp_begin:
7358  __cp_end:
7359         rtsd    r15, 8
7360         nop
7361 +__cp_cancel:
7362 +       bri     __cancel
7363 --- a/src/thread/or1k/syscall_cp.s
7364 +++ b/src/thread/or1k/syscall_cp.s
7365 @@ -12,7 +12,7 @@ __syscall_cp_asm:
7366  __cp_begin:
7367         l.lwz   r3, 0(r3)
7368         l.sfeqi r3, 0
7369 -       l.bnf   __cancel
7370 +       l.bnf   __cp_cancel
7371          l.ori  r11, r4, 0
7372         l.ori   r3, r5, 0
7373         l.ori   r4, r6, 0
7374 @@ -24,3 +24,6 @@ __cp_begin:
7375  __cp_end:
7376         l.jr    r9
7377          l.nop
7378 +__cp_cancel:
7379 +       l.j     __cancel
7380 +        l.nop
7381 --- a/src/thread/powerpc/syscall_cp.s
7382 +++ b/src/thread/powerpc/syscall_cp.s
7383 @@ -38,7 +38,7 @@ __cp_begin:
7384         cmpwi cr7, 0, 0 #compare r0 with 0, store result in cr7.
7385         beq+ cr7, 1f #jump to label 1 if r0 was 0
7386
7387 -       b __cancel #else call cancel
7388 +       b __cp_cancel #else call cancel
7389  1:
7390         #ok, the cancel flag was not set
7391         # syscall: number goes to r0, the rest 3-8
7392 @@ -55,3 +55,5 @@ __cp_end:
7393         #else negate result.
7394         neg 3, 3
7395         blr
7396 +__cp_cancel:
7397 +       b __cancel
7398 --- a/src/thread/pthread_cancel.c
7399 +++ b/src/thread/pthread_cancel.c
7400 @@ -1,12 +1,11 @@
7401 +#define _GNU_SOURCE
7402  #include <string.h>
7403  #include "pthread_impl.h"
7404  #include "syscall.h"
7405  #include "libc.h"
7406
7407 -#ifdef SHARED
7408  __attribute__((__visibility__("hidden")))
7409 -#endif
7410 -long __cancel(), __cp_cancel(), __syscall_cp_asm(), __syscall_cp_c();
7411 +long __cancel(), __syscall_cp_asm(), __syscall_cp_c();
7412
7413  long __cancel()
7414  {
7415 @@ -17,12 +16,6 @@ long __cancel()
7416         return -ECANCELED;
7417  }
7418
7419 -/* If __syscall_cp_asm has adjusted the stack pointer, it must provide a
7420 - * definition of __cp_cancel to undo those adjustments and call __cancel.
7421 - * Otherwise, __cancel provides a definition for __cp_cancel. */
7422 -
7423 -weak_alias(__cancel, __cp_cancel);
7424 -
7425  long __syscall_cp_asm(volatile void *, syscall_arg_t,
7426                        syscall_arg_t, syscall_arg_t, syscall_arg_t,
7427                        syscall_arg_t, syscall_arg_t, syscall_arg_t);
7428 @@ -52,24 +45,22 @@ static void _sigaddset(sigset_t *set, in
7429         set->__bits[s/8/sizeof *set->__bits] |= 1UL<<(s&8*sizeof *set->__bits-1);
7430  }
7431
7432 -#ifdef SHARED
7433  __attribute__((__visibility__("hidden")))
7434 -#endif
7435 -extern const char __cp_begin[1], __cp_end[1];
7436 +extern const char __cp_begin[1], __cp_end[1], __cp_cancel[1];
7437
7438  static void cancel_handler(int sig, siginfo_t *si, void *ctx)
7439  {
7440         pthread_t self = __pthread_self();
7441         ucontext_t *uc = ctx;
7442 -       const char *ip = ((char **)&uc->uc_mcontext)[CANCEL_REG_IP];
7443 +       uintptr_t pc = uc->uc_mcontext.MC_PC;
7444
7445         a_barrier();
7446         if (!self->cancel || self->canceldisable == PTHREAD_CANCEL_DISABLE) return;
7447
7448         _sigaddset(&uc->uc_sigmask, SIGCANCEL);
7449
7450 -       if (self->cancelasync || ip >= __cp_begin && ip < __cp_end) {
7451 -               ((char **)&uc->uc_mcontext)[CANCEL_REG_IP] = (char *)__cp_cancel;
7452 +       if (self->cancelasync || pc >= (uintptr_t)__cp_begin && pc < (uintptr_t)__cp_end) {
7453 +               uc->uc_mcontext.MC_PC = (uintptr_t)__cp_cancel;
7454                 return;
7455         }
7456
7457 --- /dev/null
7458 +++ b/src/thread/sh/__set_thread_area.c
7459 @@ -0,0 +1,40 @@
7460 +#include "pthread_impl.h"
7461 +#include "libc.h"
7462 +#include <elf.h>
7463 +
7464 +/* Also perform sh-specific init */
7465 +
7466 +#define CPU_HAS_LLSC 0x0040
7467 +#define CPU_HAS_CAS_L 0x0400
7468 +
7469 +__attribute__((__visibility__("hidden")))
7470 +extern const char __sh_cas_gusa[], __sh_cas_llsc[], __sh_cas_imask[], __sh_cas_cas_l[];
7471 +
7472 +__attribute__((__visibility__("hidden")))
7473 +const void *__sh_cas_ptr;
7474 +
7475 +__attribute__((__visibility__("hidden")))
7476 +unsigned __sh_nommu;
7477 +
7478 +int __set_thread_area(void *p)
7479 +{
7480 +       size_t *aux;
7481 +       __asm__ __volatile__ ( "ldc %0, gbr" : : "r"(p) : "memory" );
7482 +#ifndef __SH4A__
7483 +       __sh_cas_ptr = __sh_cas_gusa;
7484 +#if !defined(__SH3__) && !defined(__SH4__)
7485 +       for (aux=libc.auxv; *aux; aux+=2) {
7486 +               if (*aux != AT_PLATFORM) continue;
7487 +               const char *s = (void *)aux[1];
7488 +               if (s[0]!='s' || s[1]!='h' || s[2]!='2' || s[3]-'0'<10u) break;
7489 +               __sh_cas_ptr = __sh_cas_imask;
7490 +               __sh_nommu = 1;
7491 +       }
7492 +#endif
7493 +       if (__hwcap & CPU_HAS_CAS_L)
7494 +               __sh_cas_ptr = __sh_cas_cas_l;
7495 +       else if (__hwcap & CPU_HAS_LLSC)
7496 +               __sh_cas_ptr = __sh_cas_llsc;
7497 +#endif
7498 +       return 0;
7499 +}
7500 --- /dev/null
7501 +++ b/src/thread/sh/atomics.s
7502 @@ -0,0 +1,65 @@
7503 +/* Contract for all versions is same as cas.l r2,r3,@r0
7504 + * pr and r1 are also clobbered (by jsr & r1 as temp).
7505 + * r0,r2,r4-r15 must be preserved.
7506 + * r3 contains result (==r2 iff cas succeeded). */
7507 +
7508 +       .align 2
7509 +.global __sh_cas_gusa
7510 +.hidden __sh_cas_gusa
7511 +__sh_cas_gusa:
7512 +       mov.l r5,@-r15
7513 +       mov.l r4,@-r15
7514 +       mov r0,r4
7515 +       mova 1f,r0
7516 +       mov r15,r1
7517 +       mov #(0f-1f),r15
7518 +0:     mov.l @r4,r5
7519 +       cmp/eq r5,r2
7520 +       bf 1f
7521 +       mov.l r3,@r4
7522 +1:     mov r1,r15
7523 +       mov r5,r3
7524 +       mov r4,r0
7525 +       mov.l @r15+,r4
7526 +       rts
7527 +        mov.l @r15+,r5
7528 +
7529 +.global __sh_cas_llsc
7530 +.hidden __sh_cas_llsc
7531 +__sh_cas_llsc:
7532 +       mov r0,r1
7533 +       synco
7534 +0:     movli.l @r1,r0
7535 +       cmp/eq r0,r2
7536 +       bf 1f
7537 +       mov r3,r0
7538 +       movco.l r0,@r1
7539 +       bf 0b
7540 +       mov r2,r0
7541 +1:     synco
7542 +       mov r0,r3
7543 +       rts
7544 +        mov r1,r0
7545 +
7546 +.global __sh_cas_imask
7547 +.hidden __sh_cas_imask
7548 +__sh_cas_imask:
7549 +       mov r0,r1
7550 +       stc sr,r0
7551 +       mov.l r0,@-r15
7552 +       or #0xf0,r0
7553 +       ldc r0,sr
7554 +       mov.l @r1,r0
7555 +       cmp/eq r0,r2
7556 +       bf 1f
7557 +       mov.l r3,@r1
7558 +1:     ldc.l @r15+,sr
7559 +       mov r0,r3
7560 +       rts
7561 +        mov r1,r0
7562 +
7563 +.global __sh_cas_cas_l
7564 +.hidden __sh_cas_cas_l
7565 +__sh_cas_cas_l:
7566 +       rts
7567 +        .word 0x2323 /* cas.l r2,r3,@r0 */
7568 --- a/src/thread/sh/syscall_cp.s
7569 +++ b/src/thread/sh/syscall_cp.s
7570 @@ -14,17 +14,8 @@ __syscall_cp_asm:
7571  __cp_begin:
7572         mov.l @r4, r4
7573         tst   r4, r4
7574 -       bt    2f
7575 -
7576 -       mov.l L1, r0
7577 -       braf  r0
7578 -        nop
7579 -1:
7580 -
7581 -.align 2
7582 -L1:    .long __cancel@PLT-(1b-.)
7583 -
7584 -2:     mov   r5, r3
7585 +       bf    __cp_cancel
7586 +       mov   r5, r3
7587         mov   r6, r4
7588         mov   r7, r5
7589         mov.l @r15, r6
7590 @@ -43,3 +34,12 @@ __cp_end:
7591
7592         rts
7593          nop
7594 +
7595 +__cp_cancel:
7596 +       mov.l 2f, r0
7597 +       braf  r0
7598 +        nop
7599 +1:
7600 +
7601 +.align 2
7602 +2:     .long __cancel@PCREL-(1b-.)
7603 --- a/src/thread/x32/syscall_cp.s
7604 +++ b/src/thread/x32/syscall_cp.s
7605 @@ -14,7 +14,7 @@ __syscall_cp_internal:
7606  __cp_begin:
7607         mov (%rdi),%eax
7608         test %eax,%eax
7609 -       jnz __cancel
7610 +       jnz __cp_cancel
7611         mov %rdi,%r11
7612         mov %rsi,%rax
7613         mov %rdx,%rdi
7614 @@ -27,3 +27,5 @@ __cp_begin:
7615         syscall
7616  __cp_end:
7617         ret
7618 +__cp_cancel:
7619 +       jmp __cancel
7620 --- a/src/thread/x86_64/syscall_cp.s
7621 +++ b/src/thread/x86_64/syscall_cp.s
7622 @@ -14,7 +14,7 @@ __syscall_cp_asm:
7623  __cp_begin:
7624         mov (%rdi),%eax
7625         test %eax,%eax
7626 -       jnz __cancel
7627 +       jnz __cp_cancel
7628         mov %rdi,%r11
7629         mov %rsi,%rax
7630         mov %rdx,%rdi
7631 @@ -27,3 +27,5 @@ __cp_begin:
7632         syscall
7633  __cp_end:
7634         ret
7635 +__cp_cancel:
7636 +       jmp __cancel